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