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