?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging:iio:dac:ad5791: Allow asymmetrical reference voltages
[zen-stable.git] / drivers / staging / easycap / easycap_ioctl.c
blobc99addfb62428888bd089de3a96b43b6e20a8500
1 /******************************************************************************
2 * *
3 * easycap_ioctl.c *
4 * *
5 ******************************************************************************/
6 /*
7 *
8 * Copyright (C) 2010 R.M. Thomas <rmthomas@sciolus.org>
9 *
10 *
11 * This is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * The software is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this software; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 */
26 /*****************************************************************************/
27
28 #include <linux/version.h>
29 #include "easycap.h"
30
31 /*--------------------------------------------------------------------------*/
32 /*
33 * UNLESS THERE IS A PREMATURE ERROR RETURN THIS ROUTINE UPDATES THE
34 * FOLLOWING:
35 * peasycap->standard_offset
36 * peasycap->inputset[peasycap->input].standard_offset
37 * peasycap->fps
38 * peasycap->usec
39 * peasycap->tolerate
40 * peasycap->skip
41 */
42 /*---------------------------------------------------------------------------*/
43 int adjust_standard(struct easycap *peasycap, v4l2_std_id std_id)
44 {
45 struct easycap_standard const *peasycap_standard;
46 u16 reg, set;
47 int ir, rc, need, k;
48 unsigned int itwas, isnow;
49 bool resubmit;
50
51 if (!peasycap) {
52 SAY("ERROR: peasycap is NULL\n");
53 return -EFAULT;
54 }
55 if (!peasycap->pusb_device) {
56 SAM("ERROR: peasycap->pusb_device is NULL\n");
57 return -EFAULT;
58 }
59 peasycap_standard = &easycap_standard[0];
60 while (0xFFFF != peasycap_standard->mask) {
61 if (std_id == peasycap_standard->v4l2_standard.id)
62 break;
63 peasycap_standard++;
64 }
65 if (0xFFFF == peasycap_standard->mask) {
66 peasycap_standard = &easycap_standard[0];
67 while (0xFFFF != peasycap_standard->mask) {
68 if (std_id & peasycap_standard->v4l2_standard.id)
69 break;
70 peasycap_standard++;
71 }
72 }
73 if (0xFFFF == peasycap_standard->mask) {
74 SAM("ERROR: 0x%08X=std_id: standard not found\n",
75 (unsigned int)std_id);
76 return -EINVAL;
77 }
78 SAM("selected standard: %s\n",
79 &(peasycap_standard->v4l2_standard.name[0]));
80 if (peasycap->standard_offset == peasycap_standard - easycap_standard) {
81 SAM("requested standard already in effect\n");
82 return 0;
83 }
84 peasycap->standard_offset = peasycap_standard - easycap_standard;
85 for (k = 0; k < INPUT_MANY; k++) {
86 if (!peasycap->inputset[k].standard_offset_ok) {
87 peasycap->inputset[k].standard_offset =
88 peasycap->standard_offset;
89 }
90 }
91 if ((0 <= peasycap->input) && (INPUT_MANY > peasycap->input)) {
92 peasycap->inputset[peasycap->input].standard_offset =
93 peasycap->standard_offset;
94 peasycap->inputset[peasycap->input].standard_offset_ok = 1;
95 } else
96 JOM(8, "%i=peasycap->input\n", peasycap->input);
97
98 peasycap->fps = peasycap_standard->v4l2_standard.frameperiod.denominator /
99 peasycap_standard->v4l2_standard.frameperiod.numerator;
100 switch (peasycap->fps) {
101 case 6:
102 case 30: {
103 peasycap->ntsc = true;
104 break;
105 }
106 case 5:
107 case 25: {
108 peasycap->ntsc = false;
109 break;
110 }
111 default: {
112 SAM("MISTAKE: %i=frames-per-second\n", peasycap->fps);
113 return -ENOENT;
114 }
115 }
116 JOM(8, "%i frames-per-second\n", peasycap->fps);
117 if (0x8000 & peasycap_standard->mask) {
118 peasycap->skip = 5;
119 peasycap->usec = 1000000 / (2 * (5 * peasycap->fps));
120 peasycap->tolerate = 1000 * (25 / (5 * peasycap->fps));
121 } else {
122 peasycap->skip = 0;
123 peasycap->usec = 1000000 / (2 * peasycap->fps);
124 peasycap->tolerate = 1000 * (25 / peasycap->fps);
125 }
126 if (peasycap->video_isoc_streaming) {
127 resubmit = true;
128 kill_video_urbs(peasycap);
129 } else
130 resubmit = false;
131 /*--------------------------------------------------------------------------*/
132 /*
133 * SAA7113H DATASHEET PAGE 44, TABLE 42
134 */
135 /*--------------------------------------------------------------------------*/
136 need = 0;
137 itwas = 0;
138 reg = 0x00;
139 set = 0x00;
140 switch (peasycap_standard->mask & 0x000F) {
141 case NTSC_M_JP: {
142 reg = 0x0A;
143 set = 0x95;
144 ir = read_saa(peasycap->pusb_device, reg);
145 if (0 > ir)
146 SAM("ERROR: cannot read SAA register 0x%02X\n", reg);
147 else
148 itwas = (unsigned int)ir;
149 rc = write_saa(peasycap->pusb_device, reg, set);
150 if (rc)
151 SAM("ERROR: failed to set SAA register "
152 "0x%02X to 0x%02X for JP standard\n", reg, set);
153 else {
154 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
155 if (0 > ir)
156 JOM(8, "SAA register 0x%02X changed "
157 "to 0x%02X\n", reg, isnow);
158 else
159 JOM(8, "SAA register 0x%02X changed "
160 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
161 }
162
163 reg = 0x0B;
164 set = 0x48;
165 ir = read_saa(peasycap->pusb_device, reg);
166 if (0 > ir)
167 SAM("ERROR: cannot read SAA register 0x%02X\n", reg);
168 else
169 itwas = (unsigned int)ir;
170 rc = write_saa(peasycap->pusb_device, reg, set);
171 if (rc)
172 SAM("ERROR: failed to set SAA register 0x%02X to 0x%02X "
173 "for JP standard\n", reg, set);
174 else {
175 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
176 if (0 > ir)
177 JOM(8, "SAA register 0x%02X changed "
178 "to 0x%02X\n", reg, isnow);
179 else
180 JOM(8, "SAA register 0x%02X changed "
181 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
182 }
183 /*--------------------------------------------------------------------------*/
184 /*
185 * NOTE: NO break HERE: RUN ON TO NEXT CASE
186 */
187 /*--------------------------------------------------------------------------*/
188 }
189 case NTSC_M:
190 case PAL_BGHIN: {
191 reg = 0x0E;
192 set = 0x01;
193 need = 1;
194 break;
195 }
196 case NTSC_N_443:
197 case PAL_60: {
198 reg = 0x0E;
199 set = 0x11;
200 need = 1;
201 break;
202 }
203 case NTSC_443:
204 case PAL_Nc: {
205 reg = 0x0E;
206 set = 0x21;
207 need = 1;
208 break;
209 }
210 case NTSC_N:
211 case PAL_M: {
212 reg = 0x0E;
213 set = 0x31;
214 need = 1;
215 break;
216 }
217 case SECAM: {
218 reg = 0x0E;
219 set = 0x51;
220 need = 1;
221 break;
222 }
223 default:
224 break;
225 }
226 /*--------------------------------------------------------------------------*/
227 if (need) {
228 ir = read_saa(peasycap->pusb_device, reg);
229 if (0 > ir)
230 SAM("ERROR: failed to read SAA register 0x%02X\n", reg);
231 else
232 itwas = (unsigned int)ir;
233 rc = write_saa(peasycap->pusb_device, reg, set);
234 if (0 != write_saa(peasycap->pusb_device, reg, set)) {
235 SAM("ERROR: failed to set SAA register "
236 "0x%02X to 0x%02X for table 42\n", reg, set);
237 } else {
238 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
239 if (0 > ir)
240 JOM(8, "SAA register 0x%02X changed "
241 "to 0x%02X\n", reg, isnow);
242 else
243 JOM(8, "SAA register 0x%02X changed "
244 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
245 }
246 }
247 /*--------------------------------------------------------------------------*/
248 /*
249 * SAA7113H DATASHEET PAGE 41
250 */
251 /*--------------------------------------------------------------------------*/
252 reg = 0x08;
253 ir = read_saa(peasycap->pusb_device, reg);
254 if (0 > ir)
255 SAM("ERROR: failed to read SAA register 0x%02X "
256 "so cannot reset\n", reg);
257 else {
258 itwas = (unsigned int)ir;
259 if (peasycap_standard->mask & 0x0001)
260 set = itwas | 0x40 ;
261 else
262 set = itwas & ~0x40 ;
263 rc = write_saa(peasycap->pusb_device, reg, set);
264 if (rc)
265 SAM("ERROR: failed to set SAA register 0x%02X to 0x%02X\n",
266 reg, set);
267 else {
268 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
269 if (0 > ir)
270 JOM(8, "SAA register 0x%02X changed to 0x%02X\n",
271 reg, isnow);
272 else
273 JOM(8, "SAA register 0x%02X changed "
274 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
275 }
276 }
277 /*--------------------------------------------------------------------------*/
278 /*
279 * SAA7113H DATASHEET PAGE 51, TABLE 57
280 */
281 /*---------------------------------------------------------------------------*/
282 reg = 0x40;
283 ir = read_saa(peasycap->pusb_device, reg);
284 if (0 > ir)
285 SAM("ERROR: failed to read SAA register 0x%02X "
286 "so cannot reset\n", reg);
287 else {
288 itwas = (unsigned int)ir;
289 if (peasycap_standard->mask & 0x0001)
290 set = itwas | 0x80 ;
291 else
292 set = itwas & ~0x80 ;
293 rc = write_saa(peasycap->pusb_device, reg, set);
294 if (rc)
295 SAM("ERROR: failed to set SAA register 0x%02X to 0x%02X\n",
296 reg, set);
297 else {
298 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
299 if (0 > ir)
300 JOM(8, "SAA register 0x%02X changed to 0x%02X\n",
301 reg, isnow);
302 else
303 JOM(8, "SAA register 0x%02X changed "
304 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
305 }
306 }
307 /*--------------------------------------------------------------------------*/
308 /*
309 * SAA7113H DATASHEET PAGE 53, TABLE 66
310 */
311 /*--------------------------------------------------------------------------*/
312 reg = 0x5A;
313 ir = read_saa(peasycap->pusb_device, reg);
314 if (0 > ir)
315 SAM("ERROR: failed to read SAA register 0x%02X but continuing\n", reg);
316 itwas = (unsigned int)ir;
317 if (peasycap_standard->mask & 0x0001)
318 set = 0x0A ;
319 else
320 set = 0x07 ;
321 if (0 != write_saa(peasycap->pusb_device, reg, set))
322 SAM("ERROR: failed to set SAA register 0x%02X to 0x%02X\n",
323 reg, set);
324 else {
325 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
326 if (0 > ir)
327 JOM(8, "SAA register 0x%02X changed "
328 "to 0x%02X\n", reg, isnow);
329 else
330 JOM(8, "SAA register 0x%02X changed "
331 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
332 }
333 if (resubmit)
334 submit_video_urbs(peasycap);
335 return 0;
336 }
337 /*****************************************************************************/
338 /*--------------------------------------------------------------------------*/
339 /*
340 * THE ALGORITHM FOR RESPONDING TO THE VIDIO_S_FMT IOCTL REQUIRES
341 * A VALID VALUE OF peasycap->standard_offset, OTHERWISE -EBUSY IS RETURNED.
342 *
343 * PROVIDED THE ARGUMENT try IS false AND THERE IS NO PREMATURE ERROR RETURN
344 * THIS ROUTINE UPDATES THE FOLLOWING:
345 * peasycap->format_offset
346 * peasycap->inputset[peasycap->input].format_offset
347 * peasycap->pixelformat
348 * peasycap->height
349 * peasycap->width
350 * peasycap->bytesperpixel
351 * peasycap->byteswaporder
352 * peasycap->decimatepixel
353 * peasycap->frame_buffer_used
354 * peasycap->videofieldamount
355 * peasycap->offerfields
356 *
357 * IF SUCCESSFUL THE FUNCTION RETURNS THE OFFSET IN easycap_format[]
358 * IDENTIFYING THE FORMAT WHICH IS TO RETURNED TO THE USER.
359 * ERRORS RETURN A NEGATIVE NUMBER.
360 */
361 /*--------------------------------------------------------------------------*/
362 int adjust_format(struct easycap *peasycap,
363 u32 width, u32 height, u32 pixelformat, int field, bool try)
364 {
365 struct easycap_format *peasycap_format, *peasycap_best_format;
366 u16 mask;
367 struct usb_device *p;
368 int miss, multiplier, best, k;
369 char bf[5], fo[32], *pc;
370 u32 uc;
371 bool resubmit;
372
373 if (!peasycap) {
374 SAY("ERROR: peasycap is NULL\n");
375 return -EFAULT;
376 }
377 if (0 > peasycap->standard_offset) {
378 JOM(8, "%i=peasycap->standard_offset\n", peasycap->standard_offset);
379 return -EBUSY;
380 }
381 p = peasycap->pusb_device;
382 if (!p) {
383 SAM("ERROR: peaycap->pusb_device is NULL\n");
384 return -EFAULT;
385 }
386 pc = &bf[0];
387 uc = pixelformat;
388 memcpy((void *)pc, (void *)(&uc), 4);
389 bf[4] = 0;
390 mask = 0xFF & easycap_standard[peasycap->standard_offset].mask;
391 SAM("sought: %ix%i,%s(0x%08X),%i=field,0x%02X=std mask\n",
392 width, height, pc, pixelformat, field, mask);
393 switch (field) {
394 case V4L2_FIELD_ANY: {
395 strcpy(&fo[0], "V4L2_FIELD_ANY ");
396 break;
397 }
398 case V4L2_FIELD_NONE: {
399 strcpy(&fo[0], "V4L2_FIELD_NONE");
400 break;
401 }
402 case V4L2_FIELD_TOP: {
403 strcpy(&fo[0], "V4L2_FIELD_TOP");
404 break;
405 }
406 case V4L2_FIELD_BOTTOM: {
407 strcpy(&fo[0], "V4L2_FIELD_BOTTOM");
408 break;
409 }
410 case V4L2_FIELD_INTERLACED: {
411 strcpy(&fo[0], "V4L2_FIELD_INTERLACED");
412 break;
413 }
414 case V4L2_FIELD_SEQ_TB: {
415 strcpy(&fo[0], "V4L2_FIELD_SEQ_TB");
416 break;
417 }
418 case V4L2_FIELD_SEQ_BT: {
419 strcpy(&fo[0], "V4L2_FIELD_SEQ_BT");
420 break;
421 }
422 case V4L2_FIELD_ALTERNATE: {
423 strcpy(&fo[0], "V4L2_FIELD_ALTERNATE");
424 break;
425 }
426 case V4L2_FIELD_INTERLACED_TB: {
427 strcpy(&fo[0], "V4L2_FIELD_INTERLACED_TB");
428 break;
429 }
430 case V4L2_FIELD_INTERLACED_BT: {
431 strcpy(&fo[0], "V4L2_FIELD_INTERLACED_BT");
432 break;
433 }
434 default: {
435 strcpy(&fo[0], "V4L2_FIELD_... UNKNOWN ");
436 break;
437 }
438 }
439 SAM("sought: %s\n", &fo[0]);
440 if (V4L2_FIELD_ANY == field) {
441 field = V4L2_FIELD_NONE;
442 SAM("prefer: V4L2_FIELD_NONE=field, was V4L2_FIELD_ANY\n");
443 }
444 peasycap_best_format = NULL;
445 peasycap_format = &easycap_format[0];
446 while (0 != peasycap_format->v4l2_format.fmt.pix.width) {
447 JOM(16, ".> %i %i 0x%08X %ix%i\n",
448 peasycap_format->mask & 0x01,
449 peasycap_format->v4l2_format.fmt.pix.field,
450 peasycap_format->v4l2_format.fmt.pix.pixelformat,
451 peasycap_format->v4l2_format.fmt.pix.width,
452 peasycap_format->v4l2_format.fmt.pix.height);
453
454 if (((peasycap_format->mask & 0x1F) == (mask & 0x1F)) &&
455 (peasycap_format->v4l2_format.fmt.pix.field == field) &&
456 (peasycap_format->v4l2_format.fmt.pix.pixelformat == pixelformat) &&
457 (peasycap_format->v4l2_format.fmt.pix.width == width) &&
458 (peasycap_format->v4l2_format.fmt.pix.height == height)) {
459
460 peasycap_best_format = peasycap_format;
461 break;
462 }
463 peasycap_format++;
464 }
465 if (0 == peasycap_format->v4l2_format.fmt.pix.width) {
466 SAM("cannot do: %ix%i with standard mask 0x%02X\n",
467 width, height, mask);
468 peasycap_format = &easycap_format[0];
469 best = -1;
470 while (0 != peasycap_format->v4l2_format.fmt.pix.width) {
471 if (((peasycap_format->mask & 0x1F) == (mask & 0x1F)) &&
472 (peasycap_format->v4l2_format.fmt.pix.field == field) &&
473 (peasycap_format->v4l2_format.fmt.pix.pixelformat == pixelformat)) {
474
475 miss = abs(peasycap_format->v4l2_format.fmt.pix.width - width);
476 if ((best > miss) || (best < 0)) {
477 best = miss;
478 peasycap_best_format = peasycap_format;
479 if (!miss)
480 break;
481 }
482 }
483 peasycap_format++;
484 }
485 if (-1 == best) {
486 SAM("cannot do %ix... with standard mask 0x%02X\n",
487 width, mask);
488 SAM("cannot do ...x%i with standard mask 0x%02X\n",
489 height, mask);
490 SAM(" %ix%i unmatched\n", width, height);
491 return peasycap->format_offset;
492 }
493 }
494 if (!peasycap_best_format) {
495 SAM("MISTAKE: peasycap_best_format is NULL");
496 return -EINVAL;
497 }
498 peasycap_format = peasycap_best_format;
499
500 /*...........................................................................*/
501 if (try)
502 return peasycap_best_format - easycap_format;
503 /*...........................................................................*/
504
505 if (false != try) {
506 SAM("MISTAKE: true==try where is should be false\n");
507 return -EINVAL;
508 }
509 SAM("actioning: %ix%i %s\n",
510 peasycap_format->v4l2_format.fmt.pix.width,
511 peasycap_format->v4l2_format.fmt.pix.height,
512 &peasycap_format->name[0]);
513 peasycap->height = peasycap_format->v4l2_format.fmt.pix.height;
514 peasycap->width = peasycap_format->v4l2_format.fmt.pix.width;
515 peasycap->pixelformat = peasycap_format->v4l2_format.fmt.pix.pixelformat;
516 peasycap->format_offset = peasycap_format - easycap_format;
517
518
519 for (k = 0; k < INPUT_MANY; k++) {
520 if (!peasycap->inputset[k].format_offset_ok) {
521 peasycap->inputset[k].format_offset =
522 peasycap->format_offset;
523 }
524 }
525 if ((0 <= peasycap->input) && (INPUT_MANY > peasycap->input)) {
526 peasycap->inputset[peasycap->input].format_offset =
527 peasycap->format_offset;
528 peasycap->inputset[peasycap->input].format_offset_ok = 1;
529 } else
530 JOM(8, "%i=peasycap->input\n", peasycap->input);
531
532
533
534 peasycap->bytesperpixel = (0x00E0 & peasycap_format->mask) >> 5 ;
535 if (0x0100 & peasycap_format->mask)
536 peasycap->byteswaporder = true;
537 else
538 peasycap->byteswaporder = false;
539 if (0x0200 & peasycap_format->mask)
540 peasycap->skip = 5;
541 else
542 peasycap->skip = 0;
543 if (0x0800 & peasycap_format->mask)
544 peasycap->decimatepixel = true;
545 else
546 peasycap->decimatepixel = false;
547 if (0x1000 & peasycap_format->mask)
548 peasycap->offerfields = true;
549 else
550 peasycap->offerfields = false;
551 if (peasycap->decimatepixel)
552 multiplier = 2;
553 else
554 multiplier = 1;
555 peasycap->videofieldamount =
556 multiplier * peasycap->width * multiplier * peasycap->height;
557 peasycap->frame_buffer_used =
558 peasycap->bytesperpixel * peasycap->width * peasycap->height;
559 if (peasycap->video_isoc_streaming) {
560 resubmit = true;
561 kill_video_urbs(peasycap);
562 } else
563 resubmit = false;
564 /*---------------------------------------------------------------------------*/
565 /*
566 * PAL
567 */
568 /*---------------------------------------------------------------------------*/
569 if (0 == (0x01 & peasycap_format->mask)) {
570 if (((720 == peasycap_format->v4l2_format.fmt.pix.width) &&
571 (576 == peasycap_format->v4l2_format.fmt.pix.height)) ||
572 ((360 == peasycap_format->v4l2_format.fmt.pix.width) &&
573 (288 == peasycap_format->v4l2_format.fmt.pix.height))) {
574 if (set_resolution(p, 0x0000, 0x0001, 0x05A0, 0x0121)) {
575 SAM("ERROR: set_resolution() failed\n");
576 return -EINVAL;
577 }
578 } else if ((704 == peasycap_format->v4l2_format.fmt.pix.width) &&
579 (576 == peasycap_format->v4l2_format.fmt.pix.height)) {
580 if (set_resolution(p, 0x0004, 0x0001, 0x0584, 0x0121)) {
581 SAM("ERROR: set_resolution() failed\n");
582 return -EINVAL;
583 }
584 } else if (((640 == peasycap_format->v4l2_format.fmt.pix.width) &&
585 (480 == peasycap_format->v4l2_format.fmt.pix.height)) ||
586 ((320 == peasycap_format->v4l2_format.fmt.pix.width) &&
587 (240 == peasycap_format->v4l2_format.fmt.pix.height))) {
588 if (set_resolution(p, 0x0014, 0x0020, 0x0514, 0x0110)) {
589 SAM("ERROR: set_resolution() failed\n");
590 return -EINVAL;
591 }
592 } else {
593 SAM("MISTAKE: bad format, cannot set resolution\n");
594 return -EINVAL;
595 }
596 /*---------------------------------------------------------------------------*/
597 /*
598 * NTSC
599 */
600 /*---------------------------------------------------------------------------*/
601 } else {
602 if (((720 == peasycap_format->v4l2_format.fmt.pix.width) &&
603 (480 == peasycap_format->v4l2_format.fmt.pix.height)) ||
604 ((360 == peasycap_format->v4l2_format.fmt.pix.width) &&
605 (240 == peasycap_format->v4l2_format.fmt.pix.height))) {
606 if (set_resolution(p, 0x0000, 0x0003, 0x05A0, 0x00F3)) {
607 SAM("ERROR: set_resolution() failed\n");
608 return -EINVAL;
609 }
610 } else if (((640 == peasycap_format->v4l2_format.fmt.pix.width) &&
611 (480 == peasycap_format->v4l2_format.fmt.pix.height)) ||
612 ((320 == peasycap_format->v4l2_format.fmt.pix.width) &&
613 (240 == peasycap_format->v4l2_format.fmt.pix.height))) {
614 if (set_resolution(p, 0x0014, 0x0003, 0x0514, 0x00F3)) {
615 SAM("ERROR: set_resolution() failed\n");
616 return -EINVAL;
617 }
618 } else {
619 SAM("MISTAKE: bad format, cannot set resolution\n");
620 return -EINVAL;
621 }
622 }
623 /*---------------------------------------------------------------------------*/
624 if (resubmit)
625 submit_video_urbs(peasycap);
626
627 return peasycap_best_format - easycap_format;
628 }
629 /*****************************************************************************/
630 int adjust_brightness(struct easycap *peasycap, int value)
631 {
632 unsigned int mood;
633 int i1, k;
634
635 if (!peasycap) {
636 SAY("ERROR: peasycap is NULL\n");
637 return -EFAULT;
638 }
639 if (!peasycap->pusb_device) {
640 SAM("ERROR: peasycap->pusb_device is NULL\n");
641 return -EFAULT;
642 }
643 i1 = 0;
644 while (0xFFFFFFFF != easycap_control[i1].id) {
645 if (V4L2_CID_BRIGHTNESS == easycap_control[i1].id) {
646 if ((easycap_control[i1].minimum > value) ||
647 (easycap_control[i1].maximum < value))
648 value = easycap_control[i1].default_value;
649
650 if ((easycap_control[i1].minimum <= peasycap->brightness) &&
651 (easycap_control[i1].maximum >= peasycap->brightness)) {
652 if (peasycap->brightness == value) {
653 SAM("unchanged brightness at 0x%02X\n",
654 value);
655 return 0;
656 }
657 }
658 peasycap->brightness = value;
659 for (k = 0; k < INPUT_MANY; k++) {
660 if (!peasycap->inputset[k].brightness_ok)
661 peasycap->inputset[k].brightness =
662 peasycap->brightness;
663 }
664 if ((0 <= peasycap->input) && (INPUT_MANY > peasycap->input)) {
665 peasycap->inputset[peasycap->input].brightness =
666 peasycap->brightness;
667 peasycap->inputset[peasycap->input].brightness_ok = 1;
668 } else
669 JOM(8, "%i=peasycap->input\n", peasycap->input);
670 mood = 0x00FF & (unsigned int)peasycap->brightness;
671 if (!write_saa(peasycap->pusb_device, 0x0A, mood)) {
672 SAM("adjusting brightness to 0x%02X\n", mood);
673 return 0;
674 } else {
675 SAM("WARNING: failed to adjust brightness "
676 "to 0x%02X\n", mood);
677 return -ENOENT;
678 }
679 break;
680 }
681 i1++;
682 }
683 SAM("WARNING: failed to adjust brightness: control not found\n");
684 return -ENOENT;
685 }
686 /*****************************************************************************/
687 int adjust_contrast(struct easycap *peasycap, int value)
688 {
689 unsigned int mood;
690 int i1, k;
691
692 if (!peasycap) {
693 SAY("ERROR: peasycap is NULL\n");
694 return -EFAULT;
695 }
696 if (!peasycap->pusb_device) {
697 SAM("ERROR: peasycap->pusb_device is NULL\n");
698 return -EFAULT;
699 }
700 i1 = 0;
701 while (0xFFFFFFFF != easycap_control[i1].id) {
702 if (V4L2_CID_CONTRAST == easycap_control[i1].id) {
703 if ((easycap_control[i1].minimum > value) ||
704 (easycap_control[i1].maximum < value))
705 value = easycap_control[i1].default_value;
706
707
708 if ((easycap_control[i1].minimum <= peasycap->contrast) &&
709 (easycap_control[i1].maximum >= peasycap->contrast)) {
710 if (peasycap->contrast == value) {
711 SAM("unchanged contrast at 0x%02X\n", value);
712 return 0;
713 }
714 }
715 peasycap->contrast = value;
716 for (k = 0; k < INPUT_MANY; k++) {
717 if (!peasycap->inputset[k].contrast_ok)
718 peasycap->inputset[k].contrast = peasycap->contrast;
719 }
720
721 if ((0 <= peasycap->input) && (INPUT_MANY > peasycap->input)) {
722 peasycap->inputset[peasycap->input].contrast =
723 peasycap->contrast;
724 peasycap->inputset[peasycap->input].contrast_ok = 1;
725 } else
726 JOM(8, "%i=peasycap->input\n", peasycap->input);
727
728 mood = 0x00FF & (unsigned int) (peasycap->contrast - 128);
729 if (!write_saa(peasycap->pusb_device, 0x0B, mood)) {
730 SAM("adjusting contrast to 0x%02X\n", mood);
731 return 0;
732 } else {
733 SAM("WARNING: failed to adjust contrast to "
734 "0x%02X\n", mood);
735 return -ENOENT;
736 }
737 break;
738 }
739 i1++;
740 }
741 SAM("WARNING: failed to adjust contrast: control not found\n");
742 return -ENOENT;
743 }
744 /*****************************************************************************/
745 int adjust_saturation(struct easycap *peasycap, int value)
746 {
747 unsigned int mood;
748 int i1, k;
749
750 if (!peasycap) {
751 SAY("ERROR: peasycap is NULL\n");
752 return -EFAULT;
753 }
754 if (!peasycap->pusb_device) {
755 SAM("ERROR: peasycap->pusb_device is NULL\n");
756 return -EFAULT;
757 }
758 i1 = 0;
759 while (0xFFFFFFFF != easycap_control[i1].id) {
760 if (V4L2_CID_SATURATION == easycap_control[i1].id) {
761 if ((easycap_control[i1].minimum > value) ||
762 (easycap_control[i1].maximum < value))
763 value = easycap_control[i1].default_value;
764
765
766 if ((easycap_control[i1].minimum <= peasycap->saturation) &&
767 (easycap_control[i1].maximum >= peasycap->saturation)) {
768 if (peasycap->saturation == value) {
769 SAM("unchanged saturation at 0x%02X\n",
770 value);
771 return 0;
772 }
773 }
774 peasycap->saturation = value;
775 for (k = 0; k < INPUT_MANY; k++) {
776 if (!peasycap->inputset[k].saturation_ok)
777 peasycap->inputset[k].saturation =
778 peasycap->saturation;
779 }
780 if ((0 <= peasycap->input) && (INPUT_MANY > peasycap->input)) {
781 peasycap->inputset[peasycap->input].saturation =
782 peasycap->saturation;
783 peasycap->inputset[peasycap->input].saturation_ok = 1;
784 } else
785 JOM(8, "%i=peasycap->input\n", peasycap->input);
786 mood = 0x00FF & (unsigned int) (peasycap->saturation - 128);
787 if (!write_saa(peasycap->pusb_device, 0x0C, mood)) {
788 SAM("adjusting saturation to 0x%02X\n", mood);
789 return 0;
790 } else {
791 SAM("WARNING: failed to adjust saturation to "
792 "0x%02X\n", mood);
793 return -ENOENT;
794 }
795 break;
796 }
797 i1++;
798 }
799 SAM("WARNING: failed to adjust saturation: control not found\n");
800 return -ENOENT;
801 }
802 /*****************************************************************************/
803 int adjust_hue(struct easycap *peasycap, int value)
804 {
805 unsigned int mood;
806 int i1, i2, k;
807
808 if (!peasycap) {
809 SAY("ERROR: peasycap is NULL\n");
810 return -EFAULT;
811 }
812 if (!peasycap->pusb_device) {
813 SAM("ERROR: peasycap->pusb_device is NULL\n");
814 return -EFAULT;
815 }
816 i1 = 0;
817 while (0xFFFFFFFF != easycap_control[i1].id) {
818 if (V4L2_CID_HUE == easycap_control[i1].id) {
819 if ((easycap_control[i1].minimum > value) ||
820 (easycap_control[i1].maximum < value))
821 value = easycap_control[i1].default_value;
822
823 if ((easycap_control[i1].minimum <= peasycap->hue) &&
824 (easycap_control[i1].maximum >= peasycap->hue)) {
825 if (peasycap->hue == value) {
826 SAM("unchanged hue at 0x%02X\n", value);
827 return 0;
828 }
829 }
830 peasycap->hue = value;
831 for (k = 0; k < INPUT_MANY; k++) {
832 if (!peasycap->inputset[k].hue_ok)
833 peasycap->inputset[k].hue = peasycap->hue;
834 }
835 if (0 <= peasycap->input && INPUT_MANY > peasycap->input) {
836 peasycap->inputset[peasycap->input].hue = peasycap->hue;
837 peasycap->inputset[peasycap->input].hue_ok = 1;
838 } else
839 JOM(8, "%i=peasycap->input\n", peasycap->input);
840 i2 = peasycap->hue - 128;
841 mood = 0x00FF & ((int) i2);
842 if (!write_saa(peasycap->pusb_device, 0x0D, mood)) {
843 SAM("adjusting hue to 0x%02X\n", mood);
844 return 0;
845 } else {
846 SAM("WARNING: failed to adjust hue to 0x%02X\n", mood);
847 return -ENOENT;
848 }
849 break;
850 }
851 i1++;
852 }
853 SAM("WARNING: failed to adjust hue: control not found\n");
854 return -ENOENT;
855 }
856 /*****************************************************************************/
857 int adjust_volume(struct easycap *peasycap, int value)
858 {
859 s8 mood;
860 int i1;
861
862 if (!peasycap) {
863 SAY("ERROR: peasycap is NULL\n");
864 return -EFAULT;
865 }
866 if (!peasycap->pusb_device) {
867 SAM("ERROR: peasycap->pusb_device is NULL\n");
868 return -EFAULT;
869 }
870 i1 = 0;
871 while (0xFFFFFFFF != easycap_control[i1].id) {
872 if (V4L2_CID_AUDIO_VOLUME == easycap_control[i1].id) {
873 if ((easycap_control[i1].minimum > value) ||
874 (easycap_control[i1].maximum < value))
875 value = easycap_control[i1].default_value;
876
877 if ((easycap_control[i1].minimum <= peasycap->volume) &&
878 (easycap_control[i1].maximum >= peasycap->volume)) {
879 if (peasycap->volume == value) {
880 SAM("unchanged volume at 0x%02X\n", value);
881 return 0;
882 }
883 }
884 peasycap->volume = value;
885 mood = (16 > peasycap->volume) ? 16 :
886 ((31 < peasycap->volume) ? 31 :
887 (s8) peasycap->volume);
888 if (!audio_gainset(peasycap->pusb_device, mood)) {
889 SAM("adjusting volume to 0x%02X\n", mood);
890 return 0;
891 } else {
892 SAM("WARNING: failed to adjust volume to "
893 "0x%2X\n", mood);
894 return -ENOENT;
895 }
896 break;
897 }
898 i1++;
899 }
900 SAM("WARNING: failed to adjust volume: control not found\n");
901 return -ENOENT;
902 }
903 /*****************************************************************************/
904 /*---------------------------------------------------------------------------*/
905 /*
906 * AN ALTERNATIVE METHOD OF MUTING MIGHT SEEM TO BE:
907 * usb_set_interface(peasycap->pusb_device,
908 * peasycap->audio_interface,
909 * peasycap->audio_altsetting_off);
910 * HOWEVER, AFTER THIS COMMAND IS ISSUED ALL SUBSEQUENT URBS RECEIVE STATUS
911 * -ESHUTDOWN. THE HANDLER ROUTINE easyxxx_complete() DECLINES TO RESUBMIT
912 * THE URB AND THE PIPELINE COLLAPSES IRRETRIEVABLY. BEWARE.
913 */
914 /*---------------------------------------------------------------------------*/
915 static int adjust_mute(struct easycap *peasycap, int value)
916 {
917 int i1;
918
919 if (!peasycap) {
920 SAY("ERROR: peasycap is NULL\n");
921 return -EFAULT;
922 }
923 if (!peasycap->pusb_device) {
924 SAM("ERROR: peasycap->pusb_device is NULL\n");
925 return -EFAULT;
926 }
927 i1 = 0;
928 while (0xFFFFFFFF != easycap_control[i1].id) {
929 if (V4L2_CID_AUDIO_MUTE == easycap_control[i1].id) {
930 peasycap->mute = value;
931 switch (peasycap->mute) {
932 case 1: {
933 peasycap->audio_idle = 1;
934 SAM("adjusting mute: %i=peasycap->audio_idle\n",
935 peasycap->audio_idle);
936 return 0;
937 }
938 default: {
939 peasycap->audio_idle = 0;
940 SAM("adjusting mute: %i=peasycap->audio_idle\n",
941 peasycap->audio_idle);
942 return 0;
943 }
944 }
945 break;
946 }
947 i1++;
948 }
949 SAM("WARNING: failed to adjust mute: control not found\n");
950 return -ENOENT;
951 }
952 /*---------------------------------------------------------------------------*/
953 long easycap_unlocked_ioctl(struct file *file,
954 unsigned int cmd, unsigned long arg)
955 {
956 struct easycap *peasycap;
957 struct usb_device *p;
958 int kd;
959
960 if (!file) {
961 SAY("ERROR: file is NULL\n");
962 return -ERESTARTSYS;
963 }
964 peasycap = file->private_data;
965 if (!peasycap) {
966 SAY("ERROR: peasycap is NULL\n");
967 return -1;
968 }
969 p = peasycap->pusb_device;
970 if (!p) {
971 SAM("ERROR: peasycap->pusb_device is NULL\n");
972 return -EFAULT;
973 }
974 kd = isdongle(peasycap);
975 if (0 <= kd && DONGLE_MANY > kd) {
976 if (mutex_lock_interruptible(&easycapdc60_dongle[kd].mutex_video)) {
977 SAY("ERROR: cannot lock "
978 "easycapdc60_dongle[%i].mutex_video\n", kd);
979 return -ERESTARTSYS;
980 }
981 JOM(4, "locked easycapdc60_dongle[%i].mutex_video\n", kd);
982 /*---------------------------------------------------------------------------*/
983 /*
984 * MEANWHILE, easycap_usb_disconnect() MAY HAVE FREED POINTER peasycap,
985 * IN WHICH CASE A REPEAT CALL TO isdongle() WILL FAIL.
986 * IF NECESSARY, BAIL OUT.
987 */
988 /*---------------------------------------------------------------------------*/
989 if (kd != isdongle(peasycap))
990 return -ERESTARTSYS;
991 if (!file) {
992 SAY("ERROR: file is NULL\n");
993 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
994 return -ERESTARTSYS;
995 }
996 peasycap = file->private_data;
997 if (!peasycap) {
998 SAY("ERROR: peasycap is NULL\n");
999 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1000 return -ERESTARTSYS;
1001 }
1002 if (!peasycap->pusb_device) {
1003 SAM("ERROR: peasycap->pusb_device is NULL\n");
1004 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1005 return -ERESTARTSYS;
1006 }
1007 } else {
1008 /*---------------------------------------------------------------------------*/
1009 /*
1010 * IF easycap_usb_disconnect() HAS ALREADY FREED POINTER peasycap BEFORE THE
1011 * ATTEMPT TO ACQUIRE THE SEMAPHORE, isdongle() WILL HAVE FAILED. BAIL OUT.
1012 */
1013 /*---------------------------------------------------------------------------*/
1014 return -ERESTARTSYS;
1015 }
1016 /*---------------------------------------------------------------------------*/
1017 switch (cmd) {
1018 case VIDIOC_QUERYCAP: {
1019 struct v4l2_capability v4l2_capability;
1020 char version[16], *p1, *p2;
1021 int i, rc, k[3];
1022 long lng;
1023
1024 JOM(8, "VIDIOC_QUERYCAP\n");
1025
1026 if (16 <= strlen(EASYCAP_DRIVER_VERSION)) {
1027 SAM("ERROR: bad driver version string\n");
1028 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1029 return -EINVAL;
1030 }
1031 strcpy(&version[0], EASYCAP_DRIVER_VERSION);
1032 for (i = 0; i < 3; i++)
1033 k[i] = 0;
1034 p2 = &version[0];
1035 i = 0;
1036 while (*p2) {
1037 p1 = p2;
1038 while (*p2 && ('.' != *p2))
1039 p2++;
1040 if (*p2)
1041 *p2++ = 0;
1042 if (3 > i) {
1043 rc = (int) strict_strtol(p1, 10, &lng);
1044 if (rc) {
1045 SAM("ERROR: %i=strict_strtol(%s,.,,)\n",
1046 rc, p1);
1047 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1048 return -EINVAL;
1049 }
1050 k[i] = (int)lng;
1051 }
1052 i++;
1053 }
1054
1055 memset(&v4l2_capability, 0, sizeof(struct v4l2_capability));
1056 strlcpy(&v4l2_capability.driver[0],
1057 "easycap", sizeof(v4l2_capability.driver));
1058
1059 v4l2_capability.capabilities = V4L2_CAP_VIDEO_CAPTURE |
1060 V4L2_CAP_STREAMING |
1061 V4L2_CAP_AUDIO |
1062 V4L2_CAP_READWRITE;
1063
1064 v4l2_capability.version = KERNEL_VERSION(k[0], k[1], k[2]);
1065 JOM(8, "v4l2_capability.version=(%i,%i,%i)\n", k[0], k[1], k[2]);
1066
1067 strlcpy(&v4l2_capability.card[0],
1068 "EasyCAP DC60", sizeof(v4l2_capability.card));
1069
1070 if (usb_make_path(peasycap->pusb_device,
1071 &v4l2_capability.bus_info[0],
1072 sizeof(v4l2_capability.bus_info)) < 0) {
1073
1074 strlcpy(&v4l2_capability.bus_info[0], "EasyCAP bus_info",
1075 sizeof(v4l2_capability.bus_info));
1076 JOM(8, "%s=v4l2_capability.bus_info\n",
1077 &v4l2_capability.bus_info[0]);
1078 }
1079 if (copy_to_user((void __user *)arg, &v4l2_capability,
1080 sizeof(struct v4l2_capability))) {
1081 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1082 return -EFAULT;
1083 }
1084 break;
1085 }
1086 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1087 case VIDIOC_ENUMINPUT: {
1088 struct v4l2_input v4l2_input;
1089 u32 index;
1090
1091 JOM(8, "VIDIOC_ENUMINPUT\n");
1092
1093 if (copy_from_user(&v4l2_input, (void __user *)arg,
1094 sizeof(struct v4l2_input))) {
1095 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1096 return -EFAULT;
1097 }
1098
1099 index = v4l2_input.index;
1100 memset(&v4l2_input, 0, sizeof(struct v4l2_input));
1101
1102 switch (index) {
1103 case 0: {
1104 v4l2_input.index = index;
1105 strcpy(&v4l2_input.name[0], "CVBS0");
1106 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1107 v4l2_input.audioset = 0x01;
1108 v4l2_input.tuner = 0;
1109 v4l2_input.std = V4L2_STD_PAL |
1110 V4L2_STD_SECAM |
1111 V4L2_STD_NTSC ;
1112 v4l2_input.status = 0;
1113 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1114 break;
1115 }
1116 case 1: {
1117 v4l2_input.index = index;
1118 strcpy(&v4l2_input.name[0], "CVBS1");
1119 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1120 v4l2_input.audioset = 0x01;
1121 v4l2_input.tuner = 0;
1122 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM |
1123 V4L2_STD_NTSC;
1124 v4l2_input.status = 0;
1125 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1126 break;
1127 }
1128 case 2: {
1129 v4l2_input.index = index;
1130 strcpy(&v4l2_input.name[0], "CVBS2");
1131 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1132 v4l2_input.audioset = 0x01;
1133 v4l2_input.tuner = 0;
1134 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM |
1135 V4L2_STD_NTSC ;
1136 v4l2_input.status = 0;
1137 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1138 break;
1139 }
1140 case 3: {
1141 v4l2_input.index = index;
1142 strcpy(&v4l2_input.name[0], "CVBS3");
1143 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1144 v4l2_input.audioset = 0x01;
1145 v4l2_input.tuner = 0;
1146 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM |
1147 V4L2_STD_NTSC ;
1148 v4l2_input.status = 0;
1149 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1150 break;
1151 }
1152 case 4: {
1153 v4l2_input.index = index;
1154 strcpy(&v4l2_input.name[0], "CVBS4");
1155 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1156 v4l2_input.audioset = 0x01;
1157 v4l2_input.tuner = 0;
1158 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM |
1159 V4L2_STD_NTSC ;
1160 v4l2_input.status = 0;
1161 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1162 break;
1163 }
1164 case 5: {
1165 v4l2_input.index = index;
1166 strcpy(&v4l2_input.name[0], "S-VIDEO");
1167 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1168 v4l2_input.audioset = 0x01;
1169 v4l2_input.tuner = 0;
1170 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM |
1171 V4L2_STD_NTSC ;
1172 v4l2_input.status = 0;
1173 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1174 break;
1175 }
1176 default: {
1177 JOM(8, "%i=index: exhausts inputs\n", index);
1178 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1179 return -EINVAL;
1180 }
1181 }
1182
1183 if (copy_to_user((void __user *)arg, &v4l2_input,
1184 sizeof(struct v4l2_input))) {
1185 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1186 return -EFAULT;
1187 }
1188 break;
1189 }
1190 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1191 case VIDIOC_G_INPUT: {
1192 u32 index;
1193
1194 JOM(8, "VIDIOC_G_INPUT\n");
1195 index = (u32)peasycap->input;
1196 JOM(8, "user is told: %i\n", index);
1197 if (copy_to_user((void __user *)arg, &index, sizeof(u32))) {
1198 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1199 return -EFAULT;
1200 }
1201 break;
1202 }
1203 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1204 case VIDIOC_S_INPUT:
1205 {
1206 u32 index;
1207 int rc;
1208
1209 JOM(8, "VIDIOC_S_INPUT\n");
1210
1211 if (0 != copy_from_user(&index, (void __user *)arg, sizeof(u32))) {
1212 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1213 return -EFAULT;
1214 }
1215
1216 JOM(8, "user requests input %i\n", index);
1217
1218 if ((int)index == peasycap->input) {
1219 SAM("requested input already in effect\n");
1220 break;
1221 }
1222
1223 if ((0 > index) || (INPUT_MANY <= index)) {
1224 JOM(8, "ERROR: bad requested input: %i\n", index);
1225 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1226 return -EINVAL;
1227 }
1228
1229 rc = newinput(peasycap, (int)index);
1230 if (0 == rc) {
1231 JOM(8, "newinput(.,%i) OK\n", (int)index);
1232 } else {
1233 SAM("ERROR: newinput(.,%i) returned %i\n", (int)index, rc);
1234 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1235 return -EFAULT;
1236 }
1237 break;
1238 }
1239 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1240 case VIDIOC_ENUMAUDIO: {
1241 JOM(8, "VIDIOC_ENUMAUDIO\n");
1242 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1243 return -EINVAL;
1244 }
1245 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1246 case VIDIOC_ENUMAUDOUT: {
1247 struct v4l2_audioout v4l2_audioout;
1248
1249 JOM(8, "VIDIOC_ENUMAUDOUT\n");
1250
1251 if (copy_from_user(&v4l2_audioout, (void __user *)arg,
1252 sizeof(struct v4l2_audioout))) {
1253 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1254 return -EFAULT;
1255 }
1256
1257 if (0 != v4l2_audioout.index) {
1258 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1259 return -EINVAL;
1260 }
1261 memset(&v4l2_audioout, 0, sizeof(struct v4l2_audioout));
1262 v4l2_audioout.index = 0;
1263 strcpy(&v4l2_audioout.name[0], "Soundtrack");
1264
1265 if (copy_to_user((void __user *)arg, &v4l2_audioout,
1266 sizeof(struct v4l2_audioout))) {
1267 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1268 return -EFAULT;
1269 }
1270 break;
1271 }
1272 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1273 case VIDIOC_QUERYCTRL: {
1274 int i1;
1275 struct v4l2_queryctrl v4l2_queryctrl;
1276
1277 JOM(8, "VIDIOC_QUERYCTRL\n");
1278
1279 if (0 != copy_from_user(&v4l2_queryctrl, (void __user *)arg,
1280 sizeof(struct v4l2_queryctrl))) {
1281 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1282 return -EFAULT;
1283 }
1284
1285 i1 = 0;
1286 while (0xFFFFFFFF != easycap_control[i1].id) {
1287 if (easycap_control[i1].id == v4l2_queryctrl.id) {
1288 JOM(8, "VIDIOC_QUERYCTRL %s=easycap_control[%i]"
1289 ".name\n", &easycap_control[i1].name[0], i1);
1290 memcpy(&v4l2_queryctrl, &easycap_control[i1],
1291 sizeof(struct v4l2_queryctrl));
1292 break;
1293 }
1294 i1++;
1295 }
1296 if (0xFFFFFFFF == easycap_control[i1].id) {
1297 JOM(8, "%i=index: exhausts controls\n", i1);
1298 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1299 return -EINVAL;
1300 }
1301 if (copy_to_user((void __user *)arg, &v4l2_queryctrl,
1302 sizeof(struct v4l2_queryctrl))) {
1303 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1304 return -EFAULT;
1305 }
1306 break;
1307 }
1308 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1309 case VIDIOC_QUERYMENU: {
1310 JOM(8, "VIDIOC_QUERYMENU unsupported\n");
1311 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1312 return -EINVAL;
1313 }
1314 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1315 case VIDIOC_G_CTRL: {
1316 struct v4l2_control *pv4l2_control;
1317
1318 JOM(8, "VIDIOC_G_CTRL\n");
1319 pv4l2_control = memdup_user((void __user *)arg,
1320 sizeof(struct v4l2_control));
1321 if (IS_ERR(pv4l2_control)) {
1322 SAM("ERROR: copy from user failed\n");
1323 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1324 return PTR_ERR(pv4l2_control);
1325 }
1326
1327 switch (pv4l2_control->id) {
1328 case V4L2_CID_BRIGHTNESS: {
1329 pv4l2_control->value = peasycap->brightness;
1330 JOM(8, "user enquires brightness: %i\n", pv4l2_control->value);
1331 break;
1332 }
1333 case V4L2_CID_CONTRAST: {
1334 pv4l2_control->value = peasycap->contrast;
1335 JOM(8, "user enquires contrast: %i\n", pv4l2_control->value);
1336 break;
1337 }
1338 case V4L2_CID_SATURATION: {
1339 pv4l2_control->value = peasycap->saturation;
1340 JOM(8, "user enquires saturation: %i\n", pv4l2_control->value);
1341 break;
1342 }
1343 case V4L2_CID_HUE: {
1344 pv4l2_control->value = peasycap->hue;
1345 JOM(8, "user enquires hue: %i\n", pv4l2_control->value);
1346 break;
1347 }
1348 case V4L2_CID_AUDIO_VOLUME: {
1349 pv4l2_control->value = peasycap->volume;
1350 JOM(8, "user enquires volume: %i\n", pv4l2_control->value);
1351 break;
1352 }
1353 case V4L2_CID_AUDIO_MUTE: {
1354 if (1 == peasycap->mute)
1355 pv4l2_control->value = true;
1356 else
1357 pv4l2_control->value = false;
1358 JOM(8, "user enquires mute: %i\n", pv4l2_control->value);
1359 break;
1360 }
1361 default: {
1362 SAM("ERROR: unknown V4L2 control: 0x%08X=id\n",
1363 pv4l2_control->id);
1364 kfree(pv4l2_control);
1365 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1366 return -EINVAL;
1367 }
1368 }
1369 if (copy_to_user((void __user *)arg, pv4l2_control,
1370 sizeof(struct v4l2_control))) {
1371 kfree(pv4l2_control);
1372 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1373 return -EFAULT;
1374 }
1375 kfree(pv4l2_control);
1376 break;
1377 }
1378 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1379 case VIDIOC_S_CTRL: {
1380 struct v4l2_control v4l2_control;
1381
1382 JOM(8, "VIDIOC_S_CTRL\n");
1383
1384 if (0 != copy_from_user(&v4l2_control, (void __user *)arg,
1385 sizeof(struct v4l2_control))) {
1386 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1387 return -EFAULT;
1388 }
1389
1390 switch (v4l2_control.id) {
1391 case V4L2_CID_BRIGHTNESS: {
1392 JOM(8, "user requests brightness %i\n", v4l2_control.value);
1393 if (0 != adjust_brightness(peasycap, v4l2_control.value))
1394 ;
1395 break;
1396 }
1397 case V4L2_CID_CONTRAST: {
1398 JOM(8, "user requests contrast %i\n", v4l2_control.value);
1399 if (0 != adjust_contrast(peasycap, v4l2_control.value))
1400 ;
1401 break;
1402 }
1403 case V4L2_CID_SATURATION: {
1404 JOM(8, "user requests saturation %i\n", v4l2_control.value);
1405 if (0 != adjust_saturation(peasycap, v4l2_control.value))
1406 ;
1407 break;
1408 }
1409 case V4L2_CID_HUE: {
1410 JOM(8, "user requests hue %i\n", v4l2_control.value);
1411 if (0 != adjust_hue(peasycap, v4l2_control.value))
1412 ;
1413 break;
1414 }
1415 case V4L2_CID_AUDIO_VOLUME: {
1416 JOM(8, "user requests volume %i\n", v4l2_control.value);
1417 if (0 != adjust_volume(peasycap, v4l2_control.value))
1418 ;
1419 break;
1420 }
1421 case V4L2_CID_AUDIO_MUTE: {
1422 int mute;
1423
1424 JOM(8, "user requests mute %i\n", v4l2_control.value);
1425 if (v4l2_control.value)
1426 mute = 1;
1427 else
1428 mute = 0;
1429
1430 if (0 != adjust_mute(peasycap, mute))
1431 SAM("WARNING: failed to adjust mute to %i\n", mute);
1432 break;
1433 }
1434 default: {
1435 SAM("ERROR: unknown V4L2 control: 0x%08X=id\n",
1436 v4l2_control.id);
1437 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1438 return -EINVAL;
1439 }
1440 }
1441 break;
1442 }
1443 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1444 case VIDIOC_S_EXT_CTRLS: {
1445 JOM(8, "VIDIOC_S_EXT_CTRLS unsupported\n");
1446 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1447 return -EINVAL;
1448 }
1449 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1450 case VIDIOC_ENUM_FMT: {
1451 u32 index;
1452 struct v4l2_fmtdesc v4l2_fmtdesc;
1453
1454 JOM(8, "VIDIOC_ENUM_FMT\n");
1455
1456 if (0 != copy_from_user(&v4l2_fmtdesc, (void __user *)arg,
1457 sizeof(struct v4l2_fmtdesc))) {
1458 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1459 return -EFAULT;
1460 }
1461
1462 index = v4l2_fmtdesc.index;
1463 memset(&v4l2_fmtdesc, 0, sizeof(struct v4l2_fmtdesc));
1464
1465 v4l2_fmtdesc.index = index;
1466 v4l2_fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1467
1468 switch (index) {
1469 case 0: {
1470 v4l2_fmtdesc.flags = 0;
1471 strcpy(&v4l2_fmtdesc.description[0], "uyvy");
1472 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_UYVY;
1473 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1474 break;
1475 }
1476 case 1: {
1477 v4l2_fmtdesc.flags = 0;
1478 strcpy(&v4l2_fmtdesc.description[0], "yuy2");
1479 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_YUYV;
1480 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1481 break;
1482 }
1483 case 2: {
1484 v4l2_fmtdesc.flags = 0;
1485 strcpy(&v4l2_fmtdesc.description[0], "rgb24");
1486 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_RGB24;
1487 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1488 break;
1489 }
1490 case 3: {
1491 v4l2_fmtdesc.flags = 0;
1492 strcpy(&v4l2_fmtdesc.description[0], "rgb32");
1493 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_RGB32;
1494 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1495 break;
1496 }
1497 case 4: {
1498 v4l2_fmtdesc.flags = 0;
1499 strcpy(&v4l2_fmtdesc.description[0], "bgr24");
1500 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_BGR24;
1501 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1502 break;
1503 }
1504 case 5: {
1505 v4l2_fmtdesc.flags = 0;
1506 strcpy(&v4l2_fmtdesc.description[0], "bgr32");
1507 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_BGR32;
1508 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1509 break;
1510 }
1511 default: {
1512 JOM(8, "%i=index: exhausts formats\n", index);
1513 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1514 return -EINVAL;
1515 }
1516 }
1517 if (copy_to_user((void __user *)arg, &v4l2_fmtdesc,
1518 sizeof(struct v4l2_fmtdesc))) {
1519 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1520 return -EFAULT;
1521 }
1522 break;
1523 }
1524 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1525 /*
1526 * THE RESPONSE TO VIDIOC_ENUM_FRAMESIZES MUST BE CONDITIONED ON THE
1527 * THE CURRENT STANDARD, BECAUSE THAT IS WHAT gstreamer EXPECTS. BEWARE.
1528 */
1529 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1530 case VIDIOC_ENUM_FRAMESIZES: {
1531 u32 index;
1532 struct v4l2_frmsizeenum v4l2_frmsizeenum;
1533
1534 JOM(8, "VIDIOC_ENUM_FRAMESIZES\n");
1535
1536 if (0 != copy_from_user(&v4l2_frmsizeenum, (void __user *)arg,
1537 sizeof(struct v4l2_frmsizeenum))) {
1538 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1539 return -EFAULT;
1540 }
1541
1542 index = v4l2_frmsizeenum.index;
1543
1544 v4l2_frmsizeenum.type = (u32) V4L2_FRMSIZE_TYPE_DISCRETE;
1545
1546 if (peasycap->ntsc) {
1547 switch (index) {
1548 case 0: {
1549 v4l2_frmsizeenum.discrete.width = 640;
1550 v4l2_frmsizeenum.discrete.height = 480;
1551 JOM(8, "%i=index: %ix%i\n", index,
1552 (int)(v4l2_frmsizeenum.
1553 discrete.width),
1554 (int)(v4l2_frmsizeenum.
1555 discrete.height));
1556 break;
1557 }
1558 case 1: {
1559 v4l2_frmsizeenum.discrete.width = 320;
1560 v4l2_frmsizeenum.discrete.height = 240;
1561 JOM(8, "%i=index: %ix%i\n", index,
1562 (int)(v4l2_frmsizeenum.
1563 discrete.width),
1564 (int)(v4l2_frmsizeenum.
1565 discrete.height));
1566 break;
1567 }
1568 case 2: {
1569 v4l2_frmsizeenum.discrete.width = 720;
1570 v4l2_frmsizeenum.discrete.height = 480;
1571 JOM(8, "%i=index: %ix%i\n", index,
1572 (int)(v4l2_frmsizeenum.
1573 discrete.width),
1574 (int)(v4l2_frmsizeenum.
1575 discrete.height));
1576 break;
1577 }
1578 case 3: {
1579 v4l2_frmsizeenum.discrete.width = 360;
1580 v4l2_frmsizeenum.discrete.height = 240;
1581 JOM(8, "%i=index: %ix%i\n", index,
1582 (int)(v4l2_frmsizeenum.
1583 discrete.width),
1584 (int)(v4l2_frmsizeenum.
1585 discrete.height));
1586 break;
1587 }
1588 default: {
1589 JOM(8, "%i=index: exhausts framesizes\n", index);
1590 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1591 return -EINVAL;
1592 }
1593 }
1594 } else {
1595 switch (index) {
1596 case 0: {
1597 v4l2_frmsizeenum.discrete.width = 640;
1598 v4l2_frmsizeenum.discrete.height = 480;
1599 JOM(8, "%i=index: %ix%i\n", index,
1600 (int)(v4l2_frmsizeenum.
1601 discrete.width),
1602 (int)(v4l2_frmsizeenum.
1603 discrete.height));
1604 break;
1605 }
1606 case 1: {
1607 v4l2_frmsizeenum.discrete.width = 320;
1608 v4l2_frmsizeenum.discrete.height = 240;
1609 JOM(8, "%i=index: %ix%i\n", index,
1610 (int)(v4l2_frmsizeenum.
1611 discrete.width),
1612 (int)(v4l2_frmsizeenum.
1613 discrete.height));
1614 break;
1615 }
1616 case 2: {
1617 v4l2_frmsizeenum.discrete.width = 704;
1618 v4l2_frmsizeenum.discrete.height = 576;
1619 JOM(8, "%i=index: %ix%i\n", index,
1620 (int)(v4l2_frmsizeenum.
1621 discrete.width),
1622 (int)(v4l2_frmsizeenum.
1623 discrete.height));
1624 break;
1625 }
1626 case 3: {
1627 v4l2_frmsizeenum.discrete.width = 720;
1628 v4l2_frmsizeenum.discrete.height = 576;
1629 JOM(8, "%i=index: %ix%i\n", index,
1630 (int)(v4l2_frmsizeenum.
1631 discrete.width),
1632 (int)(v4l2_frmsizeenum.
1633 discrete.height));
1634 break;
1635 }
1636 case 4: {
1637 v4l2_frmsizeenum.discrete.width = 360;
1638 v4l2_frmsizeenum.discrete.height = 288;
1639 JOM(8, "%i=index: %ix%i\n", index,
1640 (int)(v4l2_frmsizeenum.
1641 discrete.width),
1642 (int)(v4l2_frmsizeenum.
1643 discrete.height));
1644 break;
1645 }
1646 default: {
1647 JOM(8, "%i=index: exhausts framesizes\n", index);
1648 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1649 return -EINVAL;
1650 }
1651 }
1652 }
1653 if (copy_to_user((void __user *)arg, &v4l2_frmsizeenum,
1654 sizeof(struct v4l2_frmsizeenum))) {
1655 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1656 return -EFAULT;
1657 }
1658 break;
1659 }
1660 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1661 /*
1662 * THE RESPONSE TO VIDIOC_ENUM_FRAMEINTERVALS MUST BE CONDITIONED ON THE
1663 * THE CURRENT STANDARD, BECAUSE THAT IS WHAT gstreamer EXPECTS. BEWARE.
1664 */
1665 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1666 case VIDIOC_ENUM_FRAMEINTERVALS: {
1667 u32 index;
1668 int denominator;
1669 struct v4l2_frmivalenum v4l2_frmivalenum;
1670
1671 JOM(8, "VIDIOC_ENUM_FRAMEINTERVALS\n");
1672
1673 if (peasycap->fps)
1674 denominator = peasycap->fps;
1675 else {
1676 if (peasycap->ntsc)
1677 denominator = 30;
1678 else
1679 denominator = 25;
1680 }
1681
1682 if (0 != copy_from_user(&v4l2_frmivalenum, (void __user *)arg,
1683 sizeof(struct v4l2_frmivalenum))) {
1684 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1685 return -EFAULT;
1686 }
1687
1688 index = v4l2_frmivalenum.index;
1689
1690 v4l2_frmivalenum.type = (u32) V4L2_FRMIVAL_TYPE_DISCRETE;
1691
1692 switch (index) {
1693 case 0: {
1694 v4l2_frmivalenum.discrete.numerator = 1;
1695 v4l2_frmivalenum.discrete.denominator = denominator;
1696 JOM(8, "%i=index: %i/%i\n", index,
1697 (int)(v4l2_frmivalenum.discrete.numerator),
1698 (int)(v4l2_frmivalenum.discrete.denominator));
1699 break;
1700 }
1701 case 1: {
1702 v4l2_frmivalenum.discrete.numerator = 1;
1703 v4l2_frmivalenum.discrete.denominator = denominator/5;
1704 JOM(8, "%i=index: %i/%i\n", index,
1705 (int)(v4l2_frmivalenum.discrete.numerator),
1706 (int)(v4l2_frmivalenum.discrete.denominator));
1707 break;
1708 }
1709 default: {
1710 JOM(8, "%i=index: exhausts frameintervals\n", index);
1711 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1712 return -EINVAL;
1713 }
1714 }
1715 if (copy_to_user((void __user *)arg, &v4l2_frmivalenum,
1716 sizeof(struct v4l2_frmivalenum))) {
1717 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1718 return -EFAULT;
1719 }
1720 break;
1721 }
1722 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1723 case VIDIOC_G_FMT: {
1724 struct v4l2_format *pv4l2_format;
1725 struct v4l2_pix_format *pv4l2_pix_format;
1726
1727 JOM(8, "VIDIOC_G_FMT\n");
1728 pv4l2_format = kzalloc(sizeof(struct v4l2_format), GFP_KERNEL);
1729 if (!pv4l2_format) {
1730 SAM("ERROR: out of memory\n");
1731 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1732 return -ENOMEM;
1733 }
1734 pv4l2_pix_format = kzalloc(sizeof(struct v4l2_pix_format), GFP_KERNEL);
1735 if (!pv4l2_pix_format) {
1736 SAM("ERROR: out of memory\n");
1737 kfree(pv4l2_format);
1738 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1739 return -ENOMEM;
1740 }
1741 if (0 != copy_from_user(pv4l2_format, (void __user *)arg,
1742 sizeof(struct v4l2_format))) {
1743 kfree(pv4l2_format);
1744 kfree(pv4l2_pix_format);
1745 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1746 return -EFAULT;
1747 }
1748
1749 if (pv4l2_format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1750 kfree(pv4l2_format);
1751 kfree(pv4l2_pix_format);
1752 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1753 return -EINVAL;
1754 }
1755
1756 memset(pv4l2_pix_format, 0, sizeof(struct v4l2_pix_format));
1757 pv4l2_format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1758 memcpy(&pv4l2_format->fmt.pix,
1759 &easycap_format[peasycap->format_offset]
1760 .v4l2_format.fmt.pix, sizeof(struct v4l2_pix_format));
1761 JOM(8, "user is told: %s\n",
1762 &easycap_format[peasycap->format_offset].name[0]);
1763
1764 if (copy_to_user((void __user *)arg, pv4l2_format,
1765 sizeof(struct v4l2_format))) {
1766 kfree(pv4l2_format);
1767 kfree(pv4l2_pix_format);
1768 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1769 return -EFAULT;
1770 }
1771 kfree(pv4l2_format);
1772 kfree(pv4l2_pix_format);
1773 break;
1774 }
1775 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1776 case VIDIOC_TRY_FMT:
1777 case VIDIOC_S_FMT: {
1778 struct v4l2_format v4l2_format;
1779 struct v4l2_pix_format v4l2_pix_format;
1780 bool try;
1781 int best_format;
1782
1783 if (VIDIOC_TRY_FMT == cmd) {
1784 JOM(8, "VIDIOC_TRY_FMT\n");
1785 try = true;
1786 } else {
1787 JOM(8, "VIDIOC_S_FMT\n");
1788 try = false;
1789 }
1790
1791 if (0 != copy_from_user(&v4l2_format, (void __user *)arg,
1792 sizeof(struct v4l2_format))) {
1793 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1794 return -EFAULT;
1795 }
1796
1797 best_format = adjust_format(peasycap,
1798 v4l2_format.fmt.pix.width,
1799 v4l2_format.fmt.pix.height,
1800 v4l2_format.fmt.pix.pixelformat,
1801 v4l2_format.fmt.pix.field,
1802 try);
1803 if (0 > best_format) {
1804 if (-EBUSY == best_format) {
1805 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1806 return -EBUSY;
1807 }
1808 JOM(8, "WARNING: adjust_format() returned %i\n", best_format);
1809 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1810 return -ENOENT;
1811 }
1812 /*...........................................................................*/
1813 memset(&v4l2_pix_format, 0, sizeof(struct v4l2_pix_format));
1814 v4l2_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1815
1816 memcpy(&(v4l2_format.fmt.pix),
1817 &(easycap_format[best_format].v4l2_format.fmt.pix),
1818 sizeof(v4l2_pix_format));
1819 JOM(8, "user is told: %s\n", &easycap_format[best_format].name[0]);
1820
1821 if (copy_to_user((void __user *)arg, &v4l2_format,
1822 sizeof(struct v4l2_format))) {
1823 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1824 return -EFAULT;
1825 }
1826 break;
1827 }
1828 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1829 case VIDIOC_CROPCAP: {
1830 struct v4l2_cropcap v4l2_cropcap;
1831
1832 JOM(8, "VIDIOC_CROPCAP\n");
1833
1834 if (0 != copy_from_user(&v4l2_cropcap, (void __user *)arg,
1835 sizeof(struct v4l2_cropcap))) {
1836 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1837 return -EFAULT;
1838 }
1839
1840 if (v4l2_cropcap.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1841 JOM(8, "v4l2_cropcap.type != V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
1842
1843 memset(&v4l2_cropcap, 0, sizeof(struct v4l2_cropcap));
1844 v4l2_cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1845 v4l2_cropcap.bounds.left = 0;
1846 v4l2_cropcap.bounds.top = 0;
1847 v4l2_cropcap.bounds.width = peasycap->width;
1848 v4l2_cropcap.bounds.height = peasycap->height;
1849 v4l2_cropcap.defrect.left = 0;
1850 v4l2_cropcap.defrect.top = 0;
1851 v4l2_cropcap.defrect.width = peasycap->width;
1852 v4l2_cropcap.defrect.height = peasycap->height;
1853 v4l2_cropcap.pixelaspect.numerator = 1;
1854 v4l2_cropcap.pixelaspect.denominator = 1;
1855
1856 JOM(8, "user is told: %ix%i\n", peasycap->width, peasycap->height);
1857
1858 if (copy_to_user((void __user *)arg, &v4l2_cropcap,
1859 sizeof(struct v4l2_cropcap))) {
1860 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1861 return -EFAULT;
1862 }
1863 break;
1864 }
1865 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1866 case VIDIOC_G_CROP:
1867 case VIDIOC_S_CROP: {
1868 JOM(8, "VIDIOC_G_CROP|VIDIOC_S_CROP unsupported\n");
1869 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1870 return -EINVAL;
1871 }
1872 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1873 case VIDIOC_QUERYSTD: {
1874 JOM(8, "VIDIOC_QUERYSTD: "
1875 "EasyCAP is incapable of detecting standard\n");
1876 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1877 return -EINVAL;
1878 break;
1879 }
1880 /*-------------------------------------------------------------------*/
1881 /*
1882 * THE MANIPULATIONS INVOLVING last0,last1,last2,last3
1883 * CONSTITUTE A WORKAROUND * FOR WHAT APPEARS TO BE
1884 * A BUG IN 64-BIT mplayer.
1885 * NOT NEEDED, BUT HOPEFULLY HARMLESS, FOR 32-BIT mplayer.
1886 */
1887 /*------------------------------------------------------------------*/
1888 case VIDIOC_ENUMSTD: {
1889 int last0 = -1, last1 = -1, last2 = -1, last3 = -1;
1890 struct v4l2_standard v4l2_standard;
1891 u32 index;
1892 struct easycap_standard const *peasycap_standard;
1893
1894 JOM(8, "VIDIOC_ENUMSTD\n");
1895
1896 if (0 != copy_from_user(&v4l2_standard, (void __user *)arg,
1897 sizeof(struct v4l2_standard))) {
1898 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1899 return -EFAULT;
1900 }
1901 index = v4l2_standard.index;
1902
1903 last3 = last2;
1904 last2 = last1;
1905 last1 = last0;
1906 last0 = index;
1907 if ((index == last3) && (index == last2) &&
1908 (index == last1) && (index == last0)) {
1909 index++;
1910 last3 = last2;
1911 last2 = last1;
1912 last1 = last0;
1913 last0 = index;
1914 }
1915
1916 memset(&v4l2_standard, 0, sizeof(struct v4l2_standard));
1917
1918 peasycap_standard = &easycap_standard[0];
1919 while (0xFFFF != peasycap_standard->mask) {
1920 if ((int)(peasycap_standard - &easycap_standard[0]) == index)
1921 break;
1922 peasycap_standard++;
1923 }
1924 if (0xFFFF == peasycap_standard->mask) {
1925 JOM(8, "%i=index: exhausts standards\n", index);
1926 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1927 return -EINVAL;
1928 }
1929 JOM(8, "%i=index: %s\n", index,
1930 &(peasycap_standard->v4l2_standard.name[0]));
1931 memcpy(&v4l2_standard, &(peasycap_standard->v4l2_standard),
1932 sizeof(struct v4l2_standard));
1933
1934 v4l2_standard.index = index;
1935
1936 if (copy_to_user((void __user *)arg, &v4l2_standard,
1937 sizeof(struct v4l2_standard))) {
1938 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1939 return -EFAULT;
1940 }
1941 break;
1942 }
1943 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1944 case VIDIOC_G_STD: {
1945 v4l2_std_id std_id;
1946 struct easycap_standard const *peasycap_standard;
1947
1948 JOM(8, "VIDIOC_G_STD\n");
1949
1950 if (0 > peasycap->standard_offset) {
1951 JOM(8, "%i=peasycap->standard_offset\n",
1952 peasycap->standard_offset);
1953 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1954 return -EBUSY;
1955 }
1956
1957 if (0 != copy_from_user(&std_id, (void __user *)arg,
1958 sizeof(v4l2_std_id))) {
1959 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1960 return -EFAULT;
1961 }
1962
1963 peasycap_standard = &easycap_standard[peasycap->standard_offset];
1964 std_id = peasycap_standard->v4l2_standard.id;
1965
1966 JOM(8, "user is told: %s\n",
1967 &peasycap_standard->v4l2_standard.name[0]);
1968
1969 if (copy_to_user((void __user *)arg, &std_id,
1970 sizeof(v4l2_std_id))) {
1971 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1972 return -EFAULT;
1973 }
1974 break;
1975 }
1976 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1977 case VIDIOC_S_STD: {
1978 v4l2_std_id std_id;
1979 int rc;
1980
1981 JOM(8, "VIDIOC_S_STD\n");
1982
1983 if (0 != copy_from_user(&std_id, (void __user *)arg,
1984 sizeof(v4l2_std_id))) {
1985 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1986 return -EFAULT;
1987 }
1988
1989 JOM(8, "User requests standard: 0x%08X%08X\n",
1990 (int)((std_id & (((v4l2_std_id)0xFFFFFFFF) << 32)) >> 32),
1991 (int)(std_id & ((v4l2_std_id)0xFFFFFFFF)));
1992
1993 rc = adjust_standard(peasycap, std_id);
1994 if (0 > rc) {
1995 JOM(8, "WARNING: adjust_standard() returned %i\n", rc);
1996 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1997 return -ENOENT;
1998 }
1999 break;
2000 }
2001 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2002 case VIDIOC_REQBUFS: {
2003 int nbuffers;
2004 struct v4l2_requestbuffers v4l2_requestbuffers;
2005
2006 JOM(8, "VIDIOC_REQBUFS\n");
2007
2008 if (0 != copy_from_user(&v4l2_requestbuffers,
2009 (void __user *)arg,
2010 sizeof(struct v4l2_requestbuffers))) {
2011 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2012 return -EFAULT;
2013 }
2014
2015 if (v4l2_requestbuffers.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2016 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2017 return -EINVAL;
2018 }
2019 if (v4l2_requestbuffers.memory != V4L2_MEMORY_MMAP) {
2020 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2021 return -EINVAL;
2022 }
2023 nbuffers = v4l2_requestbuffers.count;
2024 JOM(8, " User requests %i buffers ...\n", nbuffers);
2025 if (nbuffers < 2)
2026 nbuffers = 2;
2027 if (nbuffers > FRAME_BUFFER_MANY)
2028 nbuffers = FRAME_BUFFER_MANY;
2029 if (v4l2_requestbuffers.count == nbuffers) {
2030 JOM(8, " ... agree to %i buffers\n",
2031 nbuffers);
2032 } else {
2033 JOM(8, " ... insist on %i buffers\n",
2034 nbuffers);
2035 v4l2_requestbuffers.count = nbuffers;
2036 }
2037 peasycap->frame_buffer_many = nbuffers;
2038
2039 if (copy_to_user((void __user *)arg, &v4l2_requestbuffers,
2040 sizeof(struct v4l2_requestbuffers))) {
2041 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2042 return -EFAULT;
2043 }
2044 break;
2045 }
2046 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2047 case VIDIOC_QUERYBUF: {
2048 u32 index;
2049 struct v4l2_buffer v4l2_buffer;
2050
2051 JOM(8, "VIDIOC_QUERYBUF\n");
2052
2053 if (peasycap->video_eof) {
2054 JOM(8, "returning -EIO because %i=video_eof\n",
2055 peasycap->video_eof);
2056 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2057 return -EIO;
2058 }
2059
2060 if (0 != copy_from_user(&v4l2_buffer, (void __user *)arg,
2061 sizeof(struct v4l2_buffer))) {
2062 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2063 return -EFAULT;
2064 }
2065
2066 if (v4l2_buffer.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2067 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2068 return -EINVAL;
2069 }
2070 index = v4l2_buffer.index;
2071 if (index < 0 || index >= peasycap->frame_buffer_many)
2072 return -EINVAL;
2073 memset(&v4l2_buffer, 0, sizeof(struct v4l2_buffer));
2074 v4l2_buffer.index = index;
2075 v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2076 v4l2_buffer.bytesused = peasycap->frame_buffer_used;
2077 v4l2_buffer.flags = V4L2_BUF_FLAG_MAPPED |
2078 peasycap->done[index] |
2079 peasycap->queued[index];
2080 v4l2_buffer.field = V4L2_FIELD_NONE;
2081 v4l2_buffer.memory = V4L2_MEMORY_MMAP;
2082 v4l2_buffer.m.offset = index * FRAME_BUFFER_SIZE;
2083 v4l2_buffer.length = FRAME_BUFFER_SIZE;
2084
2085 JOM(16, " %10i=index\n", v4l2_buffer.index);
2086 JOM(16, " 0x%08X=type\n", v4l2_buffer.type);
2087 JOM(16, " %10i=bytesused\n", v4l2_buffer.bytesused);
2088 JOM(16, " 0x%08X=flags\n", v4l2_buffer.flags);
2089 JOM(16, " %10i=field\n", v4l2_buffer.field);
2090 JOM(16, " %10li=timestamp.tv_usec\n",
2091 (long)v4l2_buffer.timestamp.tv_usec);
2092 JOM(16, " %10i=sequence\n", v4l2_buffer.sequence);
2093 JOM(16, " 0x%08X=memory\n", v4l2_buffer.memory);
2094 JOM(16, " %10i=m.offset\n", v4l2_buffer.m.offset);
2095 JOM(16, " %10i=length\n", v4l2_buffer.length);
2096
2097 if (copy_to_user((void __user *)arg, &v4l2_buffer,
2098 sizeof(struct v4l2_buffer))) {
2099 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2100 return -EFAULT;
2101 }
2102 break;
2103 }
2104 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2105 case VIDIOC_QBUF: {
2106 struct v4l2_buffer v4l2_buffer;
2107
2108 JOM(8, "VIDIOC_QBUF\n");
2109
2110 if (0 != copy_from_user(&v4l2_buffer, (void __user *)arg,
2111 sizeof(struct v4l2_buffer))) {
2112 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2113 return -EFAULT;
2114 }
2115
2116 if (v4l2_buffer.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2117 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2118 return -EINVAL;
2119 }
2120 if (v4l2_buffer.memory != V4L2_MEMORY_MMAP) {
2121 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2122 return -EINVAL;
2123 }
2124 if (v4l2_buffer.index < 0 ||
2125 v4l2_buffer.index >= peasycap->frame_buffer_many) {
2126 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2127 return -EINVAL;
2128 }
2129 v4l2_buffer.flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_QUEUED;
2130
2131 peasycap->done[v4l2_buffer.index] = 0;
2132 peasycap->queued[v4l2_buffer.index] = V4L2_BUF_FLAG_QUEUED;
2133
2134 if (copy_to_user((void __user *)arg, &v4l2_buffer,
2135 sizeof(struct v4l2_buffer))) {
2136 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2137 return -EFAULT;
2138 }
2139
2140 JOM(8, "..... user queueing frame buffer %i\n",
2141 (int)v4l2_buffer.index);
2142
2143 peasycap->frame_lock = 0;
2144
2145 break;
2146 }
2147 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2148 case VIDIOC_DQBUF:
2149 {
2150 struct timeval timeval, timeval2;
2151 int i, j;
2152 struct v4l2_buffer v4l2_buffer;
2153 int rcdq;
2154 u16 input;
2155
2156 JOM(8, "VIDIOC_DQBUF\n");
2157
2158 if ((peasycap->video_idle) || (peasycap->video_eof)) {
2159 JOM(8, "returning -EIO because "
2160 "%i=video_idle %i=video_eof\n",
2161 peasycap->video_idle, peasycap->video_eof);
2162 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2163 return -EIO;
2164 }
2165
2166 if (copy_from_user(&v4l2_buffer, (void __user *)arg,
2167 sizeof(struct v4l2_buffer))) {
2168 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2169 return -EFAULT;
2170 }
2171
2172 if (v4l2_buffer.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2173 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2174 return -EINVAL;
2175 }
2176
2177 if (peasycap->offerfields) {
2178 /*---------------------------------------------------*/
2179 /*
2180 * IN ITS 50 "fps" MODE tvtime SEEMS ALWAYS TO REQUEST
2181 * V4L2_FIELD_BOTTOM
2182 */
2183 /*---------------------------------------------------*/
2184 if (V4L2_FIELD_TOP == v4l2_buffer.field)
2185 JOM(8, "user wants V4L2_FIELD_TOP\n");
2186 else if (V4L2_FIELD_BOTTOM == v4l2_buffer.field)
2187 JOM(8, "user wants V4L2_FIELD_BOTTOM\n");
2188 else if (V4L2_FIELD_ANY == v4l2_buffer.field)
2189 JOM(8, "user wants V4L2_FIELD_ANY\n");
2190 else
2191 JOM(8, "user wants V4L2_FIELD_...UNKNOWN: %i\n",
2192 v4l2_buffer.field);
2193 }
2194
2195 if (!peasycap->video_isoc_streaming) {
2196 JOM(16, "returning -EIO because video urbs not streaming\n");
2197 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2198 return -EIO;
2199 }
2200 /*-------------------------------------------------------------------*/
2201 /*
2202 * IF THE USER HAS PREVIOUSLY CALLED easycap_poll(),
2203 * AS DETERMINED BY FINDING
2204 * THE FLAG peasycap->polled SET, THERE MUST BE
2205 * NO FURTHER WAIT HERE. IN THIS
2206 * CASE, JUST CHOOSE THE FRAME INDICATED BY peasycap->frame_read
2207 */
2208 /*-------------------------------------------------------------------*/
2209
2210 if (!peasycap->polled) {
2211 do {
2212 rcdq = easycap_dqbuf(peasycap, 0);
2213 if (-EIO == rcdq) {
2214 JOM(8, "returning -EIO because "
2215 "dqbuf() returned -EIO\n");
2216 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2217 return -EIO;
2218 }
2219 } while (0 != rcdq);
2220 } else {
2221 if (peasycap->video_eof) {
2222 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2223 return -EIO;
2224 }
2225 }
2226 if (V4L2_BUF_FLAG_DONE != peasycap->done[peasycap->frame_read]) {
2227 JOM(8, "V4L2_BUF_FLAG_DONE != 0x%08X\n",
2228 peasycap->done[peasycap->frame_read]);
2229 }
2230 peasycap->polled = 0;
2231
2232 if (!(peasycap->isequence % 10)) {
2233 for (i = 0; i < 179; i++)
2234 peasycap->merit[i] = peasycap->merit[i+1];
2235 peasycap->merit[179] = merit_saa(peasycap->pusb_device);
2236 j = 0;
2237 for (i = 0; i < 180; i++)
2238 j += peasycap->merit[i];
2239 if (90 < j) {
2240 SAM("easycap driver shutting down "
2241 "on condition blue\n");
2242 peasycap->video_eof = 1;
2243 peasycap->audio_eof = 1;
2244 }
2245 }
2246
2247 v4l2_buffer.index = peasycap->frame_read;
2248 v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2249 v4l2_buffer.bytesused = peasycap->frame_buffer_used;
2250 v4l2_buffer.flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_DONE;
2251 if (peasycap->offerfields)
2252 v4l2_buffer.field = V4L2_FIELD_BOTTOM;
2253 else
2254 v4l2_buffer.field = V4L2_FIELD_NONE;
2255 do_gettimeofday(&timeval);
2256 timeval2 = timeval;
2257
2258 v4l2_buffer.timestamp = timeval2;
2259 v4l2_buffer.sequence = peasycap->isequence++;
2260 v4l2_buffer.memory = V4L2_MEMORY_MMAP;
2261 v4l2_buffer.m.offset = v4l2_buffer.index * FRAME_BUFFER_SIZE;
2262 v4l2_buffer.length = FRAME_BUFFER_SIZE;
2263
2264 JOM(16, " %10i=index\n", v4l2_buffer.index);
2265 JOM(16, " 0x%08X=type\n", v4l2_buffer.type);
2266 JOM(16, " %10i=bytesused\n", v4l2_buffer.bytesused);
2267 JOM(16, " 0x%08X=flags\n", v4l2_buffer.flags);
2268 JOM(16, " %10i=field\n", v4l2_buffer.field);
2269 JOM(16, " %10li=timestamp.tv_sec\n",
2270 (long)v4l2_buffer.timestamp.tv_sec);
2271 JOM(16, " %10li=timestamp.tv_usec\n",
2272 (long)v4l2_buffer.timestamp.tv_usec);
2273 JOM(16, " %10i=sequence\n", v4l2_buffer.sequence);
2274 JOM(16, " 0x%08X=memory\n", v4l2_buffer.memory);
2275 JOM(16, " %10i=m.offset\n", v4l2_buffer.m.offset);
2276 JOM(16, " %10i=length\n", v4l2_buffer.length);
2277
2278 if (copy_to_user((void __user *)arg, &v4l2_buffer,
2279 sizeof(struct v4l2_buffer))) {
2280 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2281 return -EFAULT;
2282 }
2283
2284 input = peasycap->frame_buffer[peasycap->frame_read][0].input;
2285 if (0x08 & input) {
2286 JOM(8, "user is offered frame buffer %i, input %i\n",
2287 peasycap->frame_read, (0x07 & input));
2288 } else {
2289 JOM(8, "user is offered frame buffer %i\n",
2290 peasycap->frame_read);
2291 }
2292 peasycap->frame_lock = 1;
2293 JOM(8, "%i=peasycap->frame_fill\n", peasycap->frame_fill);
2294 if (peasycap->frame_read == peasycap->frame_fill) {
2295 if (peasycap->frame_lock) {
2296 JOM(8, "WORRY: filling frame buffer "
2297 "while offered to user\n");
2298 }
2299 }
2300 break;
2301 }
2302 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2303 case VIDIOC_STREAMON: {
2304 int i;
2305
2306 JOM(8, "VIDIOC_STREAMON\n");
2307
2308 peasycap->isequence = 0;
2309 for (i = 0; i < 180; i++)
2310 peasycap->merit[i] = 0;
2311 if (!peasycap->pusb_device) {
2312 SAM("ERROR: peasycap->pusb_device is NULL\n");
2313 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2314 return -EFAULT;
2315 }
2316 submit_video_urbs(peasycap);
2317 peasycap->video_idle = 0;
2318 peasycap->audio_idle = 0;
2319 peasycap->video_eof = 0;
2320 peasycap->audio_eof = 0;
2321 break;
2322 }
2323 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2324 case VIDIOC_STREAMOFF: {
2325 JOM(8, "VIDIOC_STREAMOFF\n");
2326
2327 if (!peasycap->pusb_device) {
2328 SAM("ERROR: peasycap->pusb_device is NULL\n");
2329 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2330 return -EFAULT;
2331 }
2332
2333 peasycap->video_idle = 1;
2334 peasycap->audio_idle = 1;
2335 /*---------------------------------------------------------------------------*/
2336 /*
2337 * IF THE WAIT QUEUES ARE NOT CLEARED IN RESPONSE TO THE STREAMOFF COMMAND
2338 * THE USERSPACE PROGRAM, E.G. mplayer, MAY HANG ON EXIT. BEWARE.
2339 */
2340 /*---------------------------------------------------------------------------*/
2341 JOM(8, "calling wake_up on wq_video and wq_audio\n");
2342 wake_up_interruptible(&(peasycap->wq_video));
2343 if (peasycap->psubstream)
2344 snd_pcm_period_elapsed(peasycap->psubstream);
2345 break;
2346 }
2347 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2348 case VIDIOC_G_PARM: {
2349 struct v4l2_streamparm *pv4l2_streamparm;
2350
2351 JOM(8, "VIDIOC_G_PARM\n");
2352 pv4l2_streamparm = memdup_user((void __user *)arg,
2353 sizeof(struct v4l2_streamparm));
2354 if (IS_ERR(pv4l2_streamparm)) {
2355 SAM("ERROR: copy from user failed\n");
2356 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2357 return PTR_ERR(pv4l2_streamparm);
2358 }
2359
2360 if (pv4l2_streamparm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2361 kfree(pv4l2_streamparm);
2362 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2363 return -EINVAL;
2364 }
2365 pv4l2_streamparm->parm.capture.capability = 0;
2366 pv4l2_streamparm->parm.capture.capturemode = 0;
2367 pv4l2_streamparm->parm.capture.timeperframe.numerator = 1;
2368
2369 if (peasycap->fps) {
2370 pv4l2_streamparm->parm.capture.timeperframe.
2371 denominator = peasycap->fps;
2372 } else {
2373 if (peasycap->ntsc) {
2374 pv4l2_streamparm->parm.capture.timeperframe.
2375 denominator = 30;
2376 } else {
2377 pv4l2_streamparm->parm.capture.timeperframe.
2378 denominator = 25;
2379 }
2380 }
2381
2382 pv4l2_streamparm->parm.capture.readbuffers =
2383 peasycap->frame_buffer_many;
2384 pv4l2_streamparm->parm.capture.extendedmode = 0;
2385 if (copy_to_user((void __user *)arg,
2386 pv4l2_streamparm,
2387 sizeof(struct v4l2_streamparm))) {
2388 kfree(pv4l2_streamparm);
2389 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2390 return -EFAULT;
2391 }
2392 kfree(pv4l2_streamparm);
2393 break;
2394 }
2395 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2396 case VIDIOC_S_PARM: {
2397 JOM(8, "VIDIOC_S_PARM unsupported\n");
2398 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2399 return -EINVAL;
2400 }
2401 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2402 case VIDIOC_G_AUDIO: {
2403 JOM(8, "VIDIOC_G_AUDIO unsupported\n");
2404 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2405 return -EINVAL;
2406 }
2407 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2408 case VIDIOC_S_AUDIO: {
2409 JOM(8, "VIDIOC_S_AUDIO unsupported\n");
2410 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2411 return -EINVAL;
2412 }
2413 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2414 case VIDIOC_S_TUNER: {
2415 JOM(8, "VIDIOC_S_TUNER unsupported\n");
2416 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2417 return -EINVAL;
2418 }
2419 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2420 case VIDIOC_G_FBUF:
2421 case VIDIOC_S_FBUF:
2422 case VIDIOC_OVERLAY: {
2423 JOM(8, "VIDIOC_G_FBUF|VIDIOC_S_FBUF|VIDIOC_OVERLAY unsupported\n");
2424 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2425 return -EINVAL;
2426 }
2427 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2428 case VIDIOC_G_TUNER: {
2429 JOM(8, "VIDIOC_G_TUNER unsupported\n");
2430 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2431 return -EINVAL;
2432 }
2433 case VIDIOC_G_FREQUENCY:
2434 case VIDIOC_S_FREQUENCY: {
2435 JOM(8, "VIDIOC_G_FREQUENCY|VIDIOC_S_FREQUENCY unsupported\n");
2436 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2437 return -EINVAL;
2438 }
2439 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2440 default: {
2441 JOM(8, "ERROR: unrecognized V4L2 IOCTL command: 0x%08X\n", cmd);
2442 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2443 return -ENOIOCTLCMD;
2444 }
2445 }
2446 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2447 JOM(4, "unlocked easycapdc60_dongle[%i].mutex_video\n", kd);
2448 return 0;
2449 }
2450 /*****************************************************************************/