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