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