1 /******************************************************************************
5 ******************************************************************************/
8 * Copyright (C) 2010 R.M. Thomas <rmthomas@sciolus.org>
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.
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.
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
26 /*****************************************************************************/
28 #include <linux/smp_lock.h>
31 /*--------------------------------------------------------------------------*/
33 * UNLESS THERE IS A PREMATURE ERROR RETURN THIS ROUTINE UPDATES THE
35 * peasycap->standard_offset
36 * peasycap->inputset[peasycap->input].standard_offset
42 /*---------------------------------------------------------------------------*/
43 int adjust_standard(struct easycap *peasycap, v4l2_std_id std_id)
45 struct easycap_standard const *peasycap_standard;
48 unsigned int itwas, isnow;
51 if (NULL == peasycap) {
52 SAY("ERROR: peasycap is NULL\n");
55 if (NULL == peasycap->pusb_device) {
56 SAM("ERROR: peasycap->pusb_device is NULL\n");
59 peasycap_standard = &easycap_standard[0];
60 while (0xFFFF != peasycap_standard->mask) {
61 if (std_id == peasycap_standard->v4l2_standard.id)
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)
73 if (0xFFFF == peasycap_standard->mask) {
74 SAM("ERROR: 0x%08X=std_id: standard not found\n",
75 (unsigned int)std_id);
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");
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;
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;
96 JOM(8, "%i=peasycap->input\n", peasycap->input);
98 peasycap->fps = peasycap_standard->v4l2_standard.frameperiod.denominator /
99 peasycap_standard->v4l2_standard.frameperiod.numerator;
100 switch (peasycap->fps) {
103 peasycap->ntsc = true;
108 peasycap->ntsc = false;
112 SAM("MISTAKE: %i=frames-per-second\n", peasycap->fps);
116 JOM(8, "%i frames-per-second\n", peasycap->fps);
117 if (0x8000 & peasycap_standard->mask) {
119 peasycap->usec = 1000000 / (2 * (5 * peasycap->fps));
120 peasycap->tolerate = 1000 * (25 / (5 * peasycap->fps));
123 peasycap->usec = 1000000 / (2 * peasycap->fps);
124 peasycap->tolerate = 1000 * (25 / peasycap->fps);
126 if (peasycap->video_isoc_streaming) {
128 kill_video_urbs(peasycap);
131 /*--------------------------------------------------------------------------*/
133 * SAA7113H DATASHEET PAGE 44, TABLE 42
135 /*--------------------------------------------------------------------------*/
140 switch (peasycap_standard->mask & 0x000F) {
144 ir = read_saa(peasycap->pusb_device, reg);
146 SAM("ERROR: cannot read SAA register 0x%02X\n", reg);
148 itwas = (unsigned int)ir;
149 rc = write_saa(peasycap->pusb_device, reg, set);
151 SAM("ERROR: failed to set SAA register "
152 "0x%02X to 0x%02X for JP standard\n", reg, set);
154 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
156 JOM(8, "SAA register 0x%02X changed "
157 "to 0x%02X\n", reg, isnow);
159 JOM(8, "SAA register 0x%02X changed "
160 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
165 ir = read_saa(peasycap->pusb_device, reg);
167 SAM("ERROR: cannot read SAA register 0x%02X\n", reg);
169 itwas = (unsigned int)ir;
170 rc = write_saa(peasycap->pusb_device, reg, set);
172 SAM("ERROR: failed to set SAA register 0x%02X to 0x%02X "
173 "for JP standard\n", reg, set);
175 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
177 JOM(8, "SAA register 0x%02X changed "
178 "to 0x%02X\n", reg, isnow);
180 JOM(8, "SAA register 0x%02X changed "
181 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
183 /*--------------------------------------------------------------------------*/
185 * NOTE: NO break HERE: RUN ON TO NEXT CASE
187 /*--------------------------------------------------------------------------*/
226 /*--------------------------------------------------------------------------*/
228 ir = read_saa(peasycap->pusb_device, reg);
230 SAM("ERROR: failed to read SAA register 0x%02X\n", reg);
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);
238 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
240 JOM(8, "SAA register 0x%02X changed "
241 "to 0x%02X\n", reg, isnow);
243 JOM(8, "SAA register 0x%02X changed "
244 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
247 /*--------------------------------------------------------------------------*/
249 * SAA7113H DATASHEET PAGE 41
251 /*--------------------------------------------------------------------------*/
253 ir = read_saa(peasycap->pusb_device, reg);
255 SAM("ERROR: failed to read SAA register 0x%02X "
256 "so cannot reset\n", reg);
258 itwas = (unsigned int)ir;
259 if (peasycap_standard->mask & 0x0001)
262 set = itwas & ~0x40 ;
263 rc = write_saa(peasycap->pusb_device, reg, set);
265 SAM("ERROR: failed to set SAA register 0x%02X to 0x%02X\n",
268 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
270 JOM(8, "SAA register 0x%02X changed to 0x%02X\n",
273 JOM(8, "SAA register 0x%02X changed "
274 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
277 /*--------------------------------------------------------------------------*/
279 * SAA7113H DATASHEET PAGE 51, TABLE 57
281 /*---------------------------------------------------------------------------*/
283 ir = read_saa(peasycap->pusb_device, reg);
285 SAM("ERROR: failed to read SAA register 0x%02X "
286 "so cannot reset\n", reg);
288 itwas = (unsigned int)ir;
289 if (peasycap_standard->mask & 0x0001)
292 set = itwas & ~0x80 ;
293 rc = write_saa(peasycap->pusb_device, reg, set);
295 SAM("ERROR: failed to set SAA register 0x%02X to 0x%02X\n",
298 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
300 JOM(8, "SAA register 0x%02X changed to 0x%02X\n",
303 JOM(8, "SAA register 0x%02X changed "
304 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
307 /*--------------------------------------------------------------------------*/
309 * SAA7113H DATASHEET PAGE 53, TABLE 66
311 /*--------------------------------------------------------------------------*/
313 ir = read_saa(peasycap->pusb_device, reg);
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)
321 if (0 != write_saa(peasycap->pusb_device, reg, set))
322 SAM("ERROR: failed to set SAA register 0x%02X to 0x%02X\n",
325 isnow = (unsigned int)read_saa(peasycap->pusb_device, reg);
327 JOM(8, "SAA register 0x%02X changed "
328 "to 0x%02X\n", reg, isnow);
330 JOM(8, "SAA register 0x%02X changed "
331 "from 0x%02X to 0x%02X\n", reg, itwas, isnow);
333 if (true == resubmit)
334 submit_video_urbs(peasycap);
337 /*****************************************************************************/
338 /*--------------------------------------------------------------------------*/
340 * THE ALGORITHM FOR RESPONDING TO THE VIDIO_S_FMT IOCTL REQUIRES
341 * A VALID VALUE OF peasycap->standard_offset, OTHERWISE -EBUSY IS RETURNED.
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
350 * peasycap->bytesperpixel
351 * peasycap->byteswaporder
352 * peasycap->decimatepixel
353 * peasycap->frame_buffer_used
354 * peasycap->videofieldamount
355 * peasycap->offerfields
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.
361 /*--------------------------------------------------------------------------*/
362 int adjust_format(struct easycap *peasycap,
363 u32 width, u32 height, u32 pixelformat, int field, bool try)
365 struct easycap_format *peasycap_format, *peasycap_best_format;
367 struct usb_device *p;
368 int miss, multiplier, best, k;
369 char bf[5], fo[32], *pc;
373 if (NULL == peasycap) {
374 SAY("ERROR: peasycap is NULL\n");
377 if (0 > peasycap->standard_offset) {
378 JOM(8, "%i=peasycap->standard_offset\n", peasycap->standard_offset);
381 p = peasycap->pusb_device;
383 SAM("ERROR: peaycap->pusb_device is NULL\n");
388 memcpy((void *)pc, (void *)(&uc), 4);
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);
394 case V4L2_FIELD_ANY: {
395 strcpy(&fo[0], "V4L2_FIELD_ANY ");
398 case V4L2_FIELD_NONE: {
399 strcpy(&fo[0], "V4L2_FIELD_NONE");
402 case V4L2_FIELD_TOP: {
403 strcpy(&fo[0], "V4L2_FIELD_TOP");
406 case V4L2_FIELD_BOTTOM: {
407 strcpy(&fo[0], "V4L2_FIELD_BOTTOM");
410 case V4L2_FIELD_INTERLACED: {
411 strcpy(&fo[0], "V4L2_FIELD_INTERLACED");
414 case V4L2_FIELD_SEQ_TB: {
415 strcpy(&fo[0], "V4L2_FIELD_SEQ_TB");
418 case V4L2_FIELD_SEQ_BT: {
419 strcpy(&fo[0], "V4L2_FIELD_SEQ_BT");
422 case V4L2_FIELD_ALTERNATE: {
423 strcpy(&fo[0], "V4L2_FIELD_ALTERNATE");
426 case V4L2_FIELD_INTERLACED_TB: {
427 strcpy(&fo[0], "V4L2_FIELD_INTERLACED_TB");
430 case V4L2_FIELD_INTERLACED_BT: {
431 strcpy(&fo[0], "V4L2_FIELD_INTERLACED_BT");
435 strcpy(&fo[0], "V4L2_FIELD_... UNKNOWN ");
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");
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);
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)) {
460 peasycap_best_format = peasycap_format;
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];
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)) {
475 miss = abs(peasycap_format->v4l2_format.fmt.pix.width - width);
476 if ((best > miss) || (best < 0)) {
478 peasycap_best_format = peasycap_format;
486 SAM("cannot do %ix... with standard mask 0x%02X\n",
488 SAM("cannot do ...x%i with standard mask 0x%02X\n",
490 SAM(" %ix%i unmatched\n", width, height);
491 return peasycap->format_offset;
494 if (NULL == peasycap_best_format) {
495 SAM("MISTAKE: peasycap_best_format is NULL");
498 peasycap_format = peasycap_best_format;
500 /*...........................................................................*/
502 return peasycap_best_format - easycap_format;
503 /*...........................................................................*/
506 SAM("MISTAKE: true==try where is should be false\n");
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;
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;
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;
530 JOM(8, "%i=peasycap->input\n", peasycap->input);
534 peasycap->bytesperpixel = (0x00E0 & peasycap_format->mask) >> 5 ;
535 if (0x0100 & peasycap_format->mask)
536 peasycap->byteswaporder = true;
538 peasycap->byteswaporder = false;
539 if (0x0200 & peasycap_format->mask)
543 if (0x0800 & peasycap_format->mask)
544 peasycap->decimatepixel = true;
546 peasycap->decimatepixel = false;
547 if (0x1000 & peasycap_format->mask)
548 peasycap->offerfields = true;
550 peasycap->offerfields = false;
551 if (true == peasycap->decimatepixel)
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) {
561 kill_video_urbs(peasycap);
564 /*---------------------------------------------------------------------------*/
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");
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");
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");
593 SAM("MISTAKE: bad format, cannot set resolution\n");
596 /*---------------------------------------------------------------------------*/
600 /*---------------------------------------------------------------------------*/
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");
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");
619 SAM("MISTAKE: bad format, cannot set resolution\n");
623 /*---------------------------------------------------------------------------*/
625 submit_video_urbs(peasycap);
627 return peasycap_best_format - easycap_format;
629 /*****************************************************************************/
630 int adjust_brightness(struct easycap *peasycap, int value)
635 if (NULL == peasycap) {
636 SAY("ERROR: peasycap is NULL\n");
639 if (NULL == peasycap->pusb_device) {
640 SAM("ERROR: peasycap->pusb_device is NULL\n");
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;
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",
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;
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;
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);
675 SAM("WARNING: failed to adjust brightness "
676 "to 0x%02X\n", mood);
683 SAM("WARNING: failed to adjust brightness: control not found\n");
686 /*****************************************************************************/
687 int adjust_contrast(struct easycap *peasycap, int value)
692 if (NULL == peasycap) {
693 SAY("ERROR: peasycap is NULL\n");
696 if (NULL == peasycap->pusb_device) {
697 SAM("ERROR: peasycap->pusb_device is NULL\n");
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;
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);
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;
721 if ((0 <= peasycap->input) && (INPUT_MANY > peasycap->input)) {
722 peasycap->inputset[peasycap->input].contrast =
724 peasycap->inputset[peasycap->input].contrast_ok = 1;
726 JOM(8, "%i=peasycap->input\n", peasycap->input);
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);
733 SAM("WARNING: failed to adjust contrast to "
741 SAM("WARNING: failed to adjust contrast: control not found\n");
744 /*****************************************************************************/
745 int adjust_saturation(struct easycap *peasycap, int value)
750 if (NULL == peasycap) {
751 SAY("ERROR: peasycap is NULL\n");
754 if (NULL == peasycap->pusb_device) {
755 SAM("ERROR: peasycap->pusb_device is NULL\n");
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;
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",
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;
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;
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);
791 SAM("WARNING: failed to adjust saturation to "
799 SAM("WARNING: failed to adjust saturation: control not found\n");
802 /*****************************************************************************/
803 int adjust_hue(struct easycap *peasycap, int value)
808 if (NULL == peasycap) {
809 SAY("ERROR: peasycap is NULL\n");
812 if (NULL == peasycap->pusb_device) {
813 SAM("ERROR: peasycap->pusb_device is NULL\n");
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;
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);
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;
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;
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);
846 SAM("WARNING: failed to adjust hue to 0x%02X\n", mood);
853 SAM("WARNING: failed to adjust hue: control not found\n");
856 /*****************************************************************************/
857 int adjust_volume(struct easycap *peasycap, int value)
862 if (NULL == peasycap) {
863 SAY("ERROR: peasycap is NULL\n");
866 if (NULL == peasycap->pusb_device) {
867 SAM("ERROR: peasycap->pusb_device is NULL\n");
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;
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);
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);
892 SAM("WARNING: failed to adjust volume to "
900 SAM("WARNING: failed to adjust volume: control not found\n");
903 /*****************************************************************************/
904 /*---------------------------------------------------------------------------*/
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.
914 /*---------------------------------------------------------------------------*/
915 static int adjust_mute(struct easycap *peasycap, int value)
919 if (NULL == peasycap) {
920 SAY("ERROR: peasycap is NULL\n");
923 if (NULL == peasycap->pusb_device) {
924 SAM("ERROR: peasycap->pusb_device is NULL\n");
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) {
933 peasycap->audio_idle = 1;
934 peasycap->timeval0.tv_sec = 0;
935 SAM("adjusting mute: %i=peasycap->audio_idle\n",
936 peasycap->audio_idle);
940 peasycap->audio_idle = 0;
941 SAM("adjusting mute: %i=peasycap->audio_idle\n",
942 peasycap->audio_idle);
950 SAM("WARNING: failed to adjust mute: control not found\n");
953 /*---------------------------------------------------------------------------*/
954 long easycap_unlocked_ioctl(struct file *file,
955 unsigned int cmd, unsigned long arg)
957 struct easycap *peasycap;
958 struct usb_device *p;
962 SAY("ERROR: file is NULL\n");
965 peasycap = file->private_data;
966 if (NULL == peasycap) {
967 SAY("ERROR: peasycap is NULL\n");
970 if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
971 SAY("ERROR: bad peasycap\n");
974 p = peasycap->pusb_device;
976 SAM("ERROR: peasycap->pusb_device is NULL\n");
979 kd = isdongle(peasycap);
980 if (0 <= kd && DONGLE_MANY > kd) {
981 if (mutex_lock_interruptible(&easycapdc60_dongle[kd].mutex_video)) {
982 SAY("ERROR: cannot lock "
983 "easycapdc60_dongle[%i].mutex_video\n", kd);
986 JOM(4, "locked easycapdc60_dongle[%i].mutex_video\n", kd);
987 /*---------------------------------------------------------------------------*/
989 * MEANWHILE, easycap_usb_disconnect() MAY HAVE FREED POINTER peasycap,
990 * IN WHICH CASE A REPEAT CALL TO isdongle() WILL FAIL.
991 * IF NECESSARY, BAIL OUT.
993 /*---------------------------------------------------------------------------*/
994 if (kd != isdongle(peasycap))
997 SAY("ERROR: file is NULL\n");
998 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1001 peasycap = file->private_data;
1002 if (NULL == peasycap) {
1003 SAY("ERROR: peasycap is NULL\n");
1004 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1005 return -ERESTARTSYS;
1007 if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
1008 SAY("ERROR: bad peasycap\n");
1009 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1012 p = peasycap->pusb_device;
1013 if (NULL == peasycap->pusb_device) {
1014 SAM("ERROR: peasycap->pusb_device is NULL\n");
1015 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1016 return -ERESTARTSYS;
1019 /*---------------------------------------------------------------------------*/
1021 * IF easycap_usb_disconnect() HAS ALREADY FREED POINTER peasycap BEFORE THE
1022 * ATTEMPT TO ACQUIRE THE SEMAPHORE, isdongle() WILL HAVE FAILED. BAIL OUT.
1024 /*---------------------------------------------------------------------------*/
1025 return -ERESTARTSYS;
1027 /*---------------------------------------------------------------------------*/
1029 case VIDIOC_QUERYCAP: {
1030 struct v4l2_capability v4l2_capability;
1031 char version[16], *p1, *p2;
1035 JOM(8, "VIDIOC_QUERYCAP\n");
1037 if (16 <= strlen(EASYCAP_DRIVER_VERSION)) {
1038 SAM("ERROR: bad driver version string\n");
1039 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1042 strcpy(&version[0], EASYCAP_DRIVER_VERSION);
1043 for (i = 0; i < 3; i++)
1049 while (*p2 && ('.' != *p2))
1054 rc = (int) strict_strtol(p1, 10, &lng);
1056 SAM("ERROR: %i=strict_strtol(%s,.,,)\n",
1058 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1066 memset(&v4l2_capability, 0, sizeof(struct v4l2_capability));
1067 strlcpy(&v4l2_capability.driver[0],
1068 "easycap", sizeof(v4l2_capability.driver));
1070 v4l2_capability.capabilities = V4L2_CAP_VIDEO_CAPTURE |
1071 V4L2_CAP_STREAMING |
1075 v4l2_capability.version = KERNEL_VERSION(k[0], k[1], k[2]);
1076 JOM(8, "v4l2_capability.version=(%i,%i,%i)\n", k[0], k[1], k[2]);
1078 strlcpy(&v4l2_capability.card[0],
1079 "EasyCAP DC60", sizeof(v4l2_capability.card));
1081 if (usb_make_path(peasycap->pusb_device,
1082 &v4l2_capability.bus_info[0],
1083 sizeof(v4l2_capability.bus_info)) < 0) {
1085 strlcpy(&v4l2_capability.bus_info[0], "EasyCAP bus_info",
1086 sizeof(v4l2_capability.bus_info));
1087 JOM(8, "%s=v4l2_capability.bus_info\n",
1088 &v4l2_capability.bus_info[0]);
1090 if (copy_to_user((void __user *)arg, &v4l2_capability,
1091 sizeof(struct v4l2_capability))) {
1092 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1097 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1098 case VIDIOC_ENUMINPUT: {
1099 struct v4l2_input v4l2_input;
1102 JOM(8, "VIDIOC_ENUMINPUT\n");
1104 if (copy_from_user(&v4l2_input, (void __user *)arg,
1105 sizeof(struct v4l2_input))) {
1106 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1110 index = v4l2_input.index;
1111 memset(&v4l2_input, 0, sizeof(struct v4l2_input));
1115 v4l2_input.index = index;
1116 strcpy(&v4l2_input.name[0], "CVBS0");
1117 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1118 v4l2_input.audioset = 0x01;
1119 v4l2_input.tuner = 0;
1120 v4l2_input.std = V4L2_STD_PAL |
1123 v4l2_input.status = 0;
1124 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1128 v4l2_input.index = index;
1129 strcpy(&v4l2_input.name[0], "CVBS1");
1130 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1131 v4l2_input.audioset = 0x01;
1132 v4l2_input.tuner = 0;
1133 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM |
1135 v4l2_input.status = 0;
1136 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1140 v4l2_input.index = index;
1141 strcpy(&v4l2_input.name[0], "CVBS2");
1142 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1143 v4l2_input.audioset = 0x01;
1144 v4l2_input.tuner = 0;
1145 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM |
1147 v4l2_input.status = 0;
1148 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1152 v4l2_input.index = index;
1153 strcpy(&v4l2_input.name[0], "CVBS3");
1154 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1155 v4l2_input.audioset = 0x01;
1156 v4l2_input.tuner = 0;
1157 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM |
1159 v4l2_input.status = 0;
1160 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1164 v4l2_input.index = index;
1165 strcpy(&v4l2_input.name[0], "CVBS4");
1166 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1167 v4l2_input.audioset = 0x01;
1168 v4l2_input.tuner = 0;
1169 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM |
1171 v4l2_input.status = 0;
1172 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1176 v4l2_input.index = index;
1177 strcpy(&v4l2_input.name[0], "S-VIDEO");
1178 v4l2_input.type = V4L2_INPUT_TYPE_CAMERA;
1179 v4l2_input.audioset = 0x01;
1180 v4l2_input.tuner = 0;
1181 v4l2_input.std = V4L2_STD_PAL | V4L2_STD_SECAM |
1183 v4l2_input.status = 0;
1184 JOM(8, "%i=index: %s\n", index, &v4l2_input.name[0]);
1188 JOM(8, "%i=index: exhausts inputs\n", index);
1189 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1194 if (copy_to_user((void __user *)arg, &v4l2_input,
1195 sizeof(struct v4l2_input))) {
1196 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1201 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1202 case VIDIOC_G_INPUT: {
1205 JOM(8, "VIDIOC_G_INPUT\n");
1206 index = (u32)peasycap->input;
1207 JOM(8, "user is told: %i\n", index);
1208 if (copy_to_user((void __user *)arg, &index, sizeof(u32))) {
1209 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1214 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1215 case VIDIOC_S_INPUT:
1220 JOM(8, "VIDIOC_S_INPUT\n");
1222 if (0 != copy_from_user(&index, (void __user *)arg, sizeof(u32))) {
1223 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1227 JOM(8, "user requests input %i\n", index);
1229 if ((int)index == peasycap->input) {
1230 SAM("requested input already in effect\n");
1234 if ((0 > index) || (INPUT_MANY <= index)) {
1235 JOM(8, "ERROR: bad requested input: %i\n", index);
1236 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1240 rc = newinput(peasycap, (int)index);
1242 JOM(8, "newinput(.,%i) OK\n", (int)index);
1244 SAM("ERROR: newinput(.,%i) returned %i\n", (int)index, rc);
1245 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1250 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1251 case VIDIOC_ENUMAUDIO: {
1252 JOM(8, "VIDIOC_ENUMAUDIO\n");
1253 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1256 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1257 case VIDIOC_ENUMAUDOUT: {
1258 struct v4l2_audioout v4l2_audioout;
1260 JOM(8, "VIDIOC_ENUMAUDOUT\n");
1262 if (copy_from_user(&v4l2_audioout, (void __user *)arg,
1263 sizeof(struct v4l2_audioout))) {
1264 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1268 if (0 != v4l2_audioout.index) {
1269 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1272 memset(&v4l2_audioout, 0, sizeof(struct v4l2_audioout));
1273 v4l2_audioout.index = 0;
1274 strcpy(&v4l2_audioout.name[0], "Soundtrack");
1276 if (copy_to_user((void __user *)arg, &v4l2_audioout,
1277 sizeof(struct v4l2_audioout))) {
1278 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1283 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1284 case VIDIOC_QUERYCTRL: {
1286 struct v4l2_queryctrl v4l2_queryctrl;
1288 JOM(8, "VIDIOC_QUERYCTRL\n");
1290 if (0 != copy_from_user(&v4l2_queryctrl, (void __user *)arg,
1291 sizeof(struct v4l2_queryctrl))) {
1292 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1297 while (0xFFFFFFFF != easycap_control[i1].id) {
1298 if (easycap_control[i1].id == v4l2_queryctrl.id) {
1299 JOM(8, "VIDIOC_QUERYCTRL %s=easycap_control[%i]"
1300 ".name\n", &easycap_control[i1].name[0], i1);
1301 memcpy(&v4l2_queryctrl, &easycap_control[i1],
1302 sizeof(struct v4l2_queryctrl));
1307 if (0xFFFFFFFF == easycap_control[i1].id) {
1308 JOM(8, "%i=index: exhausts controls\n", i1);
1309 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1312 if (copy_to_user((void __user *)arg, &v4l2_queryctrl,
1313 sizeof(struct v4l2_queryctrl))) {
1314 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1319 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1320 case VIDIOC_QUERYMENU: {
1321 JOM(8, "VIDIOC_QUERYMENU unsupported\n");
1322 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1325 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1326 case VIDIOC_G_CTRL: {
1327 struct v4l2_control *pv4l2_control;
1329 JOM(8, "VIDIOC_G_CTRL\n");
1330 pv4l2_control = kzalloc(sizeof(struct v4l2_control), GFP_KERNEL);
1331 if (!pv4l2_control) {
1332 SAM("ERROR: out of memory\n");
1333 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1336 if (0 != copy_from_user(pv4l2_control, (void __user *)arg,
1337 sizeof(struct v4l2_control))) {
1338 kfree(pv4l2_control);
1339 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1343 switch (pv4l2_control->id) {
1344 case V4L2_CID_BRIGHTNESS: {
1345 pv4l2_control->value = peasycap->brightness;
1346 JOM(8, "user enquires brightness: %i\n", pv4l2_control->value);
1349 case V4L2_CID_CONTRAST: {
1350 pv4l2_control->value = peasycap->contrast;
1351 JOM(8, "user enquires contrast: %i\n", pv4l2_control->value);
1354 case V4L2_CID_SATURATION: {
1355 pv4l2_control->value = peasycap->saturation;
1356 JOM(8, "user enquires saturation: %i\n", pv4l2_control->value);
1359 case V4L2_CID_HUE: {
1360 pv4l2_control->value = peasycap->hue;
1361 JOM(8, "user enquires hue: %i\n", pv4l2_control->value);
1364 case V4L2_CID_AUDIO_VOLUME: {
1365 pv4l2_control->value = peasycap->volume;
1366 JOM(8, "user enquires volume: %i\n", pv4l2_control->value);
1369 case V4L2_CID_AUDIO_MUTE: {
1370 if (1 == peasycap->mute)
1371 pv4l2_control->value = true;
1373 pv4l2_control->value = false;
1374 JOM(8, "user enquires mute: %i\n", pv4l2_control->value);
1378 SAM("ERROR: unknown V4L2 control: 0x%08X=id\n",
1380 kfree(pv4l2_control);
1381 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1385 if (copy_to_user((void __user *)arg, pv4l2_control,
1386 sizeof(struct v4l2_control))) {
1387 kfree(pv4l2_control);
1388 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1391 kfree(pv4l2_control);
1394 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1397 struct v4l2_control v4l2_control;
1399 JOM(8, "VIDIOC_S_CTRL\n");
1401 if (0 != copy_from_user(&v4l2_control, (void __user *)arg,
1402 sizeof(struct v4l2_control))) {
1403 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1407 switch (v4l2_control.id) {
1408 case V4L2_CID_BRIGHTNESS: {
1409 JOM(8, "user requests brightness %i\n", v4l2_control.value);
1410 if (0 != adjust_brightness(peasycap, v4l2_control.value))
1414 case V4L2_CID_CONTRAST: {
1415 JOM(8, "user requests contrast %i\n", v4l2_control.value);
1416 if (0 != adjust_contrast(peasycap, v4l2_control.value))
1420 case V4L2_CID_SATURATION: {
1421 JOM(8, "user requests saturation %i\n", v4l2_control.value);
1422 if (0 != adjust_saturation(peasycap, v4l2_control.value))
1426 case V4L2_CID_HUE: {
1427 JOM(8, "user requests hue %i\n", v4l2_control.value);
1428 if (0 != adjust_hue(peasycap, v4l2_control.value))
1432 case V4L2_CID_AUDIO_VOLUME: {
1433 JOM(8, "user requests volume %i\n", v4l2_control.value);
1434 if (0 != adjust_volume(peasycap, v4l2_control.value))
1438 case V4L2_CID_AUDIO_MUTE: {
1441 JOM(8, "user requests mute %i\n", v4l2_control.value);
1442 if (true == v4l2_control.value)
1447 if (0 != adjust_mute(peasycap, mute))
1448 SAM("WARNING: failed to adjust mute to %i\n", mute);
1452 SAM("ERROR: unknown V4L2 control: 0x%08X=id\n",
1454 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1460 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1461 case VIDIOC_S_EXT_CTRLS: {
1462 JOM(8, "VIDIOC_S_EXT_CTRLS unsupported\n");
1463 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1466 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1467 case VIDIOC_ENUM_FMT: {
1469 struct v4l2_fmtdesc v4l2_fmtdesc;
1471 JOM(8, "VIDIOC_ENUM_FMT\n");
1473 if (0 != copy_from_user(&v4l2_fmtdesc, (void __user *)arg,
1474 sizeof(struct v4l2_fmtdesc))) {
1475 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1479 index = v4l2_fmtdesc.index;
1480 memset(&v4l2_fmtdesc, 0, sizeof(struct v4l2_fmtdesc));
1482 v4l2_fmtdesc.index = index;
1483 v4l2_fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1487 v4l2_fmtdesc.flags = 0;
1488 strcpy(&v4l2_fmtdesc.description[0], "uyvy");
1489 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_UYVY;
1490 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1494 v4l2_fmtdesc.flags = 0;
1495 strcpy(&v4l2_fmtdesc.description[0], "yuy2");
1496 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_YUYV;
1497 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1501 v4l2_fmtdesc.flags = 0;
1502 strcpy(&v4l2_fmtdesc.description[0], "rgb24");
1503 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_RGB24;
1504 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1508 v4l2_fmtdesc.flags = 0;
1509 strcpy(&v4l2_fmtdesc.description[0], "rgb32");
1510 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_RGB32;
1511 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1515 v4l2_fmtdesc.flags = 0;
1516 strcpy(&v4l2_fmtdesc.description[0], "bgr24");
1517 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_BGR24;
1518 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1522 v4l2_fmtdesc.flags = 0;
1523 strcpy(&v4l2_fmtdesc.description[0], "bgr32");
1524 v4l2_fmtdesc.pixelformat = V4L2_PIX_FMT_BGR32;
1525 JOM(8, "%i=index: %s\n", index, &v4l2_fmtdesc.description[0]);
1529 JOM(8, "%i=index: exhausts formats\n", index);
1530 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1534 if (copy_to_user((void __user *)arg, &v4l2_fmtdesc,
1535 sizeof(struct v4l2_fmtdesc))) {
1536 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1541 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1543 * THE RESPONSE TO VIDIOC_ENUM_FRAMESIZES MUST BE CONDITIONED ON THE
1544 * THE CURRENT STANDARD, BECAUSE THAT IS WHAT gstreamer EXPECTS. BEWARE.
1546 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1547 case VIDIOC_ENUM_FRAMESIZES: {
1549 struct v4l2_frmsizeenum v4l2_frmsizeenum;
1551 JOM(8, "VIDIOC_ENUM_FRAMESIZES\n");
1553 if (0 != copy_from_user(&v4l2_frmsizeenum, (void __user *)arg,
1554 sizeof(struct v4l2_frmsizeenum))) {
1555 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1559 index = v4l2_frmsizeenum.index;
1561 v4l2_frmsizeenum.type = (u32) V4L2_FRMSIZE_TYPE_DISCRETE;
1563 if (true == peasycap->ntsc) {
1566 v4l2_frmsizeenum.discrete.width = 640;
1567 v4l2_frmsizeenum.discrete.height = 480;
1568 JOM(8, "%i=index: %ix%i\n", index,
1569 (int)(v4l2_frmsizeenum.
1571 (int)(v4l2_frmsizeenum.
1576 v4l2_frmsizeenum.discrete.width = 320;
1577 v4l2_frmsizeenum.discrete.height = 240;
1578 JOM(8, "%i=index: %ix%i\n", index,
1579 (int)(v4l2_frmsizeenum.
1581 (int)(v4l2_frmsizeenum.
1586 v4l2_frmsizeenum.discrete.width = 720;
1587 v4l2_frmsizeenum.discrete.height = 480;
1588 JOM(8, "%i=index: %ix%i\n", index,
1589 (int)(v4l2_frmsizeenum.
1591 (int)(v4l2_frmsizeenum.
1596 v4l2_frmsizeenum.discrete.width = 360;
1597 v4l2_frmsizeenum.discrete.height = 240;
1598 JOM(8, "%i=index: %ix%i\n", index,
1599 (int)(v4l2_frmsizeenum.
1601 (int)(v4l2_frmsizeenum.
1606 JOM(8, "%i=index: exhausts framesizes\n", index);
1607 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1614 v4l2_frmsizeenum.discrete.width = 640;
1615 v4l2_frmsizeenum.discrete.height = 480;
1616 JOM(8, "%i=index: %ix%i\n", index,
1617 (int)(v4l2_frmsizeenum.
1619 (int)(v4l2_frmsizeenum.
1624 v4l2_frmsizeenum.discrete.width = 320;
1625 v4l2_frmsizeenum.discrete.height = 240;
1626 JOM(8, "%i=index: %ix%i\n", index,
1627 (int)(v4l2_frmsizeenum.
1629 (int)(v4l2_frmsizeenum.
1634 v4l2_frmsizeenum.discrete.width = 704;
1635 v4l2_frmsizeenum.discrete.height = 576;
1636 JOM(8, "%i=index: %ix%i\n", index,
1637 (int)(v4l2_frmsizeenum.
1639 (int)(v4l2_frmsizeenum.
1644 v4l2_frmsizeenum.discrete.width = 720;
1645 v4l2_frmsizeenum.discrete.height = 576;
1646 JOM(8, "%i=index: %ix%i\n", index,
1647 (int)(v4l2_frmsizeenum.
1649 (int)(v4l2_frmsizeenum.
1654 v4l2_frmsizeenum.discrete.width = 360;
1655 v4l2_frmsizeenum.discrete.height = 288;
1656 JOM(8, "%i=index: %ix%i\n", index,
1657 (int)(v4l2_frmsizeenum.
1659 (int)(v4l2_frmsizeenum.
1664 JOM(8, "%i=index: exhausts framesizes\n", index);
1665 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1670 if (copy_to_user((void __user *)arg, &v4l2_frmsizeenum,
1671 sizeof(struct v4l2_frmsizeenum))) {
1672 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1677 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1679 * THE RESPONSE TO VIDIOC_ENUM_FRAMEINTERVALS MUST BE CONDITIONED ON THE
1680 * THE CURRENT STANDARD, BECAUSE THAT IS WHAT gstreamer EXPECTS. BEWARE.
1682 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1683 case VIDIOC_ENUM_FRAMEINTERVALS: {
1686 struct v4l2_frmivalenum v4l2_frmivalenum;
1688 JOM(8, "VIDIOC_ENUM_FRAMEINTERVALS\n");
1691 denominator = peasycap->fps;
1693 if (true == peasycap->ntsc)
1699 if (0 != copy_from_user(&v4l2_frmivalenum, (void __user *)arg,
1700 sizeof(struct v4l2_frmivalenum))) {
1701 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1705 index = v4l2_frmivalenum.index;
1707 v4l2_frmivalenum.type = (u32) V4L2_FRMIVAL_TYPE_DISCRETE;
1711 v4l2_frmivalenum.discrete.numerator = 1;
1712 v4l2_frmivalenum.discrete.denominator = denominator;
1713 JOM(8, "%i=index: %i/%i\n", index,
1714 (int)(v4l2_frmivalenum.discrete.numerator),
1715 (int)(v4l2_frmivalenum.discrete.denominator));
1719 v4l2_frmivalenum.discrete.numerator = 1;
1720 v4l2_frmivalenum.discrete.denominator = denominator/5;
1721 JOM(8, "%i=index: %i/%i\n", index,
1722 (int)(v4l2_frmivalenum.discrete.numerator),
1723 (int)(v4l2_frmivalenum.discrete.denominator));
1727 JOM(8, "%i=index: exhausts frameintervals\n", index);
1728 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1732 if (copy_to_user((void __user *)arg, &v4l2_frmivalenum,
1733 sizeof(struct v4l2_frmivalenum))) {
1734 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1739 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1740 case VIDIOC_G_FMT: {
1741 struct v4l2_format *pv4l2_format;
1742 struct v4l2_pix_format *pv4l2_pix_format;
1744 JOM(8, "VIDIOC_G_FMT\n");
1745 pv4l2_format = kzalloc(sizeof(struct v4l2_format), GFP_KERNEL);
1746 if (!pv4l2_format) {
1747 SAM("ERROR: out of memory\n");
1748 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1751 pv4l2_pix_format = kzalloc(sizeof(struct v4l2_pix_format), GFP_KERNEL);
1752 if (!pv4l2_pix_format) {
1753 SAM("ERROR: out of memory\n");
1754 kfree(pv4l2_format);
1755 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1758 if (0 != copy_from_user(pv4l2_format, (void __user *)arg,
1759 sizeof(struct v4l2_format))) {
1760 kfree(pv4l2_format);
1761 kfree(pv4l2_pix_format);
1762 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1766 if (pv4l2_format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1767 kfree(pv4l2_format);
1768 kfree(pv4l2_pix_format);
1769 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1773 memset(pv4l2_pix_format, 0, sizeof(struct v4l2_pix_format));
1774 pv4l2_format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1775 memcpy(&pv4l2_format->fmt.pix,
1776 &easycap_format[peasycap->format_offset]
1777 .v4l2_format.fmt.pix, sizeof(struct v4l2_pix_format));
1778 JOM(8, "user is told: %s\n",
1779 &easycap_format[peasycap->format_offset].name[0]);
1781 if (copy_to_user((void __user *)arg, pv4l2_format,
1782 sizeof(struct v4l2_format))) {
1783 kfree(pv4l2_format);
1784 kfree(pv4l2_pix_format);
1785 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1788 kfree(pv4l2_format);
1789 kfree(pv4l2_pix_format);
1792 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1793 case VIDIOC_TRY_FMT:
1794 case VIDIOC_S_FMT: {
1795 struct v4l2_format v4l2_format;
1796 struct v4l2_pix_format v4l2_pix_format;
1800 if (VIDIOC_TRY_FMT == cmd) {
1801 JOM(8, "VIDIOC_TRY_FMT\n");
1804 JOM(8, "VIDIOC_S_FMT\n");
1808 if (0 != copy_from_user(&v4l2_format, (void __user *)arg,
1809 sizeof(struct v4l2_format))) {
1810 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1814 best_format = adjust_format(peasycap,
1815 v4l2_format.fmt.pix.width,
1816 v4l2_format.fmt.pix.height,
1817 v4l2_format.fmt.pix.pixelformat,
1818 v4l2_format.fmt.pix.field,
1820 if (0 > best_format) {
1821 if (-EBUSY == best_format) {
1822 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1825 JOM(8, "WARNING: adjust_format() returned %i\n", best_format);
1826 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1829 /*...........................................................................*/
1830 memset(&v4l2_pix_format, 0, sizeof(struct v4l2_pix_format));
1831 v4l2_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1833 memcpy(&(v4l2_format.fmt.pix),
1834 &(easycap_format[best_format].v4l2_format.fmt.pix),
1835 sizeof(v4l2_pix_format));
1836 JOM(8, "user is told: %s\n", &easycap_format[best_format].name[0]);
1838 if (copy_to_user((void __user *)arg, &v4l2_format,
1839 sizeof(struct v4l2_format))) {
1840 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1845 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1846 case VIDIOC_CROPCAP: {
1847 struct v4l2_cropcap v4l2_cropcap;
1849 JOM(8, "VIDIOC_CROPCAP\n");
1851 if (0 != copy_from_user(&v4l2_cropcap, (void __user *)arg,
1852 sizeof(struct v4l2_cropcap))) {
1853 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1857 if (v4l2_cropcap.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1858 JOM(8, "v4l2_cropcap.type != V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
1860 memset(&v4l2_cropcap, 0, sizeof(struct v4l2_cropcap));
1861 v4l2_cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1862 v4l2_cropcap.bounds.left = 0;
1863 v4l2_cropcap.bounds.top = 0;
1864 v4l2_cropcap.bounds.width = peasycap->width;
1865 v4l2_cropcap.bounds.height = peasycap->height;
1866 v4l2_cropcap.defrect.left = 0;
1867 v4l2_cropcap.defrect.top = 0;
1868 v4l2_cropcap.defrect.width = peasycap->width;
1869 v4l2_cropcap.defrect.height = peasycap->height;
1870 v4l2_cropcap.pixelaspect.numerator = 1;
1871 v4l2_cropcap.pixelaspect.denominator = 1;
1873 JOM(8, "user is told: %ix%i\n", peasycap->width, peasycap->height);
1875 if (copy_to_user((void __user *)arg, &v4l2_cropcap,
1876 sizeof(struct v4l2_cropcap))) {
1877 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1882 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1884 case VIDIOC_S_CROP: {
1885 JOM(8, "VIDIOC_G_CROP|VIDIOC_S_CROP unsupported\n");
1886 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1889 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1890 case VIDIOC_QUERYSTD: {
1891 JOM(8, "VIDIOC_QUERYSTD: "
1892 "EasyCAP is incapable of detecting standard\n");
1893 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1897 /*-------------------------------------------------------------------*/
1899 * THE MANIPULATIONS INVOLVING last0,last1,last2,last3
1900 * CONSTITUTE A WORKAROUND * FOR WHAT APPEARS TO BE
1901 * A BUG IN 64-BIT mplayer.
1902 * NOT NEEDED, BUT HOPEFULLY HARMLESS, FOR 32-BIT mplayer.
1904 /*------------------------------------------------------------------*/
1905 case VIDIOC_ENUMSTD: {
1906 int last0 = -1, last1 = -1, last2 = -1, last3 = -1;
1907 struct v4l2_standard v4l2_standard;
1909 struct easycap_standard const *peasycap_standard;
1911 JOM(8, "VIDIOC_ENUMSTD\n");
1913 if (0 != copy_from_user(&v4l2_standard, (void __user *)arg,
1914 sizeof(struct v4l2_standard))) {
1915 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1918 index = v4l2_standard.index;
1924 if ((index == last3) && (index == last2) &&
1925 (index == last1) && (index == last0)) {
1933 memset(&v4l2_standard, 0, sizeof(struct v4l2_standard));
1935 peasycap_standard = &easycap_standard[0];
1936 while (0xFFFF != peasycap_standard->mask) {
1937 if ((int)(peasycap_standard - &easycap_standard[0]) == index)
1939 peasycap_standard++;
1941 if (0xFFFF == peasycap_standard->mask) {
1942 JOM(8, "%i=index: exhausts standards\n", index);
1943 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1946 JOM(8, "%i=index: %s\n", index,
1947 &(peasycap_standard->v4l2_standard.name[0]));
1948 memcpy(&v4l2_standard, &(peasycap_standard->v4l2_standard),
1949 sizeof(struct v4l2_standard));
1951 v4l2_standard.index = index;
1953 if (copy_to_user((void __user *)arg, &v4l2_standard,
1954 sizeof(struct v4l2_standard))) {
1955 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1960 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1961 case VIDIOC_G_STD: {
1963 struct easycap_standard const *peasycap_standard;
1965 JOM(8, "VIDIOC_G_STD\n");
1967 if (0 > peasycap->standard_offset) {
1968 JOM(8, "%i=peasycap->standard_offset\n",
1969 peasycap->standard_offset);
1970 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1974 if (0 != copy_from_user(&std_id, (void __user *)arg,
1975 sizeof(v4l2_std_id))) {
1976 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1980 peasycap_standard = &easycap_standard[peasycap->standard_offset];
1981 std_id = peasycap_standard->v4l2_standard.id;
1983 JOM(8, "user is told: %s\n",
1984 &peasycap_standard->v4l2_standard.name[0]);
1986 if (copy_to_user((void __user *)arg, &std_id,
1987 sizeof(v4l2_std_id))) {
1988 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
1993 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1994 case VIDIOC_S_STD: {
1998 JOM(8, "VIDIOC_S_STD\n");
2000 if (0 != copy_from_user(&std_id, (void __user *)arg,
2001 sizeof(v4l2_std_id))) {
2002 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2006 JOM(8, "User requests standard: 0x%08X%08X\n",
2007 (int)((std_id & (((v4l2_std_id)0xFFFFFFFF) << 32)) >> 32),
2008 (int)(std_id & ((v4l2_std_id)0xFFFFFFFF)));
2010 rc = adjust_standard(peasycap, std_id);
2012 JOM(8, "WARNING: adjust_standard() returned %i\n", rc);
2013 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2018 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2019 case VIDIOC_REQBUFS: {
2021 struct v4l2_requestbuffers v4l2_requestbuffers;
2023 JOM(8, "VIDIOC_REQBUFS\n");
2025 if (0 != copy_from_user(&v4l2_requestbuffers,
2027 sizeof(struct v4l2_requestbuffers))) {
2028 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2032 if (v4l2_requestbuffers.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2033 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2036 if (v4l2_requestbuffers.memory != V4L2_MEMORY_MMAP) {
2037 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2040 nbuffers = v4l2_requestbuffers.count;
2041 JOM(8, " User requests %i buffers ...\n", nbuffers);
2044 if (nbuffers > FRAME_BUFFER_MANY)
2045 nbuffers = FRAME_BUFFER_MANY;
2046 if (v4l2_requestbuffers.count == nbuffers) {
2047 JOM(8, " ... agree to %i buffers\n",
2050 JOM(8, " ... insist on %i buffers\n",
2052 v4l2_requestbuffers.count = nbuffers;
2054 peasycap->frame_buffer_many = nbuffers;
2056 if (copy_to_user((void __user *)arg, &v4l2_requestbuffers,
2057 sizeof(struct v4l2_requestbuffers))) {
2058 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2063 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2064 case VIDIOC_QUERYBUF: {
2066 struct v4l2_buffer v4l2_buffer;
2068 JOM(8, "VIDIOC_QUERYBUF\n");
2070 if (peasycap->video_eof) {
2071 JOM(8, "returning -EIO because %i=video_eof\n",
2072 peasycap->video_eof);
2073 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2077 if (0 != copy_from_user(&v4l2_buffer, (void __user *)arg,
2078 sizeof(struct v4l2_buffer))) {
2079 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2083 if (v4l2_buffer.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2084 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2087 index = v4l2_buffer.index;
2088 if (index < 0 || index >= peasycap->frame_buffer_many)
2090 memset(&v4l2_buffer, 0, sizeof(struct v4l2_buffer));
2091 v4l2_buffer.index = index;
2092 v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2093 v4l2_buffer.bytesused = peasycap->frame_buffer_used;
2094 v4l2_buffer.flags = V4L2_BUF_FLAG_MAPPED |
2095 peasycap->done[index] |
2096 peasycap->queued[index];
2097 v4l2_buffer.field = V4L2_FIELD_NONE;
2098 v4l2_buffer.memory = V4L2_MEMORY_MMAP;
2099 v4l2_buffer.m.offset = index * FRAME_BUFFER_SIZE;
2100 v4l2_buffer.length = FRAME_BUFFER_SIZE;
2102 JOM(16, " %10i=index\n", v4l2_buffer.index);
2103 JOM(16, " 0x%08X=type\n", v4l2_buffer.type);
2104 JOM(16, " %10i=bytesused\n", v4l2_buffer.bytesused);
2105 JOM(16, " 0x%08X=flags\n", v4l2_buffer.flags);
2106 JOM(16, " %10i=field\n", v4l2_buffer.field);
2107 JOM(16, " %10li=timestamp.tv_usec\n",
2108 (long)v4l2_buffer.timestamp.tv_usec);
2109 JOM(16, " %10i=sequence\n", v4l2_buffer.sequence);
2110 JOM(16, " 0x%08X=memory\n", v4l2_buffer.memory);
2111 JOM(16, " %10i=m.offset\n", v4l2_buffer.m.offset);
2112 JOM(16, " %10i=length\n", v4l2_buffer.length);
2114 if (copy_to_user((void __user *)arg, &v4l2_buffer,
2115 sizeof(struct v4l2_buffer))) {
2116 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2121 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2123 struct v4l2_buffer v4l2_buffer;
2125 JOM(8, "VIDIOC_QBUF\n");
2127 if (0 != copy_from_user(&v4l2_buffer, (void __user *)arg,
2128 sizeof(struct v4l2_buffer))) {
2129 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2133 if (v4l2_buffer.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2134 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2137 if (v4l2_buffer.memory != V4L2_MEMORY_MMAP) {
2138 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2141 if (v4l2_buffer.index < 0 ||
2142 v4l2_buffer.index >= peasycap->frame_buffer_many) {
2143 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2146 v4l2_buffer.flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_QUEUED;
2148 peasycap->done[v4l2_buffer.index] = 0;
2149 peasycap->queued[v4l2_buffer.index] = V4L2_BUF_FLAG_QUEUED;
2151 if (copy_to_user((void __user *)arg, &v4l2_buffer,
2152 sizeof(struct v4l2_buffer))) {
2153 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2157 JOM(8, "..... user queueing frame buffer %i\n",
2158 (int)v4l2_buffer.index);
2160 peasycap->frame_lock = 0;
2164 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2167 struct timeval timeval, timeval2;
2169 struct v4l2_buffer v4l2_buffer;
2173 JOM(8, "VIDIOC_DQBUF\n");
2175 if ((peasycap->video_idle) || (peasycap->video_eof)) {
2176 JOM(8, "returning -EIO because "
2177 "%i=video_idle %i=video_eof\n",
2178 peasycap->video_idle, peasycap->video_eof);
2179 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2183 if (copy_from_user(&v4l2_buffer, (void __user *)arg,
2184 sizeof(struct v4l2_buffer))) {
2185 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2189 if (v4l2_buffer.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2190 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2194 if (peasycap->offerfields) {
2195 /*---------------------------------------------------*/
2197 * IN ITS 50 "fps" MODE tvtime SEEMS ALWAYS TO REQUEST
2200 /*---------------------------------------------------*/
2201 if (V4L2_FIELD_TOP == v4l2_buffer.field)
2202 JOM(8, "user wants V4L2_FIELD_TOP\n");
2203 else if (V4L2_FIELD_BOTTOM == v4l2_buffer.field)
2204 JOM(8, "user wants V4L2_FIELD_BOTTOM\n");
2205 else if (V4L2_FIELD_ANY == v4l2_buffer.field)
2206 JOM(8, "user wants V4L2_FIELD_ANY\n");
2208 JOM(8, "user wants V4L2_FIELD_...UNKNOWN: %i\n",
2212 if (!peasycap->video_isoc_streaming) {
2213 JOM(16, "returning -EIO because video urbs not streaming\n");
2214 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2217 /*-------------------------------------------------------------------*/
2219 * IF THE USER HAS PREVIOUSLY CALLED easycap_poll(),
2220 * AS DETERMINED BY FINDING
2221 * THE FLAG peasycap->polled SET, THERE MUST BE
2222 * NO FURTHER WAIT HERE. IN THIS
2223 * CASE, JUST CHOOSE THE FRAME INDICATED BY peasycap->frame_read
2225 /*-------------------------------------------------------------------*/
2227 if (!peasycap->polled) {
2229 rcdq = easycap_dqbuf(peasycap, 0);
2231 JOM(8, "returning -EIO because "
2232 "dqbuf() returned -EIO\n");
2233 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2236 } while (0 != rcdq);
2238 if (peasycap->video_eof) {
2239 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2243 if (V4L2_BUF_FLAG_DONE != peasycap->done[peasycap->frame_read]) {
2244 JOM(8, "V4L2_BUF_FLAG_DONE != 0x%08X\n",
2245 peasycap->done[peasycap->frame_read]);
2247 peasycap->polled = 0;
2249 if (!(peasycap->isequence % 10)) {
2250 for (i = 0; i < 179; i++)
2251 peasycap->merit[i] = peasycap->merit[i+1];
2252 peasycap->merit[179] = merit_saa(peasycap->pusb_device);
2254 for (i = 0; i < 180; i++)
2255 j += peasycap->merit[i];
2257 SAM("easycap driver shutting down "
2258 "on condition blue\n");
2259 peasycap->video_eof = 1;
2260 peasycap->audio_eof = 1;
2264 v4l2_buffer.index = peasycap->frame_read;
2265 v4l2_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2266 v4l2_buffer.bytesused = peasycap->frame_buffer_used;
2267 v4l2_buffer.flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_DONE;
2268 if (true == peasycap->offerfields)
2269 v4l2_buffer.field = V4L2_FIELD_BOTTOM;
2271 v4l2_buffer.field = V4L2_FIELD_NONE;
2272 do_gettimeofday(&timeval);
2275 v4l2_buffer.timestamp = timeval2;
2276 v4l2_buffer.sequence = peasycap->isequence++;
2277 v4l2_buffer.memory = V4L2_MEMORY_MMAP;
2278 v4l2_buffer.m.offset = v4l2_buffer.index * FRAME_BUFFER_SIZE;
2279 v4l2_buffer.length = FRAME_BUFFER_SIZE;
2281 JOM(16, " %10i=index\n", v4l2_buffer.index);
2282 JOM(16, " 0x%08X=type\n", v4l2_buffer.type);
2283 JOM(16, " %10i=bytesused\n", v4l2_buffer.bytesused);
2284 JOM(16, " 0x%08X=flags\n", v4l2_buffer.flags);
2285 JOM(16, " %10i=field\n", v4l2_buffer.field);
2286 JOM(16, " %10li=timestamp.tv_sec\n",
2287 (long)v4l2_buffer.timestamp.tv_sec);
2288 JOM(16, " %10li=timestamp.tv_usec\n",
2289 (long)v4l2_buffer.timestamp.tv_usec);
2290 JOM(16, " %10i=sequence\n", v4l2_buffer.sequence);
2291 JOM(16, " 0x%08X=memory\n", v4l2_buffer.memory);
2292 JOM(16, " %10i=m.offset\n", v4l2_buffer.m.offset);
2293 JOM(16, " %10i=length\n", v4l2_buffer.length);
2295 if (copy_to_user((void __user *)arg, &v4l2_buffer,
2296 sizeof(struct v4l2_buffer))) {
2297 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2301 input = peasycap->frame_buffer[peasycap->frame_read][0].input;
2303 JOM(8, "user is offered frame buffer %i, input %i\n",
2304 peasycap->frame_read, (0x07 & input));
2306 JOM(8, "user is offered frame buffer %i\n",
2307 peasycap->frame_read);
2309 peasycap->frame_lock = 1;
2310 JOM(8, "%i=peasycap->frame_fill\n", peasycap->frame_fill);
2311 if (peasycap->frame_read == peasycap->frame_fill) {
2312 if (peasycap->frame_lock) {
2313 JOM(8, "WORRY: filling frame buffer "
2314 "while offered to user\n");
2319 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2320 case VIDIOC_STREAMON: {
2323 JOM(8, "VIDIOC_STREAMON\n");
2325 peasycap->isequence = 0;
2326 for (i = 0; i < 180; i++)
2327 peasycap->merit[i] = 0;
2328 if (NULL == peasycap->pusb_device) {
2329 SAM("ERROR: peasycap->pusb_device is NULL\n");
2330 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2333 submit_video_urbs(peasycap);
2334 peasycap->video_idle = 0;
2335 peasycap->audio_idle = 0;
2336 peasycap->video_eof = 0;
2337 peasycap->audio_eof = 0;
2340 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2341 case VIDIOC_STREAMOFF: {
2342 JOM(8, "VIDIOC_STREAMOFF\n");
2344 if (NULL == peasycap->pusb_device) {
2345 SAM("ERROR: peasycap->pusb_device is NULL\n");
2346 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2350 peasycap->video_idle = 1;
2351 peasycap->audio_idle = 1;
2352 peasycap->timeval0.tv_sec = 0;
2353 /*---------------------------------------------------------------------------*/
2355 * IF THE WAIT QUEUES ARE NOT CLEARED IN RESPONSE TO THE STREAMOFF COMMAND
2356 * THE USERSPACE PROGRAM, E.G. mplayer, MAY HANG ON EXIT. BEWARE.
2358 /*---------------------------------------------------------------------------*/
2359 JOM(8, "calling wake_up on wq_video and wq_audio\n");
2360 wake_up_interruptible(&(peasycap->wq_video));
2361 #ifdef CONFIG_EASYCAP_OSS
2362 wake_up_interruptible(&(peasycap->wq_audio));
2365 if (NULL != peasycap->psubstream)
2366 snd_pcm_period_elapsed(peasycap->psubstream);
2367 #endif /* CONFIG_EASYCAP_OSS */
2368 /*---------------------------------------------------------------------------*/
2371 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2372 case VIDIOC_G_PARM: {
2373 struct v4l2_streamparm *pv4l2_streamparm;
2375 JOM(8, "VIDIOC_G_PARM\n");
2376 pv4l2_streamparm = kzalloc(sizeof(struct v4l2_streamparm), GFP_KERNEL);
2377 if (!pv4l2_streamparm) {
2378 SAM("ERROR: out of memory\n");
2379 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2382 if (copy_from_user(pv4l2_streamparm,
2383 (void __user *)arg, sizeof(struct v4l2_streamparm))) {
2384 kfree(pv4l2_streamparm);
2385 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2389 if (pv4l2_streamparm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2390 kfree(pv4l2_streamparm);
2391 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2394 pv4l2_streamparm->parm.capture.capability = 0;
2395 pv4l2_streamparm->parm.capture.capturemode = 0;
2396 pv4l2_streamparm->parm.capture.timeperframe.numerator = 1;
2398 if (peasycap->fps) {
2399 pv4l2_streamparm->parm.capture.timeperframe.
2400 denominator = peasycap->fps;
2402 if (true == peasycap->ntsc) {
2403 pv4l2_streamparm->parm.capture.timeperframe.
2406 pv4l2_streamparm->parm.capture.timeperframe.
2411 pv4l2_streamparm->parm.capture.readbuffers =
2412 peasycap->frame_buffer_many;
2413 pv4l2_streamparm->parm.capture.extendedmode = 0;
2414 if (copy_to_user((void __user *)arg,
2416 sizeof(struct v4l2_streamparm))) {
2417 kfree(pv4l2_streamparm);
2418 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2421 kfree(pv4l2_streamparm);
2424 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2425 case VIDIOC_S_PARM: {
2426 JOM(8, "VIDIOC_S_PARM unsupported\n");
2427 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2430 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2431 case VIDIOC_G_AUDIO: {
2432 JOM(8, "VIDIOC_G_AUDIO unsupported\n");
2433 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2436 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2437 case VIDIOC_S_AUDIO: {
2438 JOM(8, "VIDIOC_S_AUDIO unsupported\n");
2439 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2442 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2443 case VIDIOC_S_TUNER: {
2444 JOM(8, "VIDIOC_S_TUNER unsupported\n");
2445 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2448 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2451 case VIDIOC_OVERLAY: {
2452 JOM(8, "VIDIOC_G_FBUF|VIDIOC_S_FBUF|VIDIOC_OVERLAY unsupported\n");
2453 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2456 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2457 case VIDIOC_G_TUNER: {
2458 JOM(8, "VIDIOC_G_TUNER unsupported\n");
2459 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2462 case VIDIOC_G_FREQUENCY:
2463 case VIDIOC_S_FREQUENCY: {
2464 JOM(8, "VIDIOC_G_FREQUENCY|VIDIOC_S_FREQUENCY unsupported\n");
2465 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2468 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2470 JOM(8, "ERROR: unrecognized V4L2 IOCTL command: 0x%08X\n", cmd);
2471 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2472 return -ENOIOCTLCMD;
2475 mutex_unlock(&easycapdc60_dongle[kd].mutex_video);
2476 JOM(4, "unlocked easycapdc60_dongle[%i].mutex_video\n", kd);
2479 /*****************************************************************************/