1/*
   2 * Driver for the VINO (Video In No Out) system found in SGI Indys.
   3 *
   4 * This file is subject to the terms and conditions of the GNU General Public
   5 * License version 2 as published by the Free Software Foundation.
   6 *
   7 * Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
   8 *
   9 * Based on the previous version of the driver for 2.4 kernels by:
  10 * Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
  11 *
  12 * v4l2_device/v4l2_subdev conversion by:
  13 * Copyright (C) 2009 Hans Verkuil <hverkuil@xs4all.nl>
  14 *
  15 * Note: this conversion is untested! Please contact the linux-media
  16 * mailinglist if you can test this, together with the test results.
  17 */
  18
  19/*
  20 * TODO:
  21 * - remove "mark pages reserved-hacks" from memory allocation code
  22 *   and implement fault()
  23 * - check decimation, calculating and reporting image size when
  24 *   using decimation
  25 * - implement read(), user mode buffers and overlay (?)
  26 */
  27
  28#include <linux/init.h>
  29#include <linux/module.h>
  30#include <linux/delay.h>
  31#include <linux/dma-mapping.h>
  32#include <linux/errno.h>
  33#include <linux/fs.h>
  34#include <linux/interrupt.h>
  35#include <linux/kernel.h>
  36#include <linux/slab.h>
  37#include <linux/mm.h>
  38#include <linux/time.h>
  39#include <linux/kmod.h>
  40
  41#include <linux/i2c.h>
  42
  43#include <linux/videodev2.h>
  44#include <media/v4l2-device.h>
  45#include <media/v4l2-ioctl.h>
  46#include <linux/mutex.h>
  47
  48#include <asm/paccess.h>
  49#include <asm/io.h>
  50#include <asm/sgi/ip22.h>
  51#include <asm/sgi/mc.h>
  52
  53#include "vino.h"
  54#include "saa7191.h"
  55#include "indycam.h"
  56
  57/* Uncomment the following line to get lots and lots of (mostly useless)
  58 * debug info.
  59 * Note that the debug output also slows down the driver significantly */
  60// #define VINO_DEBUG
  61// #define VINO_DEBUG_INT
  62
  63#define VINO_MODULE_VERSION "0.0.7"
  64
  65MODULE_DESCRIPTION("SGI VINO Video4Linux2 driver");
  66MODULE_VERSION(VINO_MODULE_VERSION);
  67MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
  68MODULE_LICENSE("GPL");
  69
  70#ifdef VINO_DEBUG
  71#define dprintk(x...) printk("VINO: " x);
  72#else
  73#define dprintk(x...)
  74#endif
  75
  76#define VINO_NO_CHANNEL			0
  77#define VINO_CHANNEL_A			1
  78#define VINO_CHANNEL_B			2
  79
  80#define VINO_PAL_WIDTH			768
  81#define VINO_PAL_HEIGHT			576
  82#define VINO_NTSC_WIDTH			640
  83#define VINO_NTSC_HEIGHT		480
  84
  85#define VINO_MIN_WIDTH			32
  86#define VINO_MIN_HEIGHT			32
  87
  88#define VINO_CLIPPING_START_ODD_D1	1
  89#define VINO_CLIPPING_START_ODD_PAL	15
  90#define VINO_CLIPPING_START_ODD_NTSC	12
  91
  92#define VINO_CLIPPING_START_EVEN_D1	2
  93#define VINO_CLIPPING_START_EVEN_PAL	15
  94#define VINO_CLIPPING_START_EVEN_NTSC	12
  95
  96#define VINO_INPUT_CHANNEL_COUNT	3
  97
  98/* the number is the index for vino_inputs */
  99#define VINO_INPUT_NONE			-1
 100#define VINO_INPUT_COMPOSITE		0
 101#define VINO_INPUT_SVIDEO		1
 102#define VINO_INPUT_D1			2
 103
 104#define VINO_PAGE_RATIO			(PAGE_SIZE / VINO_PAGE_SIZE)
 105
 106#define VINO_FIFO_THRESHOLD_DEFAULT	16
 107
 108#define VINO_FRAMEBUFFER_SIZE		((VINO_PAL_WIDTH \
 109					  * VINO_PAL_HEIGHT * 4 \
 110					  + 3 * PAGE_SIZE) & ~(PAGE_SIZE - 1))
 111
 112#define VINO_FRAMEBUFFER_COUNT_MAX	8
 113
 114#define VINO_FRAMEBUFFER_UNUSED		0
 115#define VINO_FRAMEBUFFER_IN_USE		1
 116#define VINO_FRAMEBUFFER_READY		2
 117
 118#define VINO_QUEUE_ERROR		-1
 119#define VINO_QUEUE_MAGIC		0x20050125
 120
 121#define VINO_MEMORY_NONE		0
 122#define VINO_MEMORY_MMAP		1
 123#define VINO_MEMORY_USERPTR		2
 124
 125#define VINO_DUMMY_DESC_COUNT		4
 126#define VINO_DESC_FETCH_DELAY		5	/* microseconds */
 127
 128#define VINO_MAX_FRAME_SKIP_COUNT	128
 129
 130/* the number is the index for vino_data_formats */
 131#define VINO_DATA_FMT_NONE		-1
 132#define VINO_DATA_FMT_GREY		0
 133#define VINO_DATA_FMT_RGB332		1
 134#define VINO_DATA_FMT_RGB32		2
 135#define VINO_DATA_FMT_YUV		3
 136
 137#define VINO_DATA_FMT_COUNT		4
 138
 139/* the number is the index for vino_data_norms */
 140#define VINO_DATA_NORM_NONE		-1
 141#define VINO_DATA_NORM_NTSC		0
 142#define VINO_DATA_NORM_PAL		1
 143#define VINO_DATA_NORM_SECAM		2
 144#define VINO_DATA_NORM_D1		3
 145
 146#define VINO_DATA_NORM_COUNT		4
 147
 148/* I2C controller flags */
 149#define SGI_I2C_FORCE_IDLE		(0 << 0)
 150#define SGI_I2C_NOT_IDLE		(1 << 0)
 151#define SGI_I2C_WRITE			(0 << 1)
 152#define SGI_I2C_READ			(1 << 1)
 153#define SGI_I2C_RELEASE_BUS		(0 << 2)
 154#define SGI_I2C_HOLD_BUS		(1 << 2)
 155#define SGI_I2C_XFER_DONE		(0 << 4)
 156#define SGI_I2C_XFER_BUSY		(1 << 4)
 157#define SGI_I2C_ACK			(0 << 5)
 158#define SGI_I2C_NACK			(1 << 5)
 159#define SGI_I2C_BUS_OK			(0 << 7)
 160#define SGI_I2C_BUS_ERR			(1 << 7)
 161
 162/* Internal data structure definitions */
 163
 164struct vino_input {
 165	char *name;
 166	v4l2_std_id std;
 167};
 168
 169struct vino_clipping {
 170	unsigned int left, right, top, bottom;
 171};
 172
 173struct vino_data_format {
 174	/* the description */
 175	char *description;
 176	/* bytes per pixel */
 177	unsigned int bpp;
 178	/* V4L2 fourcc code */
 179	__u32 pixelformat;
 180	/* V4L2 colorspace (duh!) */
 181	enum v4l2_colorspace colorspace;
 182};
 183
 184struct vino_data_norm {
 185	char *description;
 186	unsigned int width, height;
 187	struct vino_clipping odd;
 188	struct vino_clipping even;
 189
 190	v4l2_std_id std;
 191	unsigned int fps_min, fps_max;
 192	__u32 framelines;
 193};
 194
 195struct vino_descriptor_table {
 196	/* the number of PAGE_SIZE sized pages in the buffer */
 197	unsigned int page_count;
 198	/* virtual (kmalloc'd) pointers to the actual data
 199	 * (in PAGE_SIZE chunks, used with mmap streaming) */
 200	unsigned long *virtual;
 201
 202	/* cpu address for the VINO descriptor table
 203	 * (contains DMA addresses, VINO_PAGE_SIZE chunks) */
 204	unsigned long *dma_cpu;
 205	/* dma address for the VINO descriptor table
 206	 * (contains DMA addresses, VINO_PAGE_SIZE chunks) */
 207	dma_addr_t dma;
 208};
 209
 210struct vino_framebuffer {
 211	/* identifier nubmer */
 212	unsigned int id;
 213	/* the length of the whole buffer */
 214	unsigned int size;
 215	/* the length of actual data in buffer */
 216	unsigned int data_size;
 217	/* the data format */
 218	unsigned int data_format;
 219	/* the state of buffer data */
 220	unsigned int state;
 221	/* is the buffer mapped in user space? */
 222	unsigned int map_count;
 223	/* memory offset for mmap() */
 224	unsigned int offset;
 225	/* frame counter */
 226	unsigned int frame_counter;
 227	/* timestamp (written when image capture finishes) */
 228	struct timeval timestamp;
 229
 230	struct vino_descriptor_table desc_table;
 231
 232	spinlock_t state_lock;
 233};
 234
 235struct vino_framebuffer_fifo {
 236	unsigned int length;
 237
 238	unsigned int used;
 239	unsigned int head;
 240	unsigned int tail;
 241
 242	unsigned int data[VINO_FRAMEBUFFER_COUNT_MAX];
 243};
 244
 245struct vino_framebuffer_queue {
 246	unsigned int magic;
 247
 248	/* VINO_MEMORY_NONE, VINO_MEMORY_MMAP or VINO_MEMORY_USERPTR */
 249	unsigned int type;
 250	unsigned int length;
 251
 252	/* data field of in and out contain index numbers for buffer */
 253	struct vino_framebuffer_fifo in;
 254	struct vino_framebuffer_fifo out;
 255
 256	struct vino_framebuffer *buffer[VINO_FRAMEBUFFER_COUNT_MAX];
 257
 258	spinlock_t queue_lock;
 259	struct mutex queue_mutex;
 260	wait_queue_head_t frame_wait_queue;
 261};
 262
 263struct vino_interrupt_data {
 264	struct timeval timestamp;
 265	unsigned int frame_counter;
 266	unsigned int skip_count;
 267	unsigned int skip;
 268};
 269
 270struct vino_channel_settings {
 271	unsigned int channel;
 272
 273	int input;
 274	unsigned int data_format;
 275	unsigned int data_norm;
 276	struct vino_clipping clipping;
 277	unsigned int decimation;
 278	unsigned int line_size;
 279	unsigned int alpha;
 280	unsigned int fps;
 281	unsigned int framert_reg;
 282
 283	unsigned int fifo_threshold;
 284
 285	struct vino_framebuffer_queue fb_queue;
 286
 287	/* number of the current field */
 288	unsigned int field;
 289
 290	/* read in progress */
 291	int reading;
 292	/* streaming is active */
 293	int streaming;
 294	/* the driver is currently processing the queue */
 295	int capturing;
 296
 297	struct mutex mutex;
 298	spinlock_t capture_lock;
 299
 300	unsigned int users;
 301
 302	struct vino_interrupt_data int_data;
 303
 304	/* V4L support */
 305	struct video_device *vdev;
 306};
 307
 308struct vino_settings {
 309	struct v4l2_device v4l2_dev;
 310	struct vino_channel_settings a;
 311	struct vino_channel_settings b;
 312
 313	/* the channel which owns this client:
 314	 * VINO_NO_CHANNEL, VINO_CHANNEL_A or VINO_CHANNEL_B */
 315	unsigned int decoder_owner;
 316	struct v4l2_subdev *decoder;
 317	unsigned int camera_owner;
 318	struct v4l2_subdev *camera;
 319
 320	/* a lock for vino register access */
 321	spinlock_t vino_lock;
 322	/* a lock for channel input changes */
 323	spinlock_t input_lock;
 324
 325	unsigned long dummy_page;
 326	struct vino_descriptor_table dummy_desc_table;
 327};
 328
 329/* Module parameters */
 330
 331/*
 332 * Using vino_pixel_conversion the ABGR32-format pixels supplied
 333 * by the VINO chip can be converted to more common formats
 334 * like RGBA32 (or probably RGB24 in the future). This way we
 335 * can give out data that can be specified correctly with
 336 * the V4L2-definitions.
 337 *
 338 * The pixel format is specified as RGBA32 when no conversion
 339 * is used.
 340 *
 341 * Note that this only affects the 32-bit bit depth.
 342 *
 343 * Use non-zero value to enable conversion.
 344 */
 345static int vino_pixel_conversion;
 346
 347module_param_named(pixelconv, vino_pixel_conversion, int, 0);
 348
 349MODULE_PARM_DESC(pixelconv,
 350		 "enable pixel conversion (non-zero value enables)");
 351
 352/* Internal data structures */
 353
 354static struct sgi_vino *vino;
 355
 356static struct vino_settings *vino_drvdata;
 357
 358#define camera_call(o, f, args...) \
 359	v4l2_subdev_call(vino_drvdata->camera, o, f, ##args)
 360#define decoder_call(o, f, args...) \
 361	v4l2_subdev_call(vino_drvdata->decoder, o, f, ##args)
 362
 363static const char *vino_driver_name = "vino";
 364static const char *vino_driver_description = "SGI VINO";
 365static const char *vino_bus_name = "GIO64 bus";
 366static const char *vino_vdev_name_a = "SGI VINO Channel A";
 367static const char *vino_vdev_name_b = "SGI VINO Channel B";
 368
 369static void vino_capture_tasklet(unsigned long channel);
 370
 371DECLARE_TASKLET(vino_tasklet_a, vino_capture_tasklet, VINO_CHANNEL_A);
 372DECLARE_TASKLET(vino_tasklet_b, vino_capture_tasklet, VINO_CHANNEL_B);
 373
 374static const struct vino_input vino_inputs[] = {
 375	{
 376		.name		= "Composite",
 377		.std		= V4L2_STD_NTSC | V4L2_STD_PAL
 378		| V4L2_STD_SECAM,
 379	}, {
 380		.name		= "S-Video",
 381		.std		= V4L2_STD_NTSC | V4L2_STD_PAL
 382		| V4L2_STD_SECAM,
 383	}, {
 384		.name		= "D1/IndyCam",
 385		.std		= V4L2_STD_NTSC,
 386	}
 387};
 388
 389static const struct vino_data_format vino_data_formats[] = {
 390	{
 391		.description	= "8-bit greyscale",
 392		.bpp		= 1,
 393		.pixelformat	= V4L2_PIX_FMT_GREY,
 394		.colorspace	= V4L2_COLORSPACE_SMPTE170M,
 395	}, {
 396		.description	= "8-bit dithered RGB 3-3-2",
 397		.bpp		= 1,
 398		.pixelformat	= V4L2_PIX_FMT_RGB332,
 399		.colorspace	= V4L2_COLORSPACE_SRGB,
 400	}, {
 401		.description	= "32-bit RGB",
 402		.bpp		= 4,
 403		.pixelformat	= V4L2_PIX_FMT_RGB32,
 404		.colorspace	= V4L2_COLORSPACE_SRGB,
 405	}, {
 406		.description	= "YUV 4:2:2",
 407		.bpp		= 2,
 408		.pixelformat	= V4L2_PIX_FMT_YUYV, // XXX: swapped?
 409		.colorspace	= V4L2_COLORSPACE_SMPTE170M,
 410	}
 411};
 412
 413static const struct vino_data_norm vino_data_norms[] = {
 414	{
 415		.description	= "NTSC",
 416		.std		= V4L2_STD_NTSC,
 417		.fps_min	= 6,
 418		.fps_max	= 30,
 419		.framelines	= 525,
 420		.width		= VINO_NTSC_WIDTH,
 421		.height		= VINO_NTSC_HEIGHT,
 422		.odd		= {
 423			.top	= VINO_CLIPPING_START_ODD_NTSC,
 424			.left	= 0,
 425			.bottom	= VINO_CLIPPING_START_ODD_NTSC
 426			+ VINO_NTSC_HEIGHT / 2 - 1,
 427			.right	= VINO_NTSC_WIDTH,
 428		},
 429		.even		= {
 430			.top	= VINO_CLIPPING_START_EVEN_NTSC,
 431			.left	= 0,
 432			.bottom	= VINO_CLIPPING_START_EVEN_NTSC
 433			+ VINO_NTSC_HEIGHT / 2 - 1,
 434			.right	= VINO_NTSC_WIDTH,
 435		},
 436	}, {
 437		.description	= "PAL",
 438		.std		= V4L2_STD_PAL,
 439		.fps_min	= 5,
 440		.fps_max	= 25,
 441		.framelines	= 625,
 442		.width		= VINO_PAL_WIDTH,
 443		.height		= VINO_PAL_HEIGHT,
 444		.odd		= {
 445			.top	= VINO_CLIPPING_START_ODD_PAL,
 446			.left	= 0,
 447			.bottom	= VINO_CLIPPING_START_ODD_PAL
 448			+ VINO_PAL_HEIGHT / 2 - 1,
 449			.right	= VINO_PAL_WIDTH,
 450		},
 451		.even		= {
 452			.top	= VINO_CLIPPING_START_EVEN_PAL,
 453			.left	= 0,
 454			.bottom	= VINO_CLIPPING_START_EVEN_PAL
 455			+ VINO_PAL_HEIGHT / 2 - 1,
 456			.right	= VINO_PAL_WIDTH,
 457		},
 458	}, {
 459		.description	= "SECAM",
 460		.std		= V4L2_STD_SECAM,
 461		.fps_min	= 5,
 462		.fps_max	= 25,
 463		.framelines	= 625,
 464		.width		= VINO_PAL_WIDTH,
 465		.height		= VINO_PAL_HEIGHT,
 466		.odd		= {
 467			.top	= VINO_CLIPPING_START_ODD_PAL,
 468			.left	= 0,
 469			.bottom	= VINO_CLIPPING_START_ODD_PAL
 470			+ VINO_PAL_HEIGHT / 2 - 1,
 471			.right	= VINO_PAL_WIDTH,
 472		},
 473		.even		= {
 474			.top	= VINO_CLIPPING_START_EVEN_PAL,
 475			.left	= 0,
 476			.bottom	= VINO_CLIPPING_START_EVEN_PAL
 477			+ VINO_PAL_HEIGHT / 2 - 1,
 478			.right	= VINO_PAL_WIDTH,
 479		},
 480	}, {
 481		.description	= "NTSC/D1",
 482		.std		= V4L2_STD_NTSC,
 483		.fps_min	= 6,
 484		.fps_max	= 30,
 485		.framelines	= 525,
 486		.width		= VINO_NTSC_WIDTH,
 487		.height		= VINO_NTSC_HEIGHT,
 488		.odd		= {
 489			.top	= VINO_CLIPPING_START_ODD_D1,
 490			.left	= 0,
 491			.bottom	= VINO_CLIPPING_START_ODD_D1
 492			+ VINO_NTSC_HEIGHT / 2 - 1,
 493			.right	= VINO_NTSC_WIDTH,
 494		},
 495		.even		= {
 496			.top	= VINO_CLIPPING_START_EVEN_D1,
 497			.left	= 0,
 498			.bottom	= VINO_CLIPPING_START_EVEN_D1
 499			+ VINO_NTSC_HEIGHT / 2 - 1,
 500			.right	= VINO_NTSC_WIDTH,
 501		},
 502	}
 503};
 504
 505#define VINO_INDYCAM_V4L2_CONTROL_COUNT		9
 506
 507struct v4l2_queryctrl vino_indycam_v4l2_controls[] = {
 508	{
 509		.id = V4L2_CID_AUTOGAIN,
 510		.type = V4L2_CTRL_TYPE_BOOLEAN,
 511		.name = "Automatic Gain Control",
 512		.minimum = 0,
 513		.maximum = 1,
 514		.step = 1,
 515		.default_value = INDYCAM_AGC_DEFAULT,
 516	}, {
 517		.id = V4L2_CID_AUTO_WHITE_BALANCE,
 518		.type = V4L2_CTRL_TYPE_BOOLEAN,
 519		.name = "Automatic White Balance",
 520		.minimum = 0,
 521		.maximum = 1,
 522		.step = 1,
 523		.default_value = INDYCAM_AWB_DEFAULT,
 524	}, {
 525		.id = V4L2_CID_GAIN,
 526		.type = V4L2_CTRL_TYPE_INTEGER,
 527		.name = "Gain",
 528		.minimum = INDYCAM_GAIN_MIN,
 529		.maximum = INDYCAM_GAIN_MAX,
 530		.step = 1,
 531		.default_value = INDYCAM_GAIN_DEFAULT,
 532	}, {
 533		.id = INDYCAM_CONTROL_RED_SATURATION,
 534		.type = V4L2_CTRL_TYPE_INTEGER,
 535		.name = "Red Saturation",
 536		.minimum = INDYCAM_RED_SATURATION_MIN,
 537		.maximum = INDYCAM_RED_SATURATION_MAX,
 538		.step = 1,
 539		.default_value = INDYCAM_RED_SATURATION_DEFAULT,
 540	}, {
 541		.id = INDYCAM_CONTROL_BLUE_SATURATION,
 542		.type = V4L2_CTRL_TYPE_INTEGER,
 543		.name = "Blue Saturation",
 544		.minimum = INDYCAM_BLUE_SATURATION_MIN,
 545		.maximum = INDYCAM_BLUE_SATURATION_MAX,
 546		.step = 1,
 547		.default_value = INDYCAM_BLUE_SATURATION_DEFAULT,
 548	}, {
 549		.id = V4L2_CID_RED_BALANCE,
 550		.type = V4L2_CTRL_TYPE_INTEGER,
 551		.name = "Red Balance",
 552		.minimum = INDYCAM_RED_BALANCE_MIN,
 553		.maximum = INDYCAM_RED_BALANCE_MAX,
 554		.step = 1,
 555		.default_value = INDYCAM_RED_BALANCE_DEFAULT,
 556	}, {
 557		.id = V4L2_CID_BLUE_BALANCE,
 558		.type = V4L2_CTRL_TYPE_INTEGER,
 559		.name = "Blue Balance",
 560		.minimum = INDYCAM_BLUE_BALANCE_MIN,
 561		.maximum = INDYCAM_BLUE_BALANCE_MAX,
 562		.step = 1,
 563		.default_value = INDYCAM_BLUE_BALANCE_DEFAULT,
 564	}, {
 565		.id = V4L2_CID_EXPOSURE,
 566		.type = V4L2_CTRL_TYPE_INTEGER,
 567		.name = "Shutter Control",
 568		.minimum = INDYCAM_SHUTTER_MIN,
 569		.maximum = INDYCAM_SHUTTER_MAX,
 570		.step = 1,
 571		.default_value = INDYCAM_SHUTTER_DEFAULT,
 572	}, {
 573		.id = V4L2_CID_GAMMA,
 574		.type = V4L2_CTRL_TYPE_INTEGER,
 575		.name = "Gamma",
 576		.minimum = INDYCAM_GAMMA_MIN,
 577		.maximum = INDYCAM_GAMMA_MAX,
 578		.step = 1,
 579		.default_value = INDYCAM_GAMMA_DEFAULT,
 580	}
 581};
 582
 583#define VINO_SAA7191_V4L2_CONTROL_COUNT		9
 584
 585struct v4l2_queryctrl vino_saa7191_v4l2_controls[] = {
 586	{
 587		.id = V4L2_CID_HUE,
 588		.type = V4L2_CTRL_TYPE_INTEGER,
 589		.name = "Hue",
 590		.minimum = SAA7191_HUE_MIN,
 591		.maximum = SAA7191_HUE_MAX,
 592		.step = 1,
 593		.default_value = SAA7191_HUE_DEFAULT,
 594	}, {
 595		.id = SAA7191_CONTROL_BANDPASS,
 596		.type = V4L2_CTRL_TYPE_INTEGER,
 597		.name = "Luminance Bandpass",
 598		.minimum = SAA7191_BANDPASS_MIN,
 599		.maximum = SAA7191_BANDPASS_MAX,
 600		.step = 1,
 601		.default_value = SAA7191_BANDPASS_DEFAULT,
 602	}, {
 603		.id = SAA7191_CONTROL_BANDPASS_WEIGHT,
 604		.type = V4L2_CTRL_TYPE_INTEGER,
 605		.name = "Luminance Bandpass Weight",
 606		.minimum = SAA7191_BANDPASS_WEIGHT_MIN,
 607		.maximum = SAA7191_BANDPASS_WEIGHT_MAX,
 608		.step = 1,
 609		.default_value = SAA7191_BANDPASS_WEIGHT_DEFAULT,
 610	}, {
 611		.id = SAA7191_CONTROL_CORING,
 612		.type = V4L2_CTRL_TYPE_INTEGER,
 613		.name = "HF Luminance Coring",
 614		.minimum = SAA7191_CORING_MIN,
 615		.maximum = SAA7191_CORING_MAX,
 616		.step = 1,
 617		.default_value = SAA7191_CORING_DEFAULT,
 618	}, {
 619		.id = SAA7191_CONTROL_FORCE_COLOUR,
 620		.type = V4L2_CTRL_TYPE_BOOLEAN,
 621		.name = "Force Colour",
 622		.minimum = SAA7191_FORCE_COLOUR_MIN,
 623		.maximum = SAA7191_FORCE_COLOUR_MAX,
 624		.step = 1,
 625		.default_value = SAA7191_FORCE_COLOUR_DEFAULT,
 626	}, {
 627		.id = SAA7191_CONTROL_CHROMA_GAIN,
 628		.type = V4L2_CTRL_TYPE_INTEGER,
 629		.name = "Chrominance Gain Control",
 630		.minimum = SAA7191_CHROMA_GAIN_MIN,
 631		.maximum = SAA7191_CHROMA_GAIN_MAX,
 632		.step = 1,
 633		.default_value = SAA7191_CHROMA_GAIN_DEFAULT,
 634	}, {
 635		.id = SAA7191_CONTROL_VTRC,
 636		.type = V4L2_CTRL_TYPE_BOOLEAN,
 637		.name = "VTR Time Constant",
 638		.minimum = SAA7191_VTRC_MIN,
 639		.maximum = SAA7191_VTRC_MAX,
 640		.step = 1,
 641		.default_value = SAA7191_VTRC_DEFAULT,
 642	}, {
 643		.id = SAA7191_CONTROL_LUMA_DELAY,
 644		.type = V4L2_CTRL_TYPE_INTEGER,
 645		.name = "Luminance Delay Compensation",
 646		.minimum = SAA7191_LUMA_DELAY_MIN,
 647		.maximum = SAA7191_LUMA_DELAY_MAX,
 648		.step = 1,
 649		.default_value = SAA7191_LUMA_DELAY_DEFAULT,
 650	}, {
 651		.id = SAA7191_CONTROL_VNR,
 652		.type = V4L2_CTRL_TYPE_INTEGER,
 653		.name = "Vertical Noise Reduction",
 654		.minimum = SAA7191_VNR_MIN,
 655		.maximum = SAA7191_VNR_MAX,
 656		.step = 1,
 657		.default_value = SAA7191_VNR_DEFAULT,
 658	}
 659};
 660
 661/* VINO framebuffer/DMA descriptor management */
 662
 663static void vino_free_buffer_with_count(struct vino_framebuffer *fb,
 664					       unsigned int count)
 665{
 666	unsigned int i;
 667
 668	dprintk("vino_free_buffer_with_count(): count = %d\n", count);
 669
 670	for (i = 0; i < count; i++) {
 671		ClearPageReserved(virt_to_page((void *)fb->desc_table.virtual[i]));
 672		dma_unmap_single(NULL,
 673				 fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i],
 674				 PAGE_SIZE, DMA_FROM_DEVICE);
 675		free_page(fb->desc_table.virtual[i]);
 676	}
 677
 678	dma_free_coherent(NULL,
 679			  VINO_PAGE_RATIO * (fb->desc_table.page_count + 4) *
 680			  sizeof(dma_addr_t), (void *)fb->desc_table.dma_cpu,
 681			  fb->desc_table.dma);
 682	kfree(fb->desc_table.virtual);
 683
 684	memset(fb, 0, sizeof(struct vino_framebuffer));
 685}
 686
 687static void vino_free_buffer(struct vino_framebuffer *fb)
 688{
 689	vino_free_buffer_with_count(fb, fb->desc_table.page_count);
 690}
 691
 692static int vino_allocate_buffer(struct vino_framebuffer *fb,
 693				unsigned int size)
 694{
 695	unsigned int count, i, j;
 696	int ret = 0;
 697
 698	dprintk("vino_allocate_buffer():\n");
 699
 700	if (size < 1)
 701		return -EINVAL;
 702
 703	memset(fb, 0, sizeof(struct vino_framebuffer));
 704
 705	count = ((size / PAGE_SIZE) + 4) & ~3;
 706
 707	dprintk("vino_allocate_buffer(): size = %d, count = %d\n",
 708		size, count);
 709
 710	/* allocate memory for table with virtual (page) addresses */
 711	fb->desc_table.virtual =
 712		kmalloc(count * sizeof(unsigned long), GFP_KERNEL);
 713	if (!fb->desc_table.virtual)
 714		return -ENOMEM;
 715
 716	/* allocate memory for table with dma addresses
 717	 * (has space for four extra descriptors) */
 718	fb->desc_table.dma_cpu =
 719		dma_alloc_coherent(NULL, VINO_PAGE_RATIO * (count + 4) *
 720				   sizeof(dma_addr_t), &fb->desc_table.dma,
 721				   GFP_KERNEL | GFP_DMA);
 722	if (!fb->desc_table.dma_cpu) {
 723		ret = -ENOMEM;
 724		goto out_free_virtual;
 725	}
 726
 727	/* allocate pages for the buffer and acquire the according
 728	 * dma addresses */
 729	for (i = 0; i < count; i++) {
 730		dma_addr_t dma_data_addr;
 731
 732		fb->desc_table.virtual[i] =
 733			get_zeroed_page(GFP_KERNEL | GFP_DMA);
 734		if (!fb->desc_table.virtual[i]) {
 735			ret = -ENOBUFS;
 736			break;
 737		}
 738
 739		dma_data_addr =
 740			dma_map_single(NULL,
 741				       (void *)fb->desc_table.virtual[i],
 742				       PAGE_SIZE, DMA_FROM_DEVICE);
 743
 744		for (j = 0; j < VINO_PAGE_RATIO; j++) {
 745			fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i + j] =
 746				dma_data_addr + VINO_PAGE_SIZE * j;
 747		}
 748
 749		SetPageReserved(virt_to_page((void *)fb->desc_table.virtual[i]));
 750	}
 751
 752	/* page_count needs to be set anyway, because the descriptor table has
 753	 * been allocated according to this number */
 754	fb->desc_table.page_count = count;
 755
 756	if (ret) {
 757		/* the descriptor with index i doesn't contain
 758		 * a valid address yet */
 759		vino_free_buffer_with_count(fb, i);
 760		return ret;
 761	}
 762
 763	//fb->size = size;
 764	fb->size = count * PAGE_SIZE;
 765	fb->data_format = VINO_DATA_FMT_NONE;
 766
 767	/* set the dma stop-bit for the last (count+1)th descriptor */
 768	fb->desc_table.dma_cpu[VINO_PAGE_RATIO * count] = VINO_DESC_STOP;
 769	return 0;
 770
 771 out_free_virtual:
 772	kfree(fb->desc_table.virtual);
 773	return ret;
 774}
 775
 776#if 0
 777/* user buffers not fully implemented yet */
 778static int vino_prepare_user_buffer(struct vino_framebuffer *fb,
 779				     void *user,
 780				     unsigned int size)
 781{
 782	unsigned int count, i, j;
 783	int ret = 0;
 784
 785	dprintk("vino_prepare_user_buffer():\n");
 786
 787	if (size < 1)
 788		return -EINVAL;
 789
 790	memset(fb, 0, sizeof(struct vino_framebuffer));
 791
 792	count = ((size / PAGE_SIZE)) & ~3;
 793
 794	dprintk("vino_prepare_user_buffer(): size = %d, count = %d\n",
 795		size, count);
 796
 797	/* allocate memory for table with virtual (page) addresses */
 798	fb->desc_table.virtual = (unsigned long *)
 799		kmalloc(count * sizeof(unsigned long), GFP_KERNEL);
 800	if (!fb->desc_table.virtual)
 801		return -ENOMEM;
 802
 803	/* allocate memory for table with dma addresses
 804	 * (has space for four extra descriptors) */
 805	fb->desc_table.dma_cpu =
 806		dma_alloc_coherent(NULL, VINO_PAGE_RATIO * (count + 4) *
 807				   sizeof(dma_addr_t), &fb->desc_table.dma,
 808				   GFP_KERNEL | GFP_DMA);
 809	if (!fb->desc_table.dma_cpu) {
 810		ret = -ENOMEM;
 811		goto out_free_virtual;
 812	}
 813
 814	/* allocate pages for the buffer and acquire the according
 815	 * dma addresses */
 816	for (i = 0; i < count; i++) {
 817		dma_addr_t dma_data_addr;
 818
 819		fb->desc_table.virtual[i] =
 820			get_zeroed_page(GFP_KERNEL | GFP_DMA);
 821		if (!fb->desc_table.virtual[i]) {
 822			ret = -ENOBUFS;
 823			break;
 824		}
 825
 826		dma_data_addr =
 827			dma_map_single(NULL,
 828				       (void *)fb->desc_table.virtual[i],
 829				       PAGE_SIZE, DMA_FROM_DEVICE);
 830
 831		for (j = 0; j < VINO_PAGE_RATIO; j++) {
 832			fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i + j] =
 833				dma_data_addr + VINO_PAGE_SIZE * j;
 834		}
 835
 836		SetPageReserved(virt_to_page((void *)fb->desc_table.virtual[i]));
 837	}
 838
 839	/* page_count needs to be set anyway, because the descriptor table has
 840	 * been allocated according to this number */
 841	fb->desc_table.page_count = count;
 842
 843	if (ret) {
 844		/* the descriptor with index i doesn't contain
 845		 * a valid address yet */
 846		vino_free_buffer_with_count(fb, i);
 847		return ret;
 848	}
 849
 850	//fb->size = size;
 851	fb->size = count * PAGE_SIZE;
 852
 853	/* set the dma stop-bit for the last (count+1)th descriptor */
 854	fb->desc_table.dma_cpu[VINO_PAGE_RATIO * count] = VINO_DESC_STOP;
 855	return 0;
 856
 857 out_free_virtual:
 858	kfree(fb->desc_table.virtual);
 859	return ret;
 860}
 861#endif
 862
 863static void vino_sync_buffer(struct vino_framebuffer *fb)
 864{
 865	int i;
 866
 867	dprintk("vino_sync_buffer():\n");
 868
 869	for (i = 0; i < fb->desc_table.page_count; i++)
 870		dma_sync_single_for_cpu(NULL,
 871					fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i],
 872					PAGE_SIZE, DMA_FROM_DEVICE);
 873}
 874
 875/* Framebuffer fifo functions (need to be locked externally) */
 876
 877static inline void vino_fifo_init(struct vino_framebuffer_fifo *f,
 878			   unsigned int length)
 879{
 880	f->length = 0;
 881	f->used = 0;
 882	f->head = 0;
 883	f->tail = 0;
 884
 885	if (length > VINO_FRAMEBUFFER_COUNT_MAX)
 886		length = VINO_FRAMEBUFFER_COUNT_MAX;
 887
 888	f->length = length;
 889}
 890
 891/* returns true/false */
 892static inline int vino_fifo_has_id(struct vino_framebuffer_fifo *f,
 893				   unsigned int id)
 894{
 895	unsigned int i;
 896
 897	for (i = f->head; i == (f->tail - 1); i = (i + 1) % f->length) {
 898		if (f->data[i] == id)
 899			return 1;
 900	}
 901
 902	return 0;
 903}
 904
 905#if 0
 906/* returns true/false */
 907static inline int vino_fifo_full(struct vino_framebuffer_fifo *f)
 908{
 909	return (f->used == f->length);
 910}
 911#endif
 912
 913static inline unsigned int vino_fifo_get_used(struct vino_framebuffer_fifo *f)
 914{
 915	return f->used;
 916}
 917
 918static int vino_fifo_enqueue(struct vino_framebuffer_fifo *f, unsigned int id)
 919{
 920	if (id >= f->length) {
 921		return VINO_QUEUE_ERROR;
 922	}
 923
 924	if (vino_fifo_has_id(f, id)) {
 925		return VINO_QUEUE_ERROR;
 926	}
 927
 928	if (f->used < f->length) {
 929		f->data[f->tail] = id;
 930		f->tail = (f->tail + 1) % f->length;
 931		f->used++;
 932	} else {
 933		return VINO_QUEUE_ERROR;
 934	}
 935
 936	return 0;
 937}
 938
 939static int vino_fifo_peek(struct vino_framebuffer_fifo *f, unsigned int *id)
 940{
 941	if (f->used > 0) {
 942		*id = f->data[f->head];
 943	} else {
 944		return VINO_QUEUE_ERROR;
 945	}
 946
 947	return 0;
 948}
 949
 950static int vino_fifo_dequeue(struct vino_framebuffer_fifo *f, unsigned int *id)
 951{
 952	if (f->used > 0) {
 953		*id = f->data[f->head];
 954		f->head = (f->head + 1) % f->length;
 955		f->used--;
 956	} else {
 957		return VINO_QUEUE_ERROR;
 958	}
 959
 960	return 0;
 961}
 962
 963/* Framebuffer queue functions */
 964
 965/* execute with queue_lock locked */
 966static void vino_queue_free_with_count(struct vino_framebuffer_queue *q,
 967				       unsigned int length)
 968{
 969	unsigned int i;
 970
 971	q->length = 0;
 972	memset(&q->in, 0, sizeof(struct vino_framebuffer_fifo));
 973	memset(&q->out, 0, sizeof(struct vino_framebuffer_fifo));
 974	for (i = 0; i < length; i++) {
 975		dprintk("vino_queue_free_with_count(): freeing buffer %d\n",
 976			i);
 977		vino_free_buffer(q->buffer[i]);
 978		kfree(q->buffer[i]);
 979	}
 980
 981	q->type = VINO_MEMORY_NONE;
 982	q->magic = 0;
 983}
 984
 985static void vino_queue_free(struct vino_framebuffer_queue *q)
 986{
 987	dprintk("vino_queue_free():\n");
 988
 989	if (q->magic != VINO_QUEUE_MAGIC)
 990		return;
 991	if (q->type != VINO_MEMORY_MMAP)
 992		return;
 993
 994	mutex_lock(&q->queue_mutex);
 995
 996	vino_queue_free_with_count(q, q->length);
 997
 998	mutex_unlock(&q->queue_mutex);
 999}
1000
1001static int vino_queue_init(struct vino_framebuffer_queue *q,
1002			   unsigned int *length)
1003{
1004	unsigned int i;
1005	int ret = 0;
1006
1007	dprintk("vino_queue_init(): length = %d\n", *length);
1008
1009	if (q->magic == VINO_QUEUE_MAGIC) {
1010		dprintk("vino_queue_init(): queue already initialized!\n");
1011		return -EINVAL;
1012	}
1013
1014	if (q->type != VINO_MEMORY_NONE) {
1015		dprintk("vino_queue_init(): queue already initialized!\n");
1016		return -EINVAL;
1017	}
1018
1019	if (*length < 1)
1020		return -EINVAL;
1021
1022	mutex_lock(&q->queue_mutex);
1023
1024	if (*length > VINO_FRAMEBUFFER_COUNT_MAX)
1025		*length = VINO_FRAMEBUFFER_COUNT_MAX;
1026
1027	q->length = 0;
1028
1029	for (i = 0; i < *length; i++) {
1030		dprintk("vino_queue_init(): allocating buffer %d\n", i);
1031		q->buffer[i] = kmalloc(sizeof(struct vino_framebuffer),
1032				       GFP_KERNEL);
1033		if (!q->buffer[i]) {
1034			dprintk("vino_queue_init(): kmalloc() failed\n");
1035			ret = -ENOMEM;
1036			break;
1037		}
1038
1039		ret = vino_allocate_buffer(q->buffer[i],
1040					   VINO_FRAMEBUFFER_SIZE);
1041		if (ret) {
1042			kfree(q->buffer[i]);
1043			dprintk("vino_queue_init(): "
1044				"vino_allocate_buffer() failed\n");
1045			break;
1046		}
1047
1048		q->buffer[i]->id = i;
1049		if (i > 0) {
1050			q->buffer[i]->offset = q->buffer[i - 1]->offset +
1051				q->buffer[i - 1]->size;
1052		} else {
1053			q->buffer[i]->offset = 0;
1054		}
1055
1056		spin_lock_init(&q->buffer[i]->state_lock);
1057
1058		dprintk("vino_queue_init(): buffer = %d, offset = %d, "
1059			"size = %d\n", i, q->buffer[i]->offset,
1060			q->buffer[i]->size);
1061	}
1062
1063	if (ret) {
1064		vino_queue_free_with_count(q, i);
1065		*length = 0;
1066	} else {
1067		q->length = *length;
1068		vino_fifo_init(&q->in, q->length);
1069		vino_fifo_init(&q->out, q->length);
1070		q->type = VINO_MEMORY_MMAP;
1071		q->magic = VINO_QUEUE_MAGIC;
1072	}
1073
1074	mutex_unlock(&q->queue_mutex);
1075
1076	return ret;
1077}
1078
1079static struct vino_framebuffer *vino_queue_add(struct
1080					       vino_framebuffer_queue *q,
1081					       unsigned int id)
1082{
1083	struct vino_framebuffer *ret = NULL;
1084	unsigned int total;
1085	unsigned long flags;
1086
1087	dprintk("vino_queue_add(): id = %d\n", id);
1088
1089	if (q->magic != VINO_QUEUE_MAGIC) {
1090		return ret;
1091	}
1092
1093	spin_lock_irqsave(&q->queue_lock, flags);
1094
1095	if (q->length == 0)
1096		goto out;
1097
1098	if (id >= q->length)
1099		goto out;
1100
1101	/* not needed?: if (vino_fifo_full(&q->out)) {
1102		goto out;
1103		}*/
1104	/* check that outgoing queue isn't already full
1105	 * (or that it won't become full) */
1106	total = vino_fifo_get_used(&q->in) +
1107		vino_fifo_get_used(&q->out);
1108	if (total >= q->length)
1109		goto out;
1110
1111	if (vino_fifo_enqueue(&q->in, id))
1112		goto out;
1113
1114	ret = q->buffer[id];
1115
1116out:
1117	spin_unlock_irqrestore(&q->queue_lock, flags);
1118
1119	return ret;
1120}
1121
1122static struct vino_framebuffer *vino_queue_transfer(struct
1123						    vino_framebuffer_queue *q)
1124{
1125	struct vino_framebuffer *ret = NULL;
1126	struct vino_framebuffer *fb;
1127	int id;
1128	unsigned long flags;
1129
1130	dprintk("vino_queue_transfer():\n");
1131
1132	if (q->magic != VINO_QUEUE_MAGIC) {
1133		return ret;
1134	}
1135
1136	spin_lock_irqsave(&q->queue_lock, flags);
1137
1138	if (q->length == 0)
1139		goto out;
1140
1141	// now this actually removes an entry from the incoming queue
1142	if (vino_fifo_dequeue(&q->in, &id)) {
1143		goto out;
1144	}
1145
1146	dprintk("vino_queue_transfer(): id = %d\n", id);
1147	fb = q->buffer[id];
1148
1149	// we have already checked that the outgoing queue is not full, but...
1150	if (vino_fifo_enqueue(&q->out, id)) {
1151		printk(KERN_ERR "vino_queue_transfer(): "
1152		       "outgoing queue is full, this shouldn't happen!\n");
1153		goto out;
1154	}
1155
1156	ret = fb;
1157out:
1158	spin_unlock_irqrestore(&q->queue_lock, flags);
1159
1160	return ret;
1161}
1162
1163/* returns true/false */
1164static int vino_queue_incoming_contains(struct vino_framebuffer_queue *q,
1165					unsigned int id)
1166{
1167	int ret = 0;
1168	unsigned long flags;
1169
1170	if (q->magic != VINO_QUEUE_MAGIC) {
1171		return ret;
1172	}
1173
1174	spin_lock_irqsave(&q->queue_lock, flags);
1175
1176	if (q->length == 0)
1177		goto out;
1178
1179	ret = vino_fifo_has_id(&q->in, id);
1180
1181out:
1182	spin_unlock_irqrestore(&q->queue_lock, flags);
1183
1184	return ret;
1185}
1186
1187/* returns true/false */
1188static int vino_queue_outgoing_contains(struct vino_framebuffer_queue *q,
1189					unsigned int id)
1190{
1191	int ret = 0;
1192	unsigned long flags;
1193
1194	if (q->magic != VINO_QUEUE_MAGIC) {
1195		return ret;
1196	}
1197
1198	spin_lock_irqsave(&q->queue_lock, flags);
1199
1200	if (q->length == 0)
1201		goto out;
1202
1203	ret = vino_fifo_has_id(&q->out, id);
1204
1205out:
1206	spin_unlock_irqrestore(&q->queue_lock, flags);
1207
1208	return ret;
1209}
1210
1211static int vino_queue_get_incoming(struct vino_framebuffer_queue *q,
1212				   unsigned int *used)
1213{
1214	int ret = 0;
1215	unsigned long flags;
1216
1217	if (q->magic != VINO_QUEUE_MAGIC) {
1218		return VINO_QUEUE_ERROR;
1219	}
1220
1221	spin_lock_irqsave(&q->queue_lock, flags);
1222
1223	if (q->length == 0) {
1224		ret = VINO_QUEUE_ERROR;
1225		goto out;
1226	}
1227
1228	*used = vino_fifo_get_used(&q->in);
1229
1230out:
1231	spin_unlock_irqrestore(&q->queue_lock, flags);
1232
1233	return ret;
1234}
1235
1236static int vino_queue_get_outgoing(struct vino_framebuffer_queue *q,
1237				   unsigned int *used)
1238{
1239	int ret = 0;
1240	unsigned long flags;
1241
1242	if (q->magic != VINO_QUEUE_MAGIC) {
1243		return VINO_QUEUE_ERROR;
1244	}
1245
1246	spin_lock_irqsave(&q->queue_lock, flags);
1247
1248	if (q->length == 0) {
1249		ret = VINO_QUEUE_ERROR;
1250		goto out;
1251	}
1252
1253	*used = vino_fifo_get_used(&q->out);
1254
1255out:
1256	spin_unlock_irqrestore(&q->queue_lock, flags);
1257
1258	return ret;
1259}
1260
1261#if 0
1262static int vino_queue_get_total(struct vino_framebuffer_queue *q,
1263				unsigned int *total)
1264{
1265	int ret = 0;
1266	unsigned long flags;
1267
1268	if (q->magic != VINO_QUEUE_MAGIC) {
1269		return VINO_QUEUE_ERROR;
1270	}
1271
1272	spin_lock_irqsave(&q->queue_lock, flags);
1273
1274	if (q->length == 0) {
1275		ret = VINO_QUEUE_ERROR;
1276		goto out;
1277	}
1278
1279	*total = vino_fifo_get_used(&q->in) +
1280		vino_fifo_get_used(&q->out);
1281
1282out:
1283	spin_unlock_irqrestore(&q->queue_lock, flags);
1284
1285	return ret;
1286}
1287#endif
1288
1289static struct vino_framebuffer *vino_queue_peek(struct
1290						vino_framebuffer_queue *q,
1291						unsigned int *id)
1292{
1293	struct vino_framebuffer *ret = NULL;
1294	unsigned long flags;
1295
1296	if (q->magic != VINO_QUEUE_MAGIC) {
1297		return ret;
1298	}
1299
1300	spin_lock_irqsave(&q->queue_lock, flags);
1301
1302	if (q->length == 0)
1303		goto out;
1304
1305	if (vino_fifo_peek(&q->in, id)) {
1306		goto out;
1307	}
1308
1309	ret = q->buffer[*id];
1310out:
1311	spin_unlock_irqrestore(&q->queue_lock, flags);
1312
1313	return ret;
1314}
1315
1316static struct vino_framebuffer *vino_queue_remove(struct
1317						  vino_framebuffer_queue *q,
1318						  unsigned int *id)
1319{
1320	struct vino_framebuffer *ret = NULL;
1321	unsigned long flags;
1322	dprintk("vino_queue_remove():\n");
1323
1324	if (q->magic != VINO_QUEUE_MAGIC) {
1325		return ret;
1326	}
1327
1328	spin_lock_irqsave(&q->queue_lock, flags);
1329
1330	if (q->length == 0)
1331		goto out;
1332
1333	if (vino_fifo_dequeue(&q->out, id)) {
1334		goto out;
1335	}
1336
1337	dprintk("vino_queue_remove(): id = %d\n", *id);
1338	ret = q->buffer[*id];
1339out:
1340	spin_unlock_irqrestore(&q->queue_lock, flags);
1341
1342	return ret;
1343}
1344
1345static struct
1346vino_framebuffer *vino_queue_get_buffer(struct vino_framebuffer_queue *q,
1347					unsigned int id)
1348{
1349	struct vino_framebuffer *ret = NULL;
1350	unsigned long flags;
1351
1352	if (q->magic != VINO_QUEUE_MAGIC) {
1353		return ret;
1354	}
1355
1356	spin_lock_irqsave(&q->queue_lock, flags);
1357
1358	if (q->length == 0)
1359		goto out;
1360
1361	if (id >= q->length)
1362		goto out;
1363
1364	ret = q->buffer[id];
1365 out:
1366	spin_unlock_irqrestore(&q->queue_lock, flags);
1367
1368	return ret;
1369}
1370
1371static unsigned int vino_queue_get_length(struct vino_framebuffer_queue *q)
1372{
1373	unsigned int length = 0;
1374	unsigned long flags;
1375
1376	if (q->magic != VINO_QUEUE_MAGIC) {
1377		return length;
1378	}
1379
1380	spin_lock_irqsave(&q->queue_lock, flags);
1381	length = q->length;
1382	spin_unlock_irqrestore(&q->queue_lock, flags);
1383
1384	return length;
1385}
1386
1387static int vino_queue_has_mapped_buffers(struct vino_framebuffer_queue *q)
1388{
1389	unsigned int i;
1390	int ret = 0;
1391	unsigned long flags;
1392
1393	if (q->magic != VINO_QUEUE_MAGIC) {
1394		return ret;
1395	}
1396
1397	spin_lock_irqsave(&q->queue_lock, flags);
1398	for (i = 0; i < q->length; i++) {
1399		if (q->buffer[i]->map_count > 0) {
1400			ret = 1;
1401			break;
1402		}
1403	}
1404	spin_unlock_irqrestore(&q->queue_lock, flags);
1405
1406	return ret;
1407}
1408
1409/* VINO functions */
1410
1411/* execute with input_lock locked */
1412static void vino_update_line_size(struct vino_channel_settings *vcs)
1413{
1414	unsigned int w = vcs->clipping.right - vcs->clipping.left;
1415	unsigned int d = vcs->decimation;
1416	unsigned int bpp = vino_data_formats[vcs->data_format].bpp;
1417	unsigned int lsize;
1418
1419	dprintk("update_line_size(): before: w = %d, d = %d, "
1420		"line_size = %d\n", w, d, vcs->line_size);
1421
1422	/* line size must be multiple of 8 bytes */
1423	lsize = (bpp * (w / d)) & ~7;
1424	w = (lsize / bpp) * d;
1425
1426	vcs->clipping.right = vcs->clipping.left + w;
1427	vcs->line_size = lsize;
1428
1429	dprintk("update_line_size(): after: w = %d, d = %d, "
1430		"line_size = %d\n", w, d, vcs->line_size);
1431}
1432
1433/* execute with input_lock locked */
1434static void vino_set_clipping(struct vino_channel_settings *vcs,
1435			      unsigned int x, unsigned int y,
1436			      unsigned int w, unsigned int h)
1437{
1438	unsigned int maxwidth, maxheight;
1439	unsigned int d;
1440
1441	maxwidth = vino_data_norms[vcs->data_norm].width;
1442	maxheight = vino_data_norms[vcs->data_norm].height;
1443	d = vcs->decimation;
1444
1445	y &= ~1;	/* odd/even fields */
1446
1447	if (x > maxwidth) {
1448		x = 0;
1449	}
1450	if (y > maxheight) {
1451		y = 0;
1452	}
1453
1454	if (((w / d) < VINO_MIN_WIDTH)
1455	    || ((h / d) < VINO_MIN_HEIGHT)) {
1456		w = VINO_MIN_WIDTH * d;
1457		h = VINO_MIN_HEIGHT * d;
1458	}
1459
1460	if ((x + w) > maxwidth) {
1461		w = maxwidth - x;
1462		if ((w / d) < VINO_MIN_WIDTH)
1463			x = maxwidth - VINO_MIN_WIDTH * d;
1464	}
1465	if ((y + h) > maxheight) {
1466		h = maxheight - y;
1467		if ((h / d) < VINO_MIN_HEIGHT)
1468			y = maxheight - VINO_MIN_HEIGHT * d;
1469	}
1470
1471	vcs->clipping.left = x;
1472	vcs->clipping.top = y;
1473	vcs->clipping.right = x + w;
1474	vcs->clipping.bottom = y + h;
1475
1476	vino_update_line_size(vcs);
1477
1478	dprintk("clipping %d, %d, %d, %d / %d - %d\n",
1479		vcs->clipping.left, vcs->clipping.top, vcs->clipping.right,
1480		vcs->clipping.bottom, vcs->decimation, vcs->line_size);
1481}
1482
1483/* execute with input_lock locked */
1484static inline void vino_set_default_clipping(struct vino_channel_settings *vcs)
1485{
1486	vino_set_clipping(vcs, 0, 0, vino_data_norms[vcs->data_norm].width,
1487			  vino_data_norms[vcs->data_norm].height);
1488}
1489
1490/* execute with input_lock locked */
1491static void vino_set_scaling(struct vino_channel_settings *vcs,
1492			     unsigned int w, unsigned int h)
1493{
1494	unsigned int x, y, curw, curh, d;
1495
1496	x = vcs->clipping.left;
1497	y = vcs->clipping.top;
1498	curw = vcs->clipping.right - vcs->clipping.left;
1499	curh = vcs->clipping.bottom - vcs->clipping.top;
1500
1501	d = max(curw / w, curh / h);
1502
1503	dprintk("scaling w: %d, h: %d, curw: %d, curh: %d, d: %d\n",
1504		w, h, curw, curh, d);
1505
1506	if (d < 1) {
1507		d = 1;
1508	} else if (d > 8) {
1509		d = 8;
1510	}
1511
1512	vcs->decimation = d;
1513	vino_set_clipping(vcs, x, y, w * d, h * d);
1514
1515	dprintk("scaling %d, %d, %d, %d / %d - %d\n", vcs->clipping.left,
1516		vcs->clipping.top, vcs->clipping.right, vcs->clipping.bottom,
1517		vcs->decimation, vcs->line_size);
1518}
1519
1520/* execute with input_lock locked */
1521static inline void vino_set_default_scaling(struct vino_channel_settings *vcs)
1522{
1523	vino_set_scaling(vcs, vcs->clipping.right - vcs->clipping.left,
1524			 vcs->clipping.bottom - vcs->clipping.top);
1525}
1526
1527/* execute with input_lock locked */
1528static void vino_set_framerate(struct vino_channel_settings *vcs,
1529			       unsigned int fps)
1530{
1531	unsigned int mask;
1532
1533	switch (vcs->data_norm) {
1534	case VINO_DATA_NORM_NTSC:
1535	case VINO_DATA_NORM_D1:
1536		fps = (unsigned int)(fps / 6) * 6; // FIXME: round!
1537
1538		if (fps < vino_data_norms[vcs->data_norm].fps_min)
1539			fps = vino_data_norms[vcs->data_norm].fps_min;
1540		if (fps > vino_data_norms[vcs->data_norm].fps_max)
1541			fps = vino_data_norms[vcs->data_norm].fps_max;
1542
1543		switch (fps) {
1544		case 6:
1545			mask = 0x003;
1546			break;
1547		case 12:
1548			mask = 0x0c3;
1549			break;
1550		case 18:
1551			mask = 0x333;
1552			break;
1553		case 24:
1554			mask = 0x3ff;
1555			break;
1556		case 30:
1557			mask = 0xfff;
1558			break;
1559		default:
1560			mask = VINO_FRAMERT_FULL;
1561		}
1562		vcs->framert_reg = VINO_FRAMERT_RT(mask);
1563		break;
1564	case VINO_DATA_NORM_PAL:
1565	case VINO_DATA_NORM_SECAM:
1566		fps = (unsigned int)(fps / 5) * 5; // FIXME: round!
1567
1568		if (fps < vino_data_norms[vcs->data_norm].fps_min)
1569			fps = vino_data_norms[vcs->data_norm].fps_min;
1570		if (fps > vino_data_norms[vcs->data_norm].fps_max)
1571			fps = vino_data_norms[vcs->data_norm].fps_max;
1572
1573		switch (fps) {
1574		case 5:
1575			mask = 0x003;
1576			break;
1577		case 10:
1578			mask = 0x0c3;
1579			break;
1580		case 15:
1581			mask = 0x333;
1582			break;
1583		case 20:
1584			mask = 0x0ff;
1585			break;
1586		case 25:
1587			mask = 0x3ff;
1588			break;
1589		default:
1590			mask = VINO_FRAMERT_FULL;
1591		}
1592		vcs->framert_reg = VINO_FRAMERT_RT(mask) | VINO_FRAMERT_PAL;
1593		break;
1594	}
1595
1596	vcs->fps = fps;
1597}
1598
1599/* execute with input_lock locked */
1600static inline void vino_set_default_framerate(struct
1601					      vino_channel_settings *vcs)
1602{
1603	vino_set_framerate(vcs, vino_data_norms[vcs->data_norm].fps_max);
1604}
1605
1606/* VINO I2C bus functions */
1607
1608struct i2c_algo_sgi_data {
1609	void *data;	/* private data for lowlevel routines */
1610	unsigned (*getctrl)(void *data);
1611	void (*setctrl)(void *data, unsigned val);
1612	unsigned (*rdata)(void *data);
1613	void (*wdata)(void *data, unsigned val);
1614
1615	int xfer_timeout;
1616	int ack_timeout;
1617};
1618
1619static int wait_xfer_done(struct i2c_algo_sgi_data *adap)
1620{
1621	int i;
1622
1623	for (i = 0; i < adap->xfer_timeout; i++) {
1624		if ((adap->getctrl(adap->data) & SGI_I2C_XFER_BUSY) == 0)
1625			return 0;
1626		udelay(1);
1627	}
1628
1629	return -ETIMEDOUT;
1630}
1631
1632static int wait_ack(struct i2c_algo_sgi_data *adap)
1633{
1634	int i;
1635
1636	if (wait_xfer_done(adap))
1637		return -ETIMEDOUT;
1638	for (i = 0; i < adap->ack_timeout; i++) {
1639		if ((adap->getctrl(adap->data) & SGI_I2C_NACK) == 0)
1640			return 0;
1641		udelay(1);
1642	}
1643
1644	return -ETIMEDOUT;
1645}
1646
1647static int force_idle(struct i2c_algo_sgi_data *adap)
1648{
1649	int i;
1650
1651	adap->setctrl(adap->data, SGI_I2C_FORCE_IDLE);
1652	for (i = 0; i < adap->xfer_timeout; i++) {
1653		if ((adap->getctrl(adap->data) & SGI_I2C_NOT_IDLE) == 0)
1654			goto out;
1655		udelay(1);
1656	}
1657	return -ETIMEDOUT;
1658out:
1659	if (adap->getctrl(adap->data) & SGI_I2C_BUS_ERR)
1660		return -EIO;
1661	return 0;
1662}
1663
1664static int do_address(struct i2c_algo_sgi_data *adap, unsigned int addr,
1665		      int rd)
1666{
1667	if (rd)
1668		adap->setctrl(adap->data, SGI_I2C_NOT_IDLE);
1669	/* Check if bus is idle, eventually force it to do so */
1670	if (adap->getctrl(adap->data) & SGI_I2C_NOT_IDLE)
1671		if (force_idle(adap))
1672			return -EIO;
1673	/* Write out the i2c chip address and specify operation */
1674	adap->setctrl(adap->data,
1675		      SGI_I2C_HOLD_BUS | SGI_I2C_WRITE | SGI_I2C_NOT_IDLE);
1676	if (rd)
1677		addr |= 1;
1678	adap->wdata(adap->data, addr);
1679	if (wait_ack(adap))
1680		return -EIO;
1681	return 0;
1682}
1683
1684static int i2c_read(struct i2c_algo_sgi_data *adap, unsigned char *buf,
1685		    unsigned int len)
1686{
1687	int i;
1688
1689	adap->setctrl(adap->data,
1690		      SGI_I2C_HOLD_BUS | SGI_I2C_READ | SGI_I2C_NOT_IDLE);
1691	for (i = 0; i < len; i++) {
1692		if (wait_xfer_done(adap))
1693			return -EIO;
1694		buf[i] = adap->rdata(adap->data);
1695	}
1696	adap->setctrl(adap->data, SGI_I2C_RELEASE_BUS | SGI_I2C_FORCE_IDLE);
1697
1698	return 0;
1699
1700}
1701
1702static int i2c_write(struct i2c_algo_sgi_data *adap, unsigned char *buf,
1703		     unsigned int len)
1704{
1705	int i;
1706
1707	/* We are already in write state */
1708	for (i = 0; i < len; i++) {
1709		adap->wdata(adap->data, buf[i]);
1710		if (wait_ack(adap))
1711			return -EIO;
1712	}
1713	return 0;
1714}
1715
1716static int sgi_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs,
1717		    int num)
1718{
1719	struct i2c_algo_sgi_data *adap = i2c_adap->algo_data;
1720	struct i2c_msg *p;
1721	int i, err = 0;
1722
1723	for (i = 0; !err && i < num; i++) {
1724		p = &msgs[i];
1725		err = do_address(adap, p->addr, p->flags & I2C_M_RD);
1726		if (err || !p->len)
1727			continue;
1728		if (p->flags & I2C_M_RD)
1729			err = i2c_read(adap, p->buf, p->len);
1730		else
1731			err = i2c_write(adap, p->buf, p->len);
1732	}
1733
1734	return (err < 0) ? err : i;
1735}
1736
1737static u32 sgi_func(struct i2c_adapter *adap)
1738{
1739	return I2C_FUNC_SMBUS_EMUL;
1740}
1741
1742static const struct i2c_algorithm sgi_algo = {
1743	.master_xfer	= sgi_xfer,
1744	.functionality	= sgi_func,
1745};
1746
1747static unsigned i2c_vino_getctrl(void *data)
1748{
1749	return vino->i2c_control;
1750}
1751
1752static void i2c_vino_setctrl(void *data, unsigned val)
1753{
1754	vino->i2c_control = val;
1755}
1756
1757static unsigned i2c_vino_rdata(void *data)
1758{
1759	return vino->i2c_data;
1760}
1761
1762static void i2c_vino_wdata(void *data, unsigned val)
1763{
1764	vino->i2c_data = val;
1765}
1766
1767static struct i2c_algo_sgi_data i2c_sgi_vino_data = {
1768	.getctrl = &i2c_vino_getctrl,
1769	.setctrl = &i2c_vino_setctrl,
1770	.rdata   = &i2c_vino_rdata,
1771	.wdata   = &i2c_vino_wdata,
1772	.xfer_timeout = 200,
1773	.ack_timeout  = 1000,
1774};
1775
1776static struct i2c_adapter vino_i2c_adapter = {
1777	.name			= "VINO I2C bus",
1778	.algo			= &sgi_algo,
1779	.algo_data		= &i2c_sgi_vino_data,
1780	.owner 			= THIS_MODULE,
1781};
1782
1783/*
1784 * Prepare VINO for DMA transfer...
1785 * (execute only with vino_lock and input_lock locked)
1786 */
1787static int vino_dma_setup(struct vino_channel_settings *vcs,
1788			  struct vino_framebuffer *fb)
1789{
1790	u32 ctrl, intr;
1791	struct sgi_vino_channel *ch;
1792	const struct vino_data_norm *norm;
1793
1794	dprintk("vino_dma_setup():\n");
1795
1796	vcs->field = 0;
1797	fb->frame_counter = 0;
1798
1799	ch = (vcs->channel == VINO_CHANNEL_A) ? &vino->a : &vino->b;
1800	norm = &vino_data_norms[vcs->data_norm];
1801
1802	ch->page_index = 0;
1803	ch->line_count = 0;
1804
1805	/* VINO line size register is set 8 bytes less than actual */
1806	ch->line_size = vcs->line_size - 8;
1807
1808	/* let VINO know where to transfer data */
1809	ch->start_desc_tbl = fb->desc_table.dma;
1810	ch->next_4_desc = fb->desc_table.dma;
1811
1812	/* give vino time to fetch the first four descriptors, 5 usec
1813	 * should be more than enough time */
1814	udelay(VINO_DESC_FETCH_DELAY);
1815
1816	dprintk("vino_dma_setup(): start desc = %08x, next 4 desc = %08x\n",
1817		ch->start_desc_tbl, ch->next_4_desc);
1818
1819	/* set the alpha register */
1820	ch->alpha = vcs->alpha;
1821
1822	/* set clipping registers */
1823	ch->clip_start = VINO_CLIP_ODD(norm->odd.top + vcs->clipping.top / 2) |
1824		VINO_CLIP_EVEN(norm->even.top +
1825			       vcs->clipping.top / 2) |
1826		VINO_CLIP_X(vcs->clipping.left);
1827	ch->clip_end = VINO_CLIP_ODD(norm->odd.top +
1828				     vcs->clipping.bottom / 2 - 1) |
1829		VINO_CLIP_EVEN(norm->even.top +
1830			       vcs->clipping.bottom / 2 - 1) |
1831		VINO_CLIP_X(vcs->clipping.right);
1832
1833	/* set the size of actual content in the buffer (DECIMATION !) */
1834	fb->data_size = ((vcs->clipping.right - vcs->clipping.left) /
1835			 vcs->decimation) *
1836		((vcs->clipping.bottom - vcs->clipping.top) /
1837		 vcs->decimation) *
1838		vino_data_formats[vcs->data_format].bpp;
1839
1840	ch->frame_rate = vcs->framert_reg;
1841
1842	ctrl = vino->control;
1843	intr = vino->intr_status;
1844
1845	if (vcs->channel == VINO_CHANNEL_A) {
1846		/* All interrupt conditions for this channel was cleared
1847		 * so clear the interrupt status register and enable
1848		 * interrupts */
1849		intr &=	~VINO_INTSTAT_A;
1850		ctrl |= VINO_CTRL_A_INT;
1851
1852		/* enable synchronization */
1853		ctrl |= VINO_CTRL_A_SYNC_ENBL;
1854
1855		/* enable frame assembly */
1856		ctrl |= VINO_CTRL_A_INTERLEAVE_ENBL;
1857
1858		/* set decimation used */
1859		if (vcs->decimation < 2)
1860			ctrl &= ~VINO_CTRL_A_DEC_ENBL;
1861		else {
1862			ctrl |= VINO_CTRL_A_DEC_ENBL;
1863			ctrl &= ~VINO_CTRL_A_DEC_SCALE_MASK;
1864			ctrl |= (vcs->decimation - 1) <<
1865				VINO_CTRL_A_DEC_SCALE_SHIFT;
1866		}
1867
1868		/* select input interface */
1869		if (vcs->input == VINO_INPUT_D1)
1870			ctrl |= VINO_CTRL_A_SELECT;
1871		else
1872			ctrl &= ~VINO_CTRL_A_SELECT;
1873
1874		/* palette */
1875		ctrl &= ~(VINO_CTRL_A_LUMA_ONLY | VINO_CTRL_A_RGB |
1876			  VINO_CTRL_A_DITHER);
1877	} else {
1878		intr &= ~VINO_INTSTAT_B;
1879		ctrl |= VINO_CTRL_B_INT;
1880
1881		ctrl |= VINO_CTRL_B_SYNC_ENBL;
1882		ctrl |= VINO_CTRL_B_INTERLEAVE_ENBL;
1883
1884		if (vcs->decimation < 2)
1885			ctrl &= ~VINO_CTRL_B_DEC_ENBL;
1886		else {
1887			ctrl |= VINO_CTRL_B_DEC_ENBL;
1888			ctrl &= ~VINO_CTRL_B_DEC_SCALE_MASK;
1889			ctrl |= (vcs->decimation - 1) <<
1890				VINO_CTRL_B_DEC_SCALE_SHIFT;
1891
1892		}
1893		if (vcs->input == VINO_INPUT_D1)
1894			ctrl |= VINO_CTRL_B_SELECT;
1895		else
1896			ctrl &= ~VINO_CTRL_B_SELECT;
1897
1898		ctrl &= ~(VINO_CTRL_B_LUMA_ONLY | VINO_CTRL_B_RGB |
1899			  VINO_CTRL_B_DITHER);
1900	}
1901
1902	/* set palette */
1903	fb->data_format = vcs->data_format;
1904
1905	switch (vcs->data_format) {
1906		case VINO_DATA_FMT_GREY:
1907			ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
1908				VINO_CTRL_A_LUMA_ONLY : VINO_CTRL_B_LUMA_ONLY;
1909			break;
1910		case VINO_DATA_FMT_RGB32:
1911			ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
1912				VINO_CTRL_A_RGB : VINO_CTRL_B_RGB;
1913			break;
1914		case VINO_DATA_FMT_YUV:
1915			/* nothing needs to be done */
1916			break;
1917		case VINO_DATA_FMT_RGB332:
1918			ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
1919				VINO_CTRL_A_RGB | VINO_CTRL_A_DITHER :
1920				VINO_CTRL_B_RGB | VINO_CTRL_B_DITHER;
1921			break;
1922	}
1923
1924	vino->intr_status = intr;
1925	vino->control = ctrl;
1926
1927	return 0;
1928}
1929
1930/* (execute only with vino_lock locked) */
1931static inline void vino_dma_start(struct vino_channel_settings *vcs)
1932{
1933	u32 ctrl = vino->control;
1934
1935	dprintk("vino_dma_start():\n");
1936	ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
1937		VINO_CTRL_A_DMA_ENBL : VINO_CTRL_B_DMA_ENBL;
1938	vino->control = ctrl;
1939}
1940
1941/* (execute only with vino_lock locked) */
1942static inline void vino_dma_stop(struct vino_channel_settings *vcs)
1943{
1944	u32 ctrl = vino->control;
1945
1946	ctrl &= (vcs->channel == VINO_CHANNEL_A) ?
1947		~VINO_CTRL_A_DMA_ENBL : ~VINO_CTRL_B_DMA_ENBL;
1948	ctrl &= (vcs->channel == VINO_CHANNEL_A) ?
1949		~VINO_CTRL_A_INT : ~VINO_CTRL_B_INT;
1950	vino->control = ctrl;
1951	dprintk("vino_dma_stop():\n");
1952}
1953
1954/*
1955 * Load dummy page to descriptor registers. This prevents generating of
1956 * spurious interrupts. (execute only with vino_lock locked)
1957 */
1958static void vino_clear_interrupt(struct vino_channel_settings *vcs)
1959{
1960	struct sgi_vino_channel *ch;
1961
1962	ch = (vcs->channel == VINO_CHANNEL_A) ? &vino->a : &vino->b;
1963
1964	ch->page_index = 0;
1965	ch->line_count = 0;
1966
1967	ch->start_desc_tbl = vino_drvdata->dummy_desc_table.dma;
1968	ch->next_4_desc = vino_drvdata->dummy_desc_table.dma;
1969
1970	udelay(VINO_DESC_FETCH_DELAY);
1971	dprintk("channel %c clear interrupt condition\n",
1972	       (vcs->channel == VINO_CHANNEL_A) ? 'A':'B');
1973}
1974
1975static int vino_capture(struct vino_channel_settings *vcs,
1976			struct vino_framebuffer *fb)
1977{
1978	int err = 0;
1979	unsigned long flags, flags2;
1980
1981	spin_lock_irqsave(&fb->state_lock, flags);
1982
1983	if (fb->state == VINO_FRAMEBUFFER_IN_USE)
1984		err = -EBUSY;
1985	fb->state = VINO_FRAMEBUFFER_IN_USE;
1986
1987	spin_unlock_irqrestore(&fb->state_lock, flags);
1988
1989	if (err)
1990		return err;
1991
1992	spin_lock_irqsave(&vino_drvdata->vino_lock, flags);
1993	spin_lock_irqsave(&vino_drvdata->input_lock, flags2);
1994
1995	vino_dma_setup(vcs, fb);
1996	vino_dma_start(vcs);
1997
1998	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags2);
1999	spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags);
2000
2001	return err;
2002}
2003
2004static
2005struct vino_framebuffer *vino_capture_enqueue(struct
2006					      vino_channel_settings *vcs,
2007					      unsigned int index)
2008{
2009	struct vino_framebuffer *fb;
2010	unsigned long flags;
2011
2012	dprintk("vino_capture_enqueue():\n");
2013
2014	spin_lock_irqsave(&vcs->capture_lock, flags);
2015
2016	fb = vino_queue_add(&vcs->fb_queue, index);
2017	if (fb == NULL) {
2018		dprintk("vino_capture_enqueue(): vino_queue_add() failed, "
2019			"queue full?\n");
2020		goto out;
2021	}
2022out:
2023	spin_unlock_irqrestore(&vcs->capture_lock, flags);
2024
2025	return fb;
2026}
2027
2028static int vino_capture_next(struct vino_channel_settings *vcs, int start)
2029{
2030	struct vino_framebuffer *fb;
2031	unsigned int incoming, id;
2032	int err = 0;
2033	unsigned long flags;
2034
2035	dprintk("vino_capture_next():\n");
2036
2037	spin_lock_irqsave(&vcs->capture_lock, flags);
2038
2039	if (start) {
2040		/* start capture only if capture isn't in progress already */
2041		if (vcs->capturing) {
2042			spin_unlock_irqrestore(&vcs->capture_lock, flags);
2043			return 0;
2044		}
2045
2046	} else {
2047		/* capture next frame:
2048		 * stop capture if capturing is not set */
2049		if (!vcs->capturing) {
2050			spin_unlock_irqrestore(&vcs->capture_lock, flags);
2051			return 0;
2052		}
2053	}
2054
2055	err = vino_queue_get_incoming(&vcs->fb_queue, &incoming);
2056	if (err) {
2057		dprintk("vino_capture_next(): vino_queue_get_incoming() "
2058			"failed\n");
2059		err = -EINVAL;
2060		goto out;
2061	}
2062	if (incoming == 0) {
2063		dprintk("vino_capture_next(): no buffers available\n");
2064		goto out;
2065	}
2066
2067	fb = vino_queue_peek(&vcs->fb_queue, &id);
2068	if (fb == NULL) {
2069		dprintk("vino_capture_next(): vino_queue_peek() failed\n");
2070		err = -EINVAL;
2071		goto out;
2072	}
2073
2074	if (start) {
2075		vcs->capturing = 1;
2076	}
2077
2078	spin_unlock_irqrestore(&vcs->capture_lock, flags);
2079
2080	err = vino_capture(vcs, fb);
2081
2082	return err;
2083
2084out:
2085	vcs->capturing = 0;
2086	spin_unlock_irqrestore(&vcs->capture_lock, flags);
2087
2088	return err;
2089}
2090
2091static inline int vino_is_capturing(struct vino_channel_settings *vcs)
2092{
2093	int ret;
2094	unsigned long flags;
2095
2096	spin_lock_irqsave(&vcs->capture_lock, flags);
2097
2098	ret = vcs->capturing;
2099
2100	spin_unlock_irqrestore(&vcs->capture_lock, flags);
2101
2102	return ret;
2103}
2104
2105/* waits until a frame is captured */
2106static int vino_wait_for_frame(struct vino_channel_settings *vcs)
2107{
2108	wait_queue_t wait;
2109	int err = 0;
2110
2111	dprintk("vino_wait_for_frame():\n");
2112
2113	init_waitqueue_entry(&wait, current);
2114	/* add ourselves into wait queue */
2115	add_wait_queue(&vcs->fb_queue.frame_wait_queue, &wait);
2116
2117	/* to ensure that schedule_timeout will return immediately
2118	 * if VINO interrupt was triggered meanwhile */
2119	schedule_timeout_interruptible(msecs_to_jiffies(100));
2120
2121	if (signal_pending(current))
2122		err = -EINTR;
2123
2124	remove_wait_queue(&vcs->fb_queue.frame_wait_queue, &wait);
2125
2126	dprintk("vino_wait_for_frame(): waiting for frame %s\n",
2127		err ? "failed" : "ok");
2128
2129	return err;
2130}
2131
2132/* the function assumes that PAGE_SIZE % 4 == 0 */
2133static void vino_convert_to_rgba(struct vino_framebuffer *fb) {
2134	unsigned char *pageptr;
2135	unsigned int page, i;
2136	unsigned char a;
2137
2138	for (page = 0; page < fb->desc_table.page_count; page++) {
2139		pageptr = (unsigned char *)fb->desc_table.virtual[page];
2140
2141		for (i = 0; i < PAGE_SIZE; i += 4) {
2142			a = pageptr[0];
2143			pageptr[0] = pageptr[3];
2144			pageptr[1] = pageptr[2];
2145			pageptr[2] = pageptr[1];
2146			pageptr[3] = a;
2147			pageptr += 4;
2148		}
2149	}
2150}
2151
2152/* checks if the buffer is in correct state and syncs data */
2153static int vino_check_buffer(struct vino_channel_settings *vcs,
2154			     struct vino_framebuffer *fb)
2155{
2156	int err = 0;
2157	unsigned long flags;
2158
2159	dprintk("vino_check_buffer():\n");
2160
2161	spin_lock_irqsave(&fb->state_lock, flags);
2162	switch (fb->state) {
2163	case VINO_FRAMEBUFFER_IN_USE:
2164		err = -EIO;
2165		break;
2166	case VINO_FRAMEBUFFER_READY:
2167		vino_sync_buffer(fb);
2168		fb->state = VINO_FRAMEBUFFER_UNUSED;
2169		break;
2170	default:
2171		err = -EINVAL;
2172	}
2173	spin_unlock_irqrestore(&fb->state_lock, flags);
2174
2175	if (!err) {
2176		if (vino_pixel_conversion
2177		    && (fb->data_format == VINO_DATA_FMT_RGB32)) {
2178			vino_convert_to_rgba(fb);
2179		}
2180	} else if (err && (err != -EINVAL)) {
2181		dprintk("vino_check_buffer(): buffer not ready\n");
2182
2183		spin_lock_irqsave(&vino_drvdata->vino_lock, flags);
2184		vino_dma_stop(vcs);
2185		vino_clear_interrupt(vcs);
2186		spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags);
2187	}
2188
2189	return err;
2190}
2191
2192/* forcefully terminates capture */
2193static void vino_capture_stop(struct vino_channel_settings *vcs)
2194{
2195	unsigned int incoming = 0, outgoing = 0, id;
2196	unsigned long flags, flags2;
2197
2198	dprintk("vino_capture_stop():\n");
2199
2200	spin_lock_irqsave(&vcs->capture_lock, flags);
2201
2202	/* unset capturing to stop queue processing */
2203	vcs->capturing = 0;
2204
2205	spin_lock_irqsave(&vino_drvdata->vino_lock, flags2);
2206
2207	vino_dma_stop(vcs);
2208	vino_clear_interrupt(vcs);
2209
2210	spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags2);
2211
2212	/* remove all items from the queue */
2213	if (vino_queue_get_incoming(&vcs->fb_queue, &incoming)) {
2214		dprintk("vino_capture_stop(): "
2215			"vino_queue_get_incoming() failed\n");
2216		goto out;
2217	}
2218	while (incoming > 0) {
2219		vino_queue_transfer(&vcs->fb_queue);
2220
2221		if (vino_queue_get_incoming(&vcs->fb_queue, &incoming)) {
2222			dprintk("vino_capture_stop(): "
2223				"vino_queue_get_incoming() failed\n");
2224			goto out;
2225		}
2226	}
2227
2228	if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
2229		dprintk("vino_capture_stop(): "
2230			"vino_queue_get_outgoing() failed\n");
2231		goto out;
2232	}
2233	while (outgoing > 0) {
2234		vino_queue_remove(&vcs->fb_queue, &id);
2235
2236		if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
2237			dprintk("vino_capture_stop(): "
2238				"vino_queue_get_outgoing() failed\n");
2239			goto out;
2240		}
2241	}
2242
2243out:
2244	spin_unlock_irqrestore(&vcs->capture_lock, flags);
2245}
2246
2247#if 0
2248static int vino_capture_failed(struct vino_channel_settings *vcs)
2249{
2250	struct vino_framebuffer *fb;
2251	unsigned long flags;
2252	unsigned int i;
2253	int ret;
2254
2255	dprintk("vino_capture_failed():\n");
2256
2257	spin_lock_irqsave(&vino_drvdata->vino_lock, flags);
2258
2259	vino_dma_stop(vcs);
2260	vino_clear_interrupt(vcs);
2261
2262	spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags);
2263
2264	ret = vino_queue_get_incoming(&vcs->fb_queue, &i);
2265	if (ret == VINO_QUEUE_ERROR) {
2266		dprintk("vino_queue_get_incoming() failed\n");
2267		return -EINVAL;
2268	}
2269	if (i == 0) {
2270		/* no buffers to process */
2271		return 0;
2272	}
2273
2274	fb = vino_queue_peek(&vcs->fb_queue, &i);
2275	if (fb == NULL) {
2276		dprintk("vino_queue_peek() failed\n");
2277		return -EINVAL;
2278	}
2279
2280	spin_lock_irqsave(&fb->state_lock, flags);
2281	if (fb->state == VINO_FRAMEBUFFER_IN_USE) {
2282		fb->state = VINO_FRAMEBUFFER_UNUSED;
2283		vino_queue_transfer(&vcs->fb_queue);
2284		vino_queue_remove(&vcs->fb_queue, &i);
2285		/* we should actually discard the newest frame,
2286		 * but who cares ... */
2287	}
2288	spin_unlock_irqrestore(&fb->state_lock, flags);
2289
2290	return 0;
2291}
2292#endif
2293
2294static void vino_skip_frame(struct vino_channel_settings *vcs)
2295{
2296	struct vino_framebuffer *fb;
2297	unsigned long flags;
2298	unsigned int id;
2299
2300	spin_lock_irqsave(&vcs->capture_lock, flags);
2301	fb = vino_queue_peek(&vcs->fb_queue, &id);
2302	if (!fb) {
2303		spin_unlock_irqrestore(&vcs->capture_lock, flags);
2304		dprintk("vino_skip_frame(): vino_queue_peek() failed!\n");
2305		return;
2306	}
2307	spin_unlock_irqrestore(&vcs->capture_lock, flags);
2308
2309	spin_lock_irqsave(&fb->state_lock, flags);
2310	fb->state = VINO_FRAMEBUFFER_UNUSED;
2311	spin_unlock_irqrestore(&fb->state_lock, flags);
2312
2313	vino_capture_next(vcs, 0);
2314}
2315
2316static void vino_frame_done(struct vino_channel_settings *vcs)
2317{
2318	struct vino_framebuffer *fb;
2319	unsigned long flags;
2320
2321	spin_lock_irqsave(&vcs->capture_lock, flags);
2322	fb = vino_queue_transfer(&vcs->fb_queue);
2323	if (!fb) {
2324		spin_unlock_irqrestore(&vcs->capture_lock, flags);
2325		dprintk("vino_frame_done(): vino_queue_transfer() failed!\n");
2326		return;
2327	}
2328	spin_unlock_irqrestore(&vcs->capture_lock, flags);
2329
2330	fb->frame_counter = vcs->int_data.frame_counter;
2331	memcpy(&fb->timestamp, &vcs->int_data.timestamp,
2332	       sizeof(struct timeval));
2333
2334	spin_lock_irqsave(&fb->state_lock, flags);
2335	if (fb->state == VINO_FRAMEBUFFER_IN_USE)
2336		fb->state = VINO_FRAMEBUFFER_READY;
2337	spin_unlock_irqrestore(&fb->state_lock, flags);
2338
2339	wake_up(&vcs->fb_queue.frame_wait_queue);
2340
2341	vino_capture_next(vcs, 0);
2342}
2343
2344static void vino_capture_tasklet(unsigned long channel) {
2345	struct vino_channel_settings *vcs;
2346
2347	vcs = (channel == VINO_CHANNEL_A)
2348		? &vino_drvdata->a : &vino_drvdata->b;
2349
2350	if (vcs->int_data.skip)
2351		vcs->int_data.skip_count++;
2352
2353	if (vcs->int_data.skip && (vcs->int_data.skip_count
2354				   <= VINO_MAX_FRAME_SKIP_COUNT)) {
2355		vino_skip_frame(vcs);
2356	} else {
2357		vcs->int_data.skip_count = 0;
2358		vino_frame_done(vcs);
2359	}
2360}
2361
2362static irqreturn_t vino_interrupt(int irq, void *dev_id)
2363{
2364	u32 ctrl, intr;
2365	unsigned int fc_a, fc_b;
2366	int handled_a = 0, skip_a = 0, done_a = 0;
2367	int handled_b = 0, skip_b = 0, done_b = 0;
2368
2369#ifdef VINO_DEBUG_INT
2370	int loop = 0;
2371	unsigned int line_count = vino->a.line_count,
2372		page_index = vino->a.page_index,
2373		field_counter = vino->a.field_counter,
2374		start_desc_tbl = vino->a.start_desc_tbl,
2375		next_4_desc = vino->a.next_4_desc;
2376	unsigned int line_count_2,
2377		page_index_2,
2378		field_counter_2,
2379		start_desc_tbl_2,
2380		next_4_desc_2;
2381#endif
2382
2383	spin_lock(&vino_drvdata->vino_lock);
2384
2385	while ((intr = vino->intr_status)) {
2386		fc_a = vino->a.field_counter >> 1;
2387		fc_b = vino->b.field_counter >> 1;
2388
2389		/* handle error-interrupts in some special way ?
2390		 * --> skips frames */
2391		if (intr & VINO_INTSTAT_A) {
2392			if (intr & VINO_INTSTAT_A_EOF) {
2393				vino_drvdata->a.field++;
2394				if (vino_drvdata->a.field > 1) {
2395					vino_dma_stop(&vino_drvdata->a);
2396					vino_clear_interrupt(&vino_drvdata->a);
2397					vino_drvdata->a.field = 0;
2398					done_a = 1;
2399				} else {
2400					if (vino->a.page_index
2401					    != vino_drvdata->a.line_size) {
2402						vino->a.line_count = 0;
2403						vino->a.page_index =
2404							vino_drvdata->
2405							a.line_size;
2406						vino->a.next_4_desc =
2407							vino->a.start_desc_tbl;
2408					}
2409				}
2410				dprintk("channel A end-of-field "
2411					"interrupt: %04x\n", intr);
2412			} else {
2413				vino_dma_stop(&vino_drvdata->a);
2414				vino_clear_interrupt(&vino_drvdata->a);
2415				vino_drvdata->a.field = 0;
2416				skip_a = 1;
2417				dprintk("channel A error interrupt: %04x\n",
2418					intr);
2419			}
2420
2421#ifdef VINO_DEBUG_INT
2422			line_count_2 = vino->a.line_count;
2423			page_index_2 = vino->a.page_index;
2424			field_counter_2 = vino->a.field_counter;
2425			start_desc_tbl_2 = vino->a.start_desc_tbl;
2426			next_4_desc_2 = vino->a.next_4_desc;
2427
2428			printk("intr = %04x, loop = %d, field = %d\n",
2429			       intr, loop, vino_drvdata->a.field);
2430			printk("1- line count = %04d, page index = %04d, "
2431			       "start = %08x, next = %08x\n"
2432			       "   fieldc = %d, framec = %d\n",
2433			       line_count, page_index, start_desc_tbl,
2434			       next_4_desc, field_counter, fc_a);
2435			printk("12-line count = %04d, page index = %04d, "
2436			       "   start = %08x, next = %08x\n",
2437			       line_count_2, page_index_2, start_desc_tbl_2,
2438			       next_4_desc_2);
2439
2440			if (done_a)
2441				printk("\n");
2442#endif
2443		}
2444
2445		if (intr & VINO_INTSTAT_B) {
2446			if (intr & VINO_INTSTAT_B_EOF) {
2447				vino_drvdata->b.field++;
2448				if (vino_drvdata->b.field > 1) {
2449					vino_dma_stop(&vino_drvdata->b);
2450					vino_clear_interrupt(&vino_drvdata->b);
2451					vino_drvdata->b.field = 0;
2452					done_b = 1;
2453				}
2454				dprintk("channel B end-of-field "
2455					"interrupt: %04x\n", intr);
2456			} else {
2457				vino_dma_stop(&vino_drvdata->b);
2458				vino_clear_interrupt(&vino_drvdata->b);
2459				vino_drvdata->b.field = 0;
2460				skip_b = 1;
2461				dprintk("channel B error interrupt: %04x\n",
2462					intr);
2463			}
2464		}
2465
2466		/* Always remember to clear interrupt status.
2467		 * Disable VINO interrupts while we do this. */
2468		ctrl = vino->control;
2469		vino->control = ctrl & ~(VINO_CTRL_A_INT | VINO_CTRL_B_INT);
2470		vino->intr_status = ~intr;
2471		vino->control = ctrl;
2472
2473		spin_unlock(&vino_drvdata->vino_lock);
2474
2475		if ((!handled_a) && (done_a || skip_a)) {
2476			if (!skip_a) {
2477				do_gettimeofday(&vino_drvdata->
2478						a.int_data.timestamp);
2479				vino_drvdata->a.int_data.frame_counter = fc_a;
2480			}
2481			vino_drvdata->a.int_data.skip = skip_a;
2482
2483			dprintk("channel A %s, interrupt: %d\n",
2484				skip_a ? "skipping frame" : "frame done",
2485				intr);
2486			tasklet_hi_schedule(&vino_tasklet_a);
2487			handled_a = 1;
2488		}
2489
2490		if ((!handled_b) && (done_b || skip_b)) {
2491			if (!skip_b) {
2492				do_gettimeofday(&vino_drvdata->
2493						b.int_data.timestamp);
2494				vino_drvdata->b.int_data.frame_counter = fc_b;
2495			}
2496			vino_drvdata->b.int_data.skip = skip_b;
2497
2498			dprintk("channel B %s, interrupt: %d\n",
2499				skip_b ? "skipping frame" : "frame done",
2500				intr);
2501			tasklet_hi_schedule(&vino_tasklet_b);
2502			handled_b = 1;
2503		}
2504
2505#ifdef VINO_DEBUG_INT
2506		loop++;
2507#endif
2508		spin_lock(&vino_drvdata->vino_lock);
2509	}
2510
2511	spin_unlock(&vino_drvdata->vino_lock);
2512
2513	return IRQ_HANDLED;
2514}
2515
2516/* VINO video input management */
2517
2518static int vino_get_saa7191_input(int input)
2519{
2520	switch (input) {
2521	case VINO_INPUT_COMPOSITE:
2522		return SAA7191_INPUT_COMPOSITE;
2523	case VINO_INPUT_SVIDEO:
2524		return SAA7191_INPUT_SVIDEO;
2525	default:
2526		printk(KERN_ERR "VINO: vino_get_saa7191_input(): "
2527		       "invalid input!\n");
2528		return -1;
2529	}
2530}
2531
2532/* execute with input_lock locked */
2533static int vino_is_input_owner(struct vino_channel_settings *vcs)
2534{
2535	switch(vcs->input) {
2536	case VINO_INPUT_COMPOSITE:
2537	case VINO_INPUT_SVIDEO:
2538		return vino_drvdata->decoder_owner == vcs->channel;
2539	case VINO_INPUT_D1:
2540		return vino_drvdata->camera_owner == vcs->channel;
2541	default:
2542		return 0;
2543	}
2544}
2545
2546static int vino_acquire_input(struct vino_channel_settings *vcs)
2547{
2548	unsigned long flags;
2549	int ret = 0;
2550
2551	dprintk("vino_acquire_input():\n");
2552
2553	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
2554
2555	/* First try D1 and then SAA7191 */
2556	if (vino_drvdata->camera
2557	    && (vino_drvdata->camera_owner == VINO_NO_CHANNEL)) {
2558		vino_drvdata->camera_owner = vcs->channel;
2559		vcs->input = VINO_INPUT_D1;
2560		vcs->data_norm = VINO_DATA_NORM_D1;
2561	} else if (vino_drvdata->decoder
2562		   && (vino_drvdata->decoder_owner == VINO_NO_CHANNEL)) {
2563		int input;
2564		int data_norm = 0;
2565		v4l2_std_id norm;
2566
2567		input = VINO_INPUT_COMPOSITE;
2568
2569		ret = decoder_call(video, s_routing,
2570				vino_get_saa7191_input(input), 0, 0);
2571		if (ret) {
2572			ret = -EINVAL;
2573			goto out;
2574		}
2575
2576		spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
2577
2578		/* Don't hold spinlocks while auto-detecting norm
2579		 * as it may take a while... */
2580
2581		ret = decoder_call(video, querystd, &norm);
2582		if (!ret) {
2583			for (data_norm = 0; data_norm < 3; data_norm++) {
2584				if (vino_data_norms[data_norm].std & norm)
2585					break;
2586			}
2587			if (data_norm == 3)
2588				data_norm = VINO_DATA_NORM_PAL;
2589			ret = decoder_call(core, s_std, norm);
2590		}
2591
2592		spin_lock_irqsave(&vino_drvdata->input_lock, flags);
2593
2594		if (ret) {
2595			ret = -EINVAL;
2596			goto out;
2597		}
2598
2599		vino_drvdata->decoder_owner = vcs->channel;
2600
2601		vcs->input = input;
2602		vcs->data_norm = data_norm;
2603	} else {
2604		vcs->input = (vcs->channel == VINO_CHANNEL_A) ?
2605			vino_drvdata->b.input : vino_drvdata->a.input;
2606		vcs->data_norm = (vcs->channel == VINO_CHANNEL_A) ?
2607			vino_drvdata->b.data_norm : vino_drvdata->a.data_norm;
2608	}
2609
2610	if (vcs->input == VINO_INPUT_NONE) {
2611		ret = -ENODEV;
2612		goto out;
2613	}
2614
2615	vino_set_default_clipping(vcs);
2616	vino_set_default_scaling(vcs);
2617	vino_set_default_framerate(vcs);
2618
2619	dprintk("vino_acquire_input(): %s\n", vino_inputs[vcs->input].name);
2620
2621out:
2622	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
2623
2624	return ret;
2625}
2626
2627static int vino_set_input(struct vino_channel_settings *vcs, int input)
2628{
2629	struct vino_channel_settings *vcs2 = (vcs->channel == VINO_CHANNEL_A) ?
2630		&vino_drvdata->b : &vino_drvdata->a;
2631	unsigned long flags;
2632	int ret = 0;
2633
2634	dprintk("vino_set_input():\n");
2635
2636	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
2637
2638	if (vcs->input == input)
2639		goto out;
2640
2641	switch (input) {
2642	case VINO_INPUT_COMPOSITE:
2643	case VINO_INPUT_SVIDEO:
2644		if (!vino_drvdata->decoder) {
2645			ret = -EINVAL;
2646			goto out;
2647		}
2648
2649		if (vino_drvdata->decoder_owner == VINO_NO_CHANNEL) {
2650			vino_drvdata->decoder_owner = vcs->channel;
2651		}
2652
2653		if (vino_drvdata->decoder_owner == vcs->channel) {
2654			int data_norm = 0;
2655			v4l2_std_id norm;
2656
2657			ret = decoder_call(video, s_routing,
2658					vino_get_saa7191_input(input), 0, 0);
2659			if (ret) {
2660				vino_drvdata->decoder_owner = VINO_NO_CHANNEL;
2661				ret = -EINVAL;
2662				goto out;
2663			}
2664
2665			spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
2666
2667			/* Don't hold spinlocks while auto-detecting norm
2668			 * as it may take a while... */
2669
2670			ret = decoder_call(video, querystd, &norm);
2671			if (!ret) {
2672				for (data_norm = 0; data_norm < 3; data_norm++) {
2673					if (vino_data_norms[data_norm].std & norm)
2674						break;
2675				}
2676				if (data_norm == 3)
2677					data_norm = VINO_DATA_NORM_PAL;
2678				ret = decoder_call(core, s_std, norm);
2679			}
2680
2681			spin_lock_irqsave(&vino_drvdata->input_lock, flags);
2682
2683			if (ret) {
2684				vino_drvdata->decoder_owner = VINO_NO_CHANNEL;
2685				ret = -EINVAL;
2686				goto out;
2687			}
2688
2689			vcs->input = input;
2690			vcs->data_norm = data_norm;
2691		} else {
2692			if (input != vcs2->input) {
2693				ret = -EBUSY;
2694				goto out;
2695			}
2696
2697			vcs->input = input;
2698			vcs->data_norm = vcs2->data_norm;
2699		}
2700
2701		if (vino_drvdata->camera_owner == vcs->channel) {
2702			/* Transfer the ownership or release the input */
2703			if (vcs2->input == VINO_INPUT_D1) {
2704				vino_drvdata->camera_owner = vcs2->channel;
2705			} else {
2706				vino_drvdata->camera_owner = VINO_NO_CHANNEL;
2707			}
2708		}
2709		break;
2710	case VINO_INPUT_D1:
2711		if (!vino_drvdata->camera) {
2712			ret = -EINVAL;
2713			goto out;
2714		}
2715
2716		if (vino_drvdata->camera_owner == VINO_NO_CHANNEL)
2717			vino_drvdata->camera_owner = vcs->channel;
2718
2719		if (vino_drvdata->decoder_owner == vcs->channel) {
2720			/* Transfer the ownership or release the input */
2721			if ((vcs2->input == VINO_INPUT_COMPOSITE) ||
2722				 (vcs2->input == VINO_INPUT_SVIDEO)) {
2723				vino_drvdata->decoder_owner = vcs2->channel;
2724			} else {
2725				vino_drvdata->decoder_owner = VINO_NO_CHANNEL;
2726			}
2727		}
2728
2729		vcs->input = input;
2730		vcs->data_norm = VINO_DATA_NORM_D1;
2731		break;
2732	default:
2733		ret = -EINVAL;
2734		goto out;
2735	}
2736
2737	vino_set_default_clipping(vcs);
2738	vino_set_default_scaling(vcs);
2739	vino_set_default_framerate(vcs);
2740
2741	dprintk("vino_set_input(): %s\n", vino_inputs[vcs->input].name);
2742
2743out:
2744	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
2745
2746	return ret;
2747}
2748
2749static void vino_release_input(struct vino_channel_settings *vcs)
2750{
2751	struct vino_channel_settings *vcs2 = (vcs->channel == VINO_CHANNEL_A) ?
2752		&vino_drvdata->b : &vino_drvdata->a;
2753	unsigned long flags;
2754
2755	dprintk("vino_release_input():\n");
2756
2757	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
2758
2759	/* Release ownership of the channel
2760	 * and if the other channel takes input from
2761	 * the same source, transfer the ownership */
2762	if (vino_drvdata->camera_owner == vcs->channel) {
2763		if (vcs2->input == VINO_INPUT_D1) {
2764			vino_drvdata->camera_owner = vcs2->channel;
2765		} else {
2766			vino_drvdata->camera_owner = VINO_NO_CHANNEL;
2767		}
2768	} else if (vino_drvdata->decoder_owner == vcs->channel) {
2769		if ((vcs2->input == VINO_INPUT_COMPOSITE) ||
2770			 (vcs2->input == VINO_INPUT_SVIDEO)) {
2771			vino_drvdata->decoder_owner = vcs2->channel;
2772		} else {
2773			vino_drvdata->decoder_owner = VINO_NO_CHANNEL;
2774		}
2775	}
2776	vcs->input = VINO_INPUT_NONE;
2777
2778	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
2779}
2780
2781/* execute with input_lock locked */
2782static int vino_set_data_norm(struct vino_channel_settings *vcs,
2783			      unsigned int data_norm,
2784			      unsigned long *flags)
2785{
2786	int err = 0;
2787
2788	if (data_norm == vcs->data_norm)
2789		return 0;
2790
2791	switch (vcs->input) {
2792	case VINO_INPUT_D1:
2793		/* only one "norm" supported */
2794		if (data_norm != VINO_DATA_NORM_D1)
2795			return -EINVAL;
2796		break;
2797	case VINO_INPUT_COMPOSITE:
2798	case VINO_INPUT_SVIDEO: {
2799		v4l2_std_id norm;
2800
2801		if ((data_norm != VINO_DATA_NORM_PAL)
2802		    && (data_norm != VINO_DATA_NORM_NTSC)
2803		    && (data_norm != VINO_DATA_NORM_SECAM))
2804			return -EINVAL;
2805
2806		spin_unlock_irqrestore(&vino_drvdata->input_lock, *flags);
2807
2808		/* Don't hold spinlocks while setting norm
2809		 * as it may take a while... */
2810
2811		norm = vino_data_norms[data_norm].std;
2812		err = decoder_call(core, s_std, norm);
2813
2814		spin_lock_irqsave(&vino_drvdata->input_lock, *flags);
2815
2816		if (err)
2817			goto out;
2818
2819		vcs->data_norm = data_norm;
2820
2821		vino_set_default_clipping(vcs);
2822		vino_set_default_scaling(vcs);
2823		vino_set_default_framerate(vcs);
2824		break;
2825	}
2826	default:
2827		return -EINVAL;
2828	}
2829
2830out:
2831	return err;
2832}
2833
2834/* V4L2 helper functions */
2835
2836static int vino_find_data_format(__u32 pixelformat)
2837{
2838	int i;
2839
2840	for (i = 0; i < VINO_DATA_FMT_COUNT; i++) {
2841		if (vino_data_formats[i].pixelformat == pixelformat)
2842			return i;
2843	}
2844
2845	return VINO_DATA_FMT_NONE;
2846}
2847
2848static int vino_int_enum_input(struct vino_channel_settings *vcs, __u32 index)
2849{
2850	int input = VINO_INPUT_NONE;
2851	unsigned long flags;
2852
2853	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
2854	if (vino_drvdata->decoder && vino_drvdata->camera) {
2855		switch (index) {
2856		case 0:
2857			input = VINO_INPUT_COMPOSITE;
2858			break;
2859		case 1:
2860			input = VINO_INPUT_SVIDEO;
2861			break;
2862		case 2:
2863			input = VINO_INPUT_D1;
2864			break;
2865		}
2866	} else if (vino_drvdata->decoder) {
2867		switch (index) {
2868		case 0:
2869			input = VINO_INPUT_COMPOSITE;
2870			break;
2871		case 1:
2872			input = VINO_INPUT_SVIDEO;
2873			break;
2874		}
2875	} else if (vino_drvdata->camera) {
2876		switch (index) {
2877		case 0:
2878			input = VINO_INPUT_D1;
2879			break;
2880		}
2881	}
2882	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
2883
2884	return input;
2885}
2886
2887/* execute with input_lock locked */
2888static __u32 vino_find_input_index(struct vino_channel_settings *vcs)
2889{
2890	__u32 index = 0;
2891	// FIXME: detect when no inputs available
2892
2893	if (vino_drvdata->decoder && vino_drvdata->camera) {
2894		switch (vcs->input) {
2895		case VINO_INPUT_COMPOSITE:
2896			index = 0;
2897			break;
2898		case VINO_INPUT_SVIDEO:
2899			index = 1;
2900			break;
2901		case VINO_INPUT_D1:
2902			index = 2;
2903			break;
2904		}
2905	} else if (vino_drvdata->decoder) {
2906		switch (vcs->input) {
2907		case VINO_INPUT_COMPOSITE:
2908			index = 0;
2909			break;
2910		case VINO_INPUT_SVIDEO:
2911			index = 1;
2912			break;
2913		}
2914	} else if (vino_drvdata->camera) {
2915		switch (vcs->input) {
2916		case VINO_INPUT_D1:
2917			index = 0;
2918			break;
2919		}
2920	}
2921
2922	return index;
2923}
2924
2925/* V4L2 ioctls */
2926
2927static int vino_querycap(struct file *file, void *__fh,
2928		struct v4l2_capability *cap)
2929{
2930	memset(cap, 0, sizeof(struct v4l2_capability));
2931
2932	strcpy(cap->driver, vino_driver_name);
2933	strcpy(cap->card, vino_driver_description);
2934	strcpy(cap->bus_info, vino_bus_name);
2935	cap->capabilities =
2936		V4L2_CAP_VIDEO_CAPTURE |
2937		V4L2_CAP_STREAMING;
2938	// V4L2_CAP_OVERLAY, V4L2_CAP_READWRITE
2939	return 0;
2940}
2941
2942static int vino_enum_input(struct file *file, void *__fh,
2943			       struct v4l2_input *i)
2944{
2945	struct vino_channel_settings *vcs = video_drvdata(file);
2946	__u32 index = i->index;
2947	int input;
2948	dprintk("requested index = %d\n", index);
2949
2950	input = vino_int_enum_input(vcs, index);
2951	if (input == VINO_INPUT_NONE)
2952		return -EINVAL;
2953
2954	i->type = V4L2_INPUT_TYPE_CAMERA;
2955	i->std = vino_inputs[input].std;
2956	strcpy(i->name, vino_inputs[input].name);
2957
2958	if (input == VINO_INPUT_COMPOSITE || input == VINO_INPUT_SVIDEO)
2959		decoder_call(video, g_input_status, &i->status);
2960	return 0;
2961}
2962
2963static int vino_g_input(struct file *file, void *__fh,
2964			     unsigned int *i)
2965{
2966	struct vino_channel_settings *vcs = video_drvdata(file);
2967	__u32 index;
2968	int input;
2969	unsigned long flags;
2970
2971	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
2972	input = vcs->input;
2973	index = vino_find_input_index(vcs);
2974	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
2975
2976	dprintk("input = %d\n", input);
2977
2978	if (input == VINO_INPUT_NONE) {
2979		return -EINVAL;
2980	}
2981
2982	*i = index;
2983
2984	return 0;
2985}
2986
2987static int vino_s_input(struct file *file, void *__fh,
2988			     unsigned int i)
2989{
2990	struct vino_channel_settings *vcs = video_drvdata(file);
2991	int input;
2992	dprintk("requested input = %d\n", i);
2993
2994	input = vino_int_enum_input(vcs, i);
2995	if (input == VINO_INPUT_NONE)
2996		return -EINVAL;
2997
2998	return vino_set_input(vcs, input);
2999}
3000
3001static int vino_querystd(struct file *file, void *__fh,
3002			      v4l2_std_id *std)
3003{
3004	struct vino_channel_settings *vcs = video_drvdata(file);
3005	unsigned long flags;
3006	int err = 0;
3007
3008	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3009
3010	switch (vcs->input) {
3011	case VINO_INPUT_D1:
3012		*std = vino_inputs[vcs->input].std;
3013		break;
3014	case VINO_INPUT_COMPOSITE:
3015	case VINO_INPUT_SVIDEO: {
3016		decoder_call(video, querystd, std);
3017		break;
3018	}
3019	default:
3020		err = -EINVAL;
3021	}
3022
3023	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3024
3025	return err;
3026}
3027
3028static int vino_g_std(struct file *file, void *__fh,
3029			   v4l2_std_id *std)
3030{
3031	struct vino_channel_settings *vcs = video_drvdata(file);
3032	unsigned long flags;
3033
3034	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3035
3036	*std = vino_data_norms[vcs->data_norm].std;
3037	dprintk("current standard = %d\n", vcs->data_norm);
3038
3039	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3040
3041	return 0;
3042}
3043
3044static int vino_s_std(struct file *file, void *__fh,
3045			   v4l2_std_id *std)
3046{
3047	struct vino_channel_settings *vcs = video_drvdata(file);
3048	unsigned long flags;
3049	int ret = 0;
3050
3051	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3052
3053	if (!vino_is_input_owner(vcs)) {
3054		ret = -EBUSY;
3055		goto out;
3056	}
3057
3058	/* check if the standard is valid for the current input */
3059	if ((*std) & vino_inputs[vcs->input].std) {
3060		dprintk("standard accepted\n");
3061
3062		/* change the video norm for SAA7191
3063		 * and accept NTSC for D1 (do nothing) */
3064
3065		if (vcs->input == VINO_INPUT_D1)
3066			goto out;
3067
3068		if ((*std) & V4L2_STD_PAL) {
3069			ret = vino_set_data_norm(vcs, VINO_DATA_NORM_PAL,
3070						 &flags);
3071		} else if ((*std) & V4L2_STD_NTSC) {
3072			ret = vino_set_data_norm(vcs, VINO_DATA_NORM_NTSC,
3073						 &flags);
3074		} else if ((*std) & V4L2_STD_SECAM) {
3075			ret = vino_set_data_norm(vcs, VINO_DATA_NORM_SECAM,
3076						 &flags);
3077		} else {
3078			ret = -EINVAL;
3079		}
3080
3081		if (ret) {
3082			ret = -EINVAL;
3083		}
3084	} else {
3085		ret = -EINVAL;
3086	}
3087
3088out:
3089	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3090
3091	return ret;
3092}
3093
3094static int vino_enum_fmt_vid_cap(struct file *file, void *__fh,
3095			      struct v4l2_fmtdesc *fd)
3096{
3097	dprintk("format index = %d\n", fd->index);
3098
3099	if (fd->index >= VINO_DATA_FMT_COUNT)
3100		return -EINVAL;
3101	dprintk("format name = %s\n", vino_data_formats[fd->index].description);
3102
3103	fd->pixelformat = vino_data_formats[fd->index].pixelformat;
3104	strcpy(fd->description, vino_data_formats[fd->index].description);
3105	return 0;
3106}
3107
3108static int vino_try_fmt_vid_cap(struct file *file, void *__fh,
3109			     struct v4l2_format *f)
3110{
3111	struct vino_channel_settings *vcs = video_drvdata(file);
3112	struct vino_channel_settings tempvcs;
3113	unsigned long flags;
3114	struct v4l2_pix_format *pf = &f->fmt.pix;
3115
3116	dprintk("requested: w = %d, h = %d\n",
3117			pf->width, pf->height);
3118
3119	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3120	memcpy(&tempvcs, vcs, sizeof(struct vino_channel_settings));
3121	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3122
3123	tempvcs.data_format = vino_find_data_format(pf->pixelformat);
3124	if (tempvcs.data_format == VINO_DATA_FMT_NONE) {
3125		tempvcs.data_format = VINO_DATA_FMT_GREY;
3126		pf->pixelformat =
3127			vino_data_formats[tempvcs.data_format].
3128			pixelformat;
3129	}
3130
3131	/* data format must be set before clipping/scaling */
3132	vino_set_scaling(&tempvcs, pf->width, pf->height);
3133
3134	dprintk("data format = %s\n",
3135			vino_data_formats[tempvcs.data_format].description);
3136
3137	pf->width = (tempvcs.clipping.right - tempvcs.clipping.left) /
3138		tempvcs.decimation;
3139	pf->height = (tempvcs.clipping.bottom - tempvcs.clipping.top) /
3140		tempvcs.decimation;
3141
3142	pf->field = V4L2_FIELD_INTERLACED;
3143	pf->bytesperline = tempvcs.line_size;
3144	pf->sizeimage = tempvcs.line_size *
3145		(tempvcs.clipping.bottom - tempvcs.clipping.top) /
3146		tempvcs.decimation;
3147	pf->colorspace =
3148		vino_data_formats[tempvcs.data_format].colorspace;
3149
3150	pf->priv = 0;
3151	return 0;
3152}
3153
3154static int vino_g_fmt_vid_cap(struct file *file, void *__fh,
3155			   struct v4l2_format *f)
3156{
3157	struct vino_channel_settings *vcs = video_drvdata(file);
3158	unsigned long flags;
3159	struct v4l2_pix_format *pf = &f->fmt.pix;
3160
3161	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3162
3163	pf->width = (vcs->clipping.right - vcs->clipping.left) /
3164		vcs->decimation;
3165	pf->height = (vcs->clipping.bottom - vcs->clipping.top) /
3166		vcs->decimation;
3167	pf->pixelformat =
3168		vino_data_formats[vcs->data_format].pixelformat;
3169
3170	pf->field = V4L2_FIELD_INTERLACED;
3171	pf->bytesperline = vcs->line_size;
3172	pf->sizeimage = vcs->line_size *
3173		(vcs->clipping.bottom - vcs->clipping.top) /
3174		vcs->decimation;
3175	pf->colorspace =
3176		vino_data_formats[vcs->data_format].colorspace;
3177
3178	pf->priv = 0;
3179
3180	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3181	return 0;
3182}
3183
3184static int vino_s_fmt_vid_cap(struct file *file, void *__fh,
3185			   struct v4l2_format *f)
3186{
3187	struct vino_channel_settings *vcs = video_drvdata(file);
3188	int data_format;
3189	unsigned long flags;
3190	struct v4l2_pix_format *pf = &f->fmt.pix;
3191
3192	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3193
3194	data_format = vino_find_data_format(pf->pixelformat);
3195
3196	if (data_format == VINO_DATA_FMT_NONE) {
3197		vcs->data_format = VINO_DATA_FMT_GREY;
3198		pf->pixelformat =
3199			vino_data_formats[vcs->data_format].
3200			pixelformat;
3201	} else {
3202		vcs->data_format = data_format;
3203	}
3204
3205	/* data format must be set before clipping/scaling */
3206	vino_set_scaling(vcs, pf->width, pf->height);
3207
3208	dprintk("data format = %s\n",
3209	       vino_data_formats[vcs->data_format].description);
3210
3211	pf->width = vcs->clipping.right - vcs->clipping.left;
3212	pf->height = vcs->clipping.bottom - vcs->clipping.top;
3213
3214	pf->field = V4L2_FIELD_INTERLACED;
3215	pf->bytesperline = vcs->line_size;
3216	pf->sizeimage = vcs->line_size *
3217		(vcs->clipping.bottom - vcs->clipping.top) /
3218		vcs->decimation;
3219	pf->colorspace =
3220		vino_data_formats[vcs->data_format].colorspace;
3221
3222	pf->priv = 0;
3223
3224	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3225	return 0;
3226}
3227
3228static int vino_cropcap(struct file *file, void *__fh,
3229			     struct v4l2_cropcap *ccap)
3230{
3231	struct vino_channel_settings *vcs = video_drvdata(file);
3232	const struct vino_data_norm *norm;
3233	unsigned long flags;
3234
3235	switch (ccap->type) {
3236	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3237		spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3238
3239		norm = &vino_data_norms[vcs->data_norm];
3240
3241		spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3242
3243		ccap->bounds.left = 0;
3244		ccap->bounds.top = 0;
3245		ccap->bounds.width = norm->width;
3246		ccap->bounds.height = norm->height;
3247		memcpy(&ccap->defrect, &ccap->bounds,
3248		       sizeof(struct v4l2_rect));
3249
3250		ccap->pixelaspect.numerator = 1;
3251		ccap->pixelaspect.denominator = 1;
3252		break;
3253	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
3254	default:
3255		return -EINVAL;
3256	}
3257
3258	return 0;
3259}
3260
3261static int vino_g_crop(struct file *file, void *__fh,
3262			    struct v4l2_crop *c)
3263{
3264	struct vino_channel_settings *vcs = video_drvdata(file);
3265	unsigned long flags;
3266
3267	switch (c->type) {
3268	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3269		spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3270
3271		c->c.left = vcs->clipping.left;
3272		c->c.top = vcs->clipping.top;
3273		c->c.width = vcs->clipping.right - vcs->clipping.left;
3274		c->c.height = vcs->clipping.bottom - vcs->clipping.top;
3275
3276		spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3277		break;
3278	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
3279	default:
3280		return -EINVAL;
3281	}
3282
3283	return 0;
3284}
3285
3286static int vino_s_crop(struct file *file, void *__fh,
3287			    struct v4l2_crop *c)
3288{
3289	struct vino_channel_settings *vcs = video_drvdata(file);
3290	unsigned long flags;
3291
3292	switch (c->type) {
3293	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3294		spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3295
3296		vino_set_clipping(vcs, c->c.left, c->c.top,
3297				  c->c.width, c->c.height);
3298
3299		spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3300		break;
3301	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
3302	default:
3303		return -EINVAL;
3304	}
3305
3306	return 0;
3307}
3308
3309static int vino_g_parm(struct file *file, void *__fh,
3310			    struct v4l2_streamparm *sp)
3311{
3312	struct vino_channel_settings *vcs = video_drvdata(file);
3313	unsigned long flags;
3314	struct v4l2_captureparm *cp = &sp->parm.capture;
3315
3316	cp->capability = V4L2_CAP_TIMEPERFRAME;
3317	cp->timeperframe.numerator = 1;
3318
3319	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3320
3321	cp->timeperframe.denominator = vcs->fps;
3322
3323	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3324
3325	/* TODO: cp->readbuffers = xxx; */
3326
3327	return 0;
3328}
3329
3330static int vino_s_parm(struct file *file, void *__fh,
3331			    struct v4l2_streamparm *sp)
3332{
3333	struct vino_channel_settings *vcs = video_drvdata(file);
3334	unsigned long flags;
3335	struct v4l2_captureparm *cp = &sp->parm.capture;
3336
3337	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3338
3339	if ((cp->timeperframe.numerator == 0) ||
3340	    (cp->timeperframe.denominator == 0)) {
3341		/* reset framerate */
3342		vino_set_default_framerate(vcs);
3343	} else {
3344		vino_set_framerate(vcs, cp->timeperframe.denominator /
3345				   cp->timeperframe.numerator);
3346	}
3347
3348	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3349
3350	return 0;
3351}
3352
3353static int vino_reqbufs(struct file *file, void *__fh,
3354			     struct v4l2_requestbuffers *rb)
3355{
3356	struct vino_channel_settings *vcs = video_drvdata(file);
3357
3358	if (vcs->reading)
3359		return -EBUSY;
3360
3361	/* TODO: check queue type */
3362	if (rb->memory != V4L2_MEMORY_MMAP) {
3363		dprintk("type not mmap\n");
3364		return -EINVAL;
3365	}
3366
3367	dprintk("count = %d\n", rb->count);
3368	if (rb->count > 0) {
3369		if (vino_is_capturing(vcs)) {
3370			dprintk("busy, capturing\n");
3371			return -EBUSY;
3372		}
3373
3374		if (vino_queue_has_mapped_buffers(&vcs->fb_queue)) {
3375			dprintk("busy, buffers still mapped\n");
3376			return -EBUSY;
3377		} else {
3378			vcs->streaming = 0;
3379			vino_queue_free(&vcs->fb_queue);
3380			vino_queue_init(&vcs->fb_queue, &rb->count);
3381		}
3382	} else {
3383		vcs->streaming = 0;
3384		vino_capture_stop(vcs);
3385		vino_queue_free(&vcs->fb_queue);
3386	}
3387
3388	return 0;
3389}
3390
3391static void vino_v4l2_get_buffer_status(struct vino_channel_settings *vcs,
3392					struct vino_framebuffer *fb,
3393					struct v4l2_buffer *b)
3394{
3395	if (vino_queue_outgoing_contains(&vcs->fb_queue,
3396					 fb->id)) {
3397		b->flags &= ~V4L2_BUF_FLAG_QUEUED;
3398		b->flags |= V4L2_BUF_FLAG_DONE;
3399	} else if (vino_queue_incoming_contains(&vcs->fb_queue,
3400				       fb->id)) {
3401		b->flags &= ~V4L2_BUF_FLAG_DONE;
3402		b->flags |= V4L2_BUF_FLAG_QUEUED;
3403	} else {
3404		b->flags &= ~(V4L2_BUF_FLAG_DONE |
3405			      V4L2_BUF_FLAG_QUEUED);
3406	}
3407
3408	b->flags &= ~(V4L2_BUF_FLAG_TIMECODE);
3409
3410	if (fb->map_count > 0)
3411		b->flags |= V4L2_BUF_FLAG_MAPPED;
3412
3413	b->index = fb->id;
3414	b->memory = (vcs->fb_queue.type == VINO_MEMORY_MMAP) ?
3415		V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
3416	b->m.offset = fb->offset;
3417	b->bytesused = fb->data_size;
3418	b->length = fb->size;
3419	b->field = V4L2_FIELD_INTERLACED;
3420	b->sequence = fb->frame_counter;
3421	memcpy(&b->timestamp, &fb->timestamp,
3422	       sizeof(struct timeval));
3423	// b->input ?
3424
3425	dprintk("buffer %d: length = %d, bytesused = %d, offset = %d\n",
3426		fb->id, fb->size, fb->data_size, fb->offset);
3427}
3428
3429static int vino_querybuf(struct file *file, void *__fh,
3430			      struct v4l2_buffer *b)
3431{
3432	struct vino_channel_settings *vcs = video_drvdata(file);
3433	struct vino_framebuffer *fb;
3434
3435	if (vcs->reading)
3436		return -EBUSY;
3437
3438	/* TODO: check queue type */
3439	if (b->index >= vino_queue_get_length(&vcs->fb_queue)) {
3440		dprintk("invalid index = %d\n",
3441		       b->index);
3442		return -EINVAL;
3443	}
3444
3445	fb = vino_queue_get_buffer(&vcs->fb_queue,
3446				   b->index);
3447	if (fb == NULL) {
3448		dprintk("vino_queue_get_buffer() failed");
3449		return -EINVAL;
3450	}
3451
3452	vino_v4l2_get_buffer_status(vcs, fb, b);
3453
3454	return 0;
3455}
3456
3457static int vino_qbuf(struct file *file, void *__fh,
3458			  struct v4l2_buffer *b)
3459{
3460	struct vino_channel_settings *vcs = video_drvdata(file);
3461	struct vino_framebuffer *fb;
3462	int ret;
3463
3464	if (vcs->reading)
3465		return -EBUSY;
3466
3467	/* TODO: check queue type */
3468	if (b->memory != V4L2_MEMORY_MMAP) {
3469		dprintk("type not mmap\n");
3470		return -EINVAL;
3471	}
3472
3473	fb = vino_capture_enqueue(vcs, b->index);
3474	if (fb == NULL)
3475		return -EINVAL;
3476
3477	vino_v4l2_get_buffer_status(vcs, fb, b);
3478
3479	if (vcs->streaming) {
3480		ret = vino_capture_next(vcs, 1);
3481		if (ret)
3482			return ret;
3483	}
3484
3485	return 0;
3486}
3487
3488static int vino_dqbuf(struct file *file, void *__fh,
3489			   struct v4l2_buffer *b)
3490{
3491	struct vino_channel_settings *vcs = video_drvdata(file);
3492	unsigned int nonblocking = file->f_flags & O_NONBLOCK;
3493	struct vino_framebuffer *fb;
3494	unsigned int incoming, outgoing;
3495	int err;
3496
3497	if (vcs->reading)
3498		return -EBUSY;
3499
3500	/* TODO: check queue type */
3501
3502	err = vino_queue_get_incoming(&vcs->fb_queue, &incoming);
3503	if (err) {
3504		dprintk("vino_queue_get_incoming() failed\n");
3505		return -EINVAL;
3506	}
3507	err = vino_queue_get_outgoing(&vcs->fb_queue, &outgoing);
3508	if (err) {
3509		dprintk("vino_queue_get_outgoing() failed\n");
3510		return -EINVAL;
3511	}
3512
3513	dprintk("incoming = %d, outgoing = %d\n", incoming, outgoing);
3514
3515	if (outgoing == 0) {
3516		if (incoming == 0) {
3517			dprintk("no incoming or outgoing buffers\n");
3518			return -EINVAL;
3519		}
3520		if (nonblocking) {
3521			dprintk("non-blocking I/O was selected and "
3522				"there are no buffers to dequeue\n");
3523			return -EAGAIN;
3524		}
3525
3526		err = vino_wait_for_frame(vcs);
3527		if (err) {
3528			err = vino_wait_for_frame(vcs);
3529			if (err) {
3530				/* interrupted or no frames captured because of
3531				 * frame skipping */
3532				/* vino_capture_failed(vcs); */
3533				return -EIO;
3534			}
3535		}
3536	}
3537
3538	fb = vino_queue_remove(&vcs->fb_queue, &b->index);
3539	if (fb == NULL) {
3540		dprintk("vino_queue_remove() failed\n");
3541		return -EINVAL;
3542	}
3543
3544	err = vino_check_buffer(vcs, fb);
3545
3546	vino_v4l2_get_buffer_status(vcs, fb, b);
3547
3548	if (err)
3549		return -EIO;
3550
3551	return 0;
3552}
3553
3554static int vino_streamon(struct file *file, void *__fh,
3555		enum v4l2_buf_type i)
3556{
3557	struct vino_channel_settings *vcs = video_drvdata(file);
3558	unsigned int incoming;
3559	int ret;
3560	if (vcs->reading)
3561		return -EBUSY;
3562
3563	if (vcs->streaming)
3564		return 0;
3565
3566	// TODO: check queue type
3567
3568	if (vino_queue_get_length(&vcs->fb_queue) < 1) {
3569		dprintk("no buffers allocated\n");
3570		return -EINVAL;
3571	}
3572
3573	ret = vino_queue_get_incoming(&vcs->fb_queue, &incoming);
3574	if (ret) {
3575		dprintk("vino_queue_get_incoming() failed\n");
3576		return -EINVAL;
3577	}
3578
3579	vcs->streaming = 1;
3580
3581	if (incoming > 0) {
3582		ret = vino_capture_next(vcs, 1);
3583		if (ret) {
3584			vcs->streaming = 0;
3585
3586			dprintk("couldn't start capture\n");
3587			return -EINVAL;
3588		}
3589	}
3590
3591	return 0;
3592}
3593
3594static int vino_streamoff(struct file *file, void *__fh,
3595		enum v4l2_buf_type i)
3596{
3597	struct vino_channel_settings *vcs = video_drvdata(file);
3598	if (vcs->reading)
3599		return -EBUSY;
3600
3601	if (!vcs->streaming)
3602		return 0;
3603
3604	vcs->streaming = 0;
3605	vino_capture_stop(vcs);
3606
3607	return 0;
3608}
3609
3610static int vino_queryctrl(struct file *file, void *__fh,
3611			       struct v4l2_queryctrl *queryctrl)
3612{
3613	struct vino_channel_settings *vcs = video_drvdata(file);
3614	unsigned long flags;
3615	int i;
3616	int err = 0;
3617
3618	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3619
3620	switch (vcs->input) {
3621	case VINO_INPUT_D1:
3622		for (i = 0; i < VINO_INDYCAM_V4L2_CONTROL_COUNT; i++) {
3623			if (vino_indycam_v4l2_controls[i].id ==
3624			    queryctrl->id) {
3625				memcpy(queryctrl,
3626				       &vino_indycam_v4l2_controls[i],
3627				       sizeof(struct v4l2_queryctrl));
3628				queryctrl->reserved[0] = 0;
3629				goto found;
3630			}
3631		}
3632
3633		err =  -EINVAL;
3634		break;
3635	case VINO_INPUT_COMPOSITE:
3636	case VINO_INPUT_SVIDEO:
3637		for (i = 0; i < VINO_SAA7191_V4L2_CONTROL_COUNT; i++) {
3638			if (vino_saa7191_v4l2_controls[i].id ==
3639			    queryctrl->id) {
3640				memcpy(queryctrl,
3641				       &vino_saa7191_v4l2_controls[i],
3642				       sizeof(struct v4l2_queryctrl));
3643				queryctrl->reserved[0] = 0;
3644				goto found;
3645			}
3646		}
3647
3648		err =  -EINVAL;
3649		break;
3650	default:
3651		err =  -EINVAL;
3652	}
3653
3654 found:
3655	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3656
3657	return err;
3658}
3659
3660static int vino_g_ctrl(struct file *file, void *__fh,
3661			    struct v4l2_control *control)
3662{
3663	struct vino_channel_settings *vcs = video_drvdata(file);
3664	unsigned long flags;
3665	int i;
3666	int err = 0;
3667
3668	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3669
3670	switch (vcs->input) {
3671	case VINO_INPUT_D1: {
3672		err = -EINVAL;
3673		for (i = 0; i < VINO_INDYCAM_V4L2_CONTROL_COUNT; i++) {
3674			if (vino_indycam_v4l2_controls[i].id == control->id) {
3675				err = 0;
3676				break;
3677			}
3678		}
3679
3680		if (err)
3681			goto out;
3682
3683		err = camera_call(core, g_ctrl, control);
3684		if (err)
3685			err = -EINVAL;
3686		break;
3687	}
3688	case VINO_INPUT_COMPOSITE:
3689	case VINO_INPUT_SVIDEO: {
3690		err = -EINVAL;
3691		for (i = 0; i < VINO_SAA7191_V4L2_CONTROL_COUNT; i++) {
3692			if (vino_saa7191_v4l2_controls[i].id == control->id) {
3693				err = 0;
3694				break;
3695			}
3696		}
3697
3698		if (err)
3699			goto out;
3700
3701		err = decoder_call(core, g_ctrl, control);
3702		if (err)
3703			err = -EINVAL;
3704		break;
3705	}
3706	default:
3707		err =  -EINVAL;
3708	}
3709
3710out:
3711	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3712
3713	return err;
3714}
3715
3716static int vino_s_ctrl(struct file *file, void *__fh,
3717			    struct v4l2_control *control)
3718{
3719	struct vino_channel_settings *vcs = video_drvdata(file);
3720	unsigned long flags;
3721	int i;
3722	int err = 0;
3723
3724	spin_lock_irqsave(&vino_drvdata->input_lock, flags);
3725
3726	if (!vino_is_input_owner(vcs)) {
3727		err = -EBUSY;
3728		goto out;
3729	}
3730
3731	switch (vcs->input) {
3732	case VINO_INPUT_D1: {
3733		err = -EINVAL;
3734		for (i = 0; i < VINO_INDYCAM_V4L2_CONTROL_COUNT; i++) {
3735			if (vino_indycam_v4l2_controls[i].id == control->id) {
3736				err = 0;
3737				break;
3738			}
3739		}
3740		if (err)
3741			goto out;
3742		if (control->value < vino_indycam_v4l2_controls[i].minimum ||
3743		    control->value > vino_indycam_v4l2_controls[i].maximum) {
3744			err = -ERANGE;
3745			goto out;
3746		}
3747		err = camera_call(core, s_ctrl, control);
3748		if (err)
3749			err = -EINVAL;
3750		break;
3751	}
3752	case VINO_INPUT_COMPOSITE:
3753	case VINO_INPUT_SVIDEO: {
3754		err = -EINVAL;
3755		for (i = 0; i < VINO_SAA7191_V4L2_CONTROL_COUNT; i++) {
3756			if (vino_saa7191_v4l2_controls[i].id == control->id) {
3757				err = 0;
3758				break;
3759			}
3760		}
3761		if (err)
3762			goto out;
3763		if (control->value < vino_saa7191_v4l2_controls[i].minimum ||
3764		    control->value > vino_saa7191_v4l2_controls[i].maximum) {
3765			err = -ERANGE;
3766			goto out;
3767		}
3768
3769		err = decoder_call(core, s_ctrl, control);
3770		if (err)
3771			err = -EINVAL;
3772		break;
3773	}
3774	default:
3775		err =  -EINVAL;
3776	}
3777
3778out:
3779	spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
3780
3781	return err;
3782}
3783
3784/* File operations */
3785
3786static int vino_open(struct file *file)
3787{
3788	struct vino_channel_settings *vcs = video_drvdata(file);
3789	int ret = 0;
3790	dprintk("open(): channel = %c\n",
3791	       (vcs->channel == VINO_CHANNEL_A) ? 'A' : 'B');
3792
3793	mutex_lock(&vcs->mutex);
3794
3795	if (vcs->users) {
3796		dprintk("open(): driver busy\n");
3797		ret = -EBUSY;
3798		goto out;
3799	}
3800
3801	ret = vino_acquire_input(vcs);
3802	if (ret) {
3803		dprintk("open(): vino_acquire_input() failed\n");
3804		goto out;
3805	}
3806
3807	vcs->users++;
3808
3809 out:
3810	mutex_unlock(&vcs->mutex);
3811
3812	dprintk("open(): %s!\n", ret ? "failed" : "complete");
3813
3814	return ret;
3815}
3816
3817static int vino_close(struct file *file)
3818{
3819	struct vino_channel_settings *vcs = video_drvdata(file);
3820	dprintk("close():\n");
3821
3822	mutex_lock(&vcs->mutex);
3823
3824	vcs->users--;
3825
3826	if (!vcs->users) {
3827		vino_release_input(vcs);
3828
3829		/* stop DMA and free buffers */
3830		vino_capture_stop(vcs);
3831		vino_queue_free(&vcs->fb_queue);
3832	}
3833
3834	mutex_unlock(&vcs->mutex);
3835
3836	return 0;
3837}
3838
3839static void vino_vm_open(struct vm_area_struct *vma)
3840{
3841	struct vino_framebuffer *fb = vma->vm_private_data;
3842
3843	fb->map_count++;
3844	dprintk("vino_vm_open(): count = %d\n", fb->map_count);
3845}
3846
3847static void vino_vm_close(struct vm_area_struct *vma)
3848{
3849	struct vino_framebuffer *fb = vma->vm_private_data;
3850
3851	fb->map_count--;
3852	dprintk("vino_vm_close(): count = %d\n", fb->map_count);
3853}
3854
3855static const struct vm_operations_struct vino_vm_ops = {
3856	.open	= vino_vm_open,
3857	.close	= vino_vm_close,
3858};
3859
3860static int vino_mmap(struct file *file, struct vm_area_struct *vma)
3861{
3862	struct vino_channel_settings *vcs = video_drvdata(file);
3863
3864	unsigned long start = vma->vm_start;
3865	unsigned long size = vma->vm_end - vma->vm_start;
3866	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
3867
3868	struct vino_framebuffer *fb = NULL;
3869	unsigned int i, length;
3870	int ret = 0;
3871
3872	dprintk("mmap():\n");
3873
3874	// TODO: reject mmap if already mapped
3875
3876	if (mutex_lock_interruptible(&vcs->mutex))
3877		return -EINTR;
3878
3879	if (vcs->reading) {
3880		ret = -EBUSY;
3881		goto out;
3882	}
3883
3884	// TODO: check queue type
3885
3886	if (!(vma->vm_flags & VM_WRITE)) {
3887		dprintk("mmap(): app bug: PROT_WRITE please\n");
3888		ret = -EINVAL;
3889		goto out;
3890	}
3891	if (!(vma->vm_flags & VM_SHARED)) {
3892		dprintk("mmap(): app bug: MAP_SHARED please\n");
3893		ret = -EINVAL;
3894		goto out;
3895	}
3896
3897	/* find the correct buffer using offset */
3898	length = vino_queue_get_length(&vcs->fb_queue);
3899	if (length == 0) {
3900		dprintk("mmap(): queue not initialized\n");
3901		ret = -EINVAL;
3902		goto out;
3903	}
3904
3905	for (i = 0; i < length; i++) {
3906		fb = vino_queue_get_buffer(&vcs->fb_queue, i);
3907		if (fb == NULL) {
3908			dprintk("mmap(): vino_queue_get_buffer() failed\n");
3909			ret = -EINVAL;
3910			goto out;
3911		}
3912
3913		if (fb->offset == offset)
3914			goto found;
3915	}
3916
3917	dprintk("mmap(): invalid offset = %lu\n", offset);
3918	ret = -EINVAL;
3919	goto out;
3920
3921found:
3922	dprintk("mmap(): buffer = %d\n", i);
3923
3924	if (size > (fb->desc_table.page_count * PAGE_SIZE)) {
3925		dprintk("mmap(): failed: size = %lu > %lu\n",
3926			size, fb->desc_table.page_count * PAGE_SIZE);
3927		ret = -EINVAL;
3928		goto out;
3929	}
3930
3931	for (i = 0; i < fb->desc_table.page_count; i++) {
3932		unsigned long pfn =
3933			virt_to_phys((void *)fb->desc_table.virtual[i]) >>
3934			PAGE_SHIFT;
3935
3936		if (size < PAGE_SIZE)
3937			break;
3938
3939		// protection was: PAGE_READONLY
3940		if (remap_pfn_range(vma, start, pfn, PAGE_SIZE,
3941				    vma->vm_page_prot)) {
3942			dprintk("mmap(): remap_pfn_range() failed\n");
3943			ret = -EAGAIN;
3944			goto out;
3945		}
3946
3947		start += PAGE_SIZE;
3948		size -= PAGE_SIZE;
3949	}
3950
3951	fb->map_count = 1;
3952
3953	vma->vm_flags |= VM_DONTEXPAND | VM_RESERVED;
3954	vma->vm_flags &= ~VM_IO;
3955	vma->vm_private_data = fb;
3956	vma->vm_file = file;
3957	vma->vm_ops = &vino_vm_ops;
3958
3959out:
3960	mutex_unlock(&vcs->mutex);
3961
3962	return ret;
3963}
3964
3965static unsigned int vino_poll(struct file *file, poll_table *pt)
3966{
3967	struct vino_channel_settings *vcs = video_drvdata(file);
3968	unsigned int outgoing;
3969	unsigned int ret = 0;
3970
3971	// lock mutex (?)
3972	// TODO: this has to be corrected for different read modes
3973
3974	dprintk("poll():\n");
3975
3976	if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
3977		dprintk("poll(): vino_queue_get_outgoing() failed\n");
3978		ret = POLLERR;
3979		goto error;
3980	}
3981	if (outgoing > 0)
3982		goto over;
3983
3984	poll_wait(file, &vcs->fb_queue.frame_wait_queue, pt);
3985
3986	if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
3987		dprintk("poll(): vino_queue_get_outgoing() failed\n");
3988		ret = POLLERR;
3989		goto error;
3990	}
3991
3992over:
3993	dprintk("poll(): data %savailable\n",
3994		(outgoing > 0) ? "" : "not ");
3995
3996	if (outgoing > 0)
3997		ret = POLLIN | POLLRDNORM;
3998
3999error:
4000	return ret;
4001}
4002
4003static long vino_ioctl(struct file *file,
4004		      unsigned int cmd, unsigned long arg)
4005{
4006	struct vino_channel_settings *vcs = video_drvdata(file);
4007	long ret;
4008
4009	if (mutex_lock_interruptible(&vcs->mutex))
4010		return -EINTR;
4011
4012	ret = video_ioctl2(file, cmd, arg);
4013
4014	mutex_unlock(&vcs->mutex);
4015
4016	return ret;
4017}
4018
4019/* Initialization and cleanup */
4020
4021/* __initdata */
4022static int vino_init_stage;
4023
4024const struct v4l2_ioctl_ops vino_ioctl_ops = {
4025	.vidioc_enum_fmt_vid_cap     = vino_enum_fmt_vid_cap,
4026	.vidioc_g_fmt_vid_cap 	     = vino_g_fmt_vid_cap,
4027	.vidioc_s_fmt_vid_cap  	     = vino_s_fmt_vid_cap,
4028	.vidioc_try_fmt_vid_cap	     = vino_try_fmt_vid_cap,
4029	.vidioc_querycap    	     = vino_querycap,
4030	.vidioc_enum_input   	     = vino_enum_input,
4031	.vidioc_g_input      	     = vino_g_input,
4032	.vidioc_s_input      	     = vino_s_input,
4033	.vidioc_g_std 		     = vino_g_std,
4034	.vidioc_s_std 		     = vino_s_std,
4035	.vidioc_querystd             = vino_querystd,
4036	.vidioc_cropcap      	     = vino_cropcap,
4037	.vidioc_s_crop       	     = vino_s_crop,
4038	.vidioc_g_crop       	     = vino_g_crop,
4039	.vidioc_s_parm 		     = vino_s_parm,
4040	.vidioc_g_parm 		     = vino_g_parm,
4041	.vidioc_reqbufs              = vino_reqbufs,
4042	.vidioc_querybuf             = vino_querybuf,
4043	.vidioc_qbuf                 = vino_qbuf,
4044	.vidioc_dqbuf                = vino_dqbuf,
4045	.vidioc_streamon             = vino_streamon,
4046	.vidioc_streamoff            = vino_streamoff,
4047	.vidioc_queryctrl            = vino_queryctrl,
4048	.vidioc_g_ctrl               = vino_g_ctrl,
4049	.vidioc_s_ctrl               = vino_s_ctrl,
4050};
4051
4052static const struct v4l2_file_operations vino_fops = {
4053	.owner		= THIS_MODULE,
4054	.open		= vino_open,
4055	.release	= vino_close,
4056	.unlocked_ioctl	= vino_ioctl,
4057	.mmap		= vino_mmap,
4058	.poll		= vino_poll,
4059};
4060
4061static struct video_device vdev_template = {
4062	.name		= "NOT SET",
4063	.fops		= &vino_fops,
4064	.ioctl_ops 	= &vino_ioctl_ops,
4065	.tvnorms 	= V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
4066};
4067
4068static void vino_module_cleanup(int stage)
4069{
4070	switch(stage) {
4071	case 11:
4072		video_unregister_device(vino_drvdata->b.vdev);
4073		vino_drvdata->b.vdev = NULL;
4074	case 10:
4075		video_unregister_device(vino_drvdata->a.vdev);
4076		vino_drvdata->a.vdev = NULL;
4077	case 9:
4078		i2c_del_adapter(&vino_i2c_adapter);
4079	case 8:
4080		free_irq(SGI_VINO_IRQ, NULL);
4081	case 7:
4082		if (vino_drvdata->b.vdev) {
4083			video_device_release(vino_drvdata->b.vdev);
4084			vino_drvdata->b.vdev = NULL;
4085		}
4086	case 6:
4087		if (vino_drvdata->a.vdev) {
4088			video_device_release(vino_drvdata->a.vdev);
4089			vino_drvdata->a.vdev = NULL;
4090		}
4091	case 5:
4092		/* all entries in dma_cpu dummy table have the same address */
4093		dma_unmap_single(NULL,
4094				 vino_drvdata->dummy_desc_table.dma_cpu[0],
4095				 PAGE_SIZE, DMA_FROM_DEVICE);
4096		dma_free_coherent(NULL, VINO_DUMMY_DESC_COUNT
4097				  * sizeof(dma_addr_t),
4098				  (void *)vino_drvdata->
4099				  dummy_desc_table.dma_cpu,
4100				  vino_drvdata->dummy_desc_table.dma);
4101	case 4:
4102		free_page(vino_drvdata->dummy_page);
4103	case 3:
4104		v4l2_device_unregister(&vino_drvdata->v4l2_dev);
4105	case 2:
4106		kfree(vino_drvdata);
4107	case 1:
4108		iounmap(vino);
4109	case 0:
4110		break;
4111	default:
4112		dprintk("vino_module_cleanup(): invalid cleanup stage = %d\n",
4113			stage);
4114	}
4115}
4116
4117static int vino_probe(void)
4118{
4119	unsigned long rev_id;
4120
4121	if (ip22_is_fullhouse()) {
4122		printk(KERN_ERR "VINO doesn't exist in IP22 Fullhouse\n");
4123		return -ENODEV;
4124	}
4125
4126	if (!(sgimc->systemid & SGIMC_SYSID_EPRESENT)) {
4127		printk(KERN_ERR "VINO is not found (EISA BUS not present)\n");
4128		return -ENODEV;
4129	}
4130
4131	vino = (struct sgi_vino *)ioremap(VINO_BASE, sizeof(struct sgi_vino));
4132	if (!vino) {
4133		printk(KERN_ERR "VINO: ioremap() failed\n");
4134		return -EIO;
4135	}
4136	vino_init_stage++;
4137
4138	if (get_dbe(rev_id, &(vino->rev_id))) {
4139		printk(KERN_ERR "Failed to read VINO revision register\n");
4140		vino_module_cleanup(vino_init_stage);
4141		return -ENODEV;
4142	}
4143
4144	if (VINO_ID_VALUE(rev_id) != VINO_CHIP_ID) {
4145		printk(KERN_ERR "Unknown VINO chip ID (Rev/ID: 0x%02lx)\n",
4146		       rev_id);
4147		vino_module_cleanup(vino_init_stage);
4148		return -ENODEV;
4149	}
4150
4151	printk(KERN_INFO "VINO revision %ld found\n", VINO_REV_NUM(rev_id));
4152
4153	return 0;
4154}
4155
4156static int vino_init(void)
4157{
4158	dma_addr_t dma_dummy_address;
4159	int err;
4160	int i;
4161
4162	vino_drvdata = kzalloc(sizeof(struct vino_settings), GFP_KERNEL);
4163	if (!vino_drvdata) {
4164		vino_module_cleanup(vino_init_stage);
4165		return -ENOMEM;
4166	}
4167	vino_init_stage++;
4168	strlcpy(vino_drvdata->v4l2_dev.name, "vino",
4169			sizeof(vino_drvdata->v4l2_dev.name));
4170	err = v4l2_device_register(NULL, &vino_drvdata->v4l2_dev);
4171	if (err)
4172		return err;
4173	vino_init_stage++;
4174
4175	/* create a dummy dma descriptor */
4176	vino_drvdata->dummy_page = get_zeroed_page(GFP_KERNEL | GFP_DMA);
4177	if (!vino_drvdata->dummy_page) {
4178		vino_module_cleanup(vino_init_stage);
4179		return -ENOMEM;
4180	}
4181	vino_init_stage++;
4182
4183	// TODO: use page_count in dummy_desc_table
4184
4185	vino_drvdata->dummy_desc_table.dma_cpu =
4186		dma_alloc_coherent(NULL,
4187		VINO_DUMMY_DESC_COUNT * sizeof(dma_addr_t),
4188		&vino_drvdata->dummy_desc_table.dma,
4189		GFP_KERNEL | GFP_DMA);
4190	if (!vino_drvdata->dummy_desc_table.dma_cpu) {
4191		vino_module_cleanup(vino_init_stage);
4192		return -ENOMEM;
4193	}
4194	vino_init_stage++;
4195
4196	dma_dummy_address = dma_map_single(NULL,
4197					   (void *)vino_drvdata->dummy_page,
4198					PAGE_SIZE, DMA_FROM_DEVICE);
4199	for (i = 0; i < VINO_DUMMY_DESC_COUNT; i++) {
4200		vino_drvdata->dummy_desc_table.dma_cpu[i] = dma_dummy_address;
4201	}
4202
4203	/* initialize VINO */
4204
4205	vino->control = 0;
4206	vino->a.next_4_desc = vino_drvdata->dummy_desc_table.dma;
4207	vino->b.next_4_desc = vino_drvdata->dummy_desc_table.dma;
4208	udelay(VINO_DESC_FETCH_DELAY);
4209
4210	vino->intr_status = 0;
4211
4212	vino->a.fifo_thres = VINO_FIFO_THRESHOLD_DEFAULT;
4213	vino->b.fifo_thres = VINO_FIFO_THRESHOLD_DEFAULT;
4214
4215	return 0;
4216}
4217
4218static int vino_init_channel_settings(struct vino_channel_settings *vcs,
4219				 unsigned int channel, const char *name)
4220{
4221	vcs->channel = channel;
4222	vcs->input = VINO_INPUT_NONE;
4223	vcs->alpha = 0;
4224	vcs->users = 0;
4225	vcs->data_format = VINO_DATA_FMT_GREY;
4226	vcs->data_norm = VINO_DATA_NORM_NTSC;
4227	vcs->decimation = 1;
4228	vino_set_default_clipping(vcs);
4229	vino_set_default_framerate(vcs);
4230
4231	vcs->capturing = 0;
4232
4233	mutex_init(&vcs->mutex);
4234	spin_lock_init(&vcs->capture_lock);
4235
4236	mutex_init(&vcs->fb_queue.queue_mutex);
4237	spin_lock_init(&vcs->fb_queue.queue_lock);
4238	init_waitqueue_head(&vcs->fb_queue.frame_wait_queue);
4239
4240	vcs->vdev = video_device_alloc();
4241	if (!vcs->vdev) {
4242		vino_module_cleanup(vino_init_stage);
4243		return -ENOMEM;
4244	}
4245	vino_init_stage++;
4246
4247	memcpy(vcs->vdev, &vdev_template,
4248	       sizeof(struct video_device));
4249	strcpy(vcs->vdev->name, name);
4250	vcs->vdev->release = video_device_release;
4251	vcs->vdev->v4l2_dev = &vino_drvdata->v4l2_dev;
4252
4253	video_set_drvdata(vcs->vdev, vcs);
4254
4255	return 0;
4256}
4257
4258static int __init vino_module_init(void)
4259{
4260	int ret;
4261
4262	printk(KERN_INFO "SGI VINO driver version %s\n",
4263	       VINO_MODULE_VERSION);
4264
4265	ret = vino_probe();
4266	if (ret)
4267		return ret;
4268
4269	ret = vino_init();
4270	if (ret)
4271		return ret;
4272
4273	/* initialize data structures */
4274
4275	spin_lock_init(&vino_drvdata->vino_lock);
4276	spin_lock_init(&vino_drvdata->input_lock);
4277
4278	ret = vino_init_channel_settings(&vino_drvdata->a, VINO_CHANNEL_A,
4279				    vino_vdev_name_a);
4280	if (ret)
4281		return ret;
4282
4283	ret = vino_init_channel_settings(&vino_drvdata->b, VINO_CHANNEL_B,
4284				    vino_vdev_name_b);
4285	if (ret)
4286		return ret;
4287
4288	/* initialize hardware and register V4L devices */
4289
4290	ret = request_irq(SGI_VINO_IRQ, vino_interrupt, 0,
4291		vino_driver_description, NULL);
4292	if (ret) {
4293		printk(KERN_ERR "VINO: requesting IRQ %02d failed\n",
4294		       SGI_VINO_IRQ);
4295		vino_module_cleanup(vino_init_stage);
4296		return -EAGAIN;
4297	}
4298	vino_init_stage++;
4299
4300	ret = i2c_add_adapter(&vino_i2c_adapter);
4301	if (ret) {
4302		printk(KERN_ERR "VINO I2C bus registration failed\n");
4303		vino_module_cleanup(vino_init_stage);
4304		return ret;
4305	}
4306	i2c_set_adapdata(&vino_i2c_adapter, &vino_drvdata->v4l2_dev);
4307	vino_init_stage++;
4308
4309	ret = video_register_device(vino_drvdata->a.vdev,
4310				    VFL_TYPE_GRABBER, -1);
4311	if (ret < 0) {
4312		printk(KERN_ERR "VINO channel A Video4Linux-device "
4313		       "registration failed\n");
4314		vino_module_cleanup(vino_init_stage);
4315		return -EINVAL;
4316	}
4317	vino_init_stage++;
4318
4319	ret = video_register_device(vino_drvdata->b.vdev,
4320				    VFL_TYPE_GRABBER, -1);
4321	if (ret < 0) {
4322		printk(KERN_ERR "VINO channel B Video4Linux-device "
4323		       "registration failed\n");
4324		vino_module_cleanup(vino_init_stage);
4325		return -EINVAL;
4326	}
4327	vino_init_stage++;
4328
4329	vino_drvdata->decoder =
4330		v4l2_i2c_new_subdev(&vino_drvdata->v4l2_dev, &vino_i2c_adapter,
4331			       "saa7191", 0, I2C_ADDRS(0x45));
4332	vino_drvdata->camera =
4333		v4l2_i2c_new_subdev(&vino_drvdata->v4l2_dev, &vino_i2c_adapter,
4334			       "indycam", 0, I2C_ADDRS(0x2b));
4335
4336	dprintk("init complete!\n");
4337
4338	return 0;
4339}
4340
4341static void __exit vino_module_exit(void)
4342{
4343	dprintk("exiting, stage = %d ...\n", vino_init_stage);
4344	vino_module_cleanup(vino_init_stage);
4345	dprintk("cleanup complete, exit!\n");
4346}
4347
4348module_init(vino_module_init);
4349module_exit(vino_module_exit);