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