SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/vino.c

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