1 /***************************************************************************** 2 * * 3 * easycap.h * 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 /* 29 * THE FOLLOWING PARAMETERS ARE UNDEFINED: 30 * 31 * EASYCAP_DEBUG 32 * 33 * IF REQUIRED THEY MUST BE EXTERNALLY DEFINED, FOR EXAMPLE AS COMPILER 34 * OPTIONS. 35 */ 36 /*---------------------------------------------------------------------------*/ 37 38 #ifndef __EASYCAP_H__ 39 #define __EASYCAP_H__ 40 41 /*---------------------------------------------------------------------------*/ 42 /* 43 * THESE ARE NORMALLY DEFINED 44 */ 45 /*---------------------------------------------------------------------------*/ 46 #define PATIENCE 500 47 #define PERSEVERE 48 /*---------------------------------------------------------------------------*/ 49 /* 50 * THESE ARE FOR MAINTENANCE ONLY - NORMALLY UNDEFINED: 51 */ 52 /*---------------------------------------------------------------------------*/ 53 #undef EASYCAP_TESTCARD 54 /*---------------------------------------------------------------------------*/ 55 #include <linux/kernel.h> 56 #include <linux/errno.h> 57 #include <linux/init.h> 58 #include <linux/slab.h> 59 #include <linux/module.h> 60 #include <linux/kref.h> 61 #include <linux/usb.h> 62 #include <linux/uaccess.h> 63 64 #include <linux/i2c.h> 65 #include <linux/version.h> 66 #include <linux/workqueue.h> 67 #include <linux/poll.h> 68 #include <linux/mm.h> 69 #include <linux/fs.h> 70 #include <linux/delay.h> 71 #include <linux/types.h> 72 73 #ifndef CONFIG_EASYCAP_OSS 74 #include <linux/vmalloc.h> 75 #include <linux/sound.h> 76 #include <sound/core.h> 77 #include <sound/pcm.h> 78 #include <sound/pcm_params.h> 79 #include <sound/info.h> 80 #include <sound/initval.h> 81 #include <sound/control.h> 82 #endif /* !CONFIG_EASYCAP_OSS */ 83 #include <media/v4l2-dev.h> 84 #include <media/v4l2-device.h> 85 #include <linux/videodev2.h> 86 #include <linux/soundcard.h> 87 88 #ifndef PAGE_SIZE 89 #error "PAGE_SIZE not defined" 90 #endif /* PAGE_SIZE */ 91 92 /*---------------------------------------------------------------------------*/ 93 /* VENDOR, PRODUCT: Syntek Semiconductor Co., Ltd 94 * 95 * EITHER EasyCAP USB 2.0 Video Adapter with Audio, Model No. DC60 96 * with input cabling: AUDIO(L), AUDIO(R), CVBS, S-VIDEO. 97 * 98 * OR EasyCAP 4CHANNEL USB 2.0 DVR, Model No. EasyCAP002 99 * with input cabling: MICROPHONE, CVBS1, CVBS2, CVBS3, CVBS4. 100 */ 101 /*---------------------------------------------------------------------------*/ 102 #define USB_EASYCAP_VENDOR_ID 0x05e1 103 #define USB_EASYCAP_PRODUCT_ID 0x0408 104 105 #define EASYCAP_DRIVER_VERSION "0.9.01" 106 #define EASYCAP_DRIVER_DESCRIPTION "easycapdc60" 107 108 #define USB_SKEL_MINOR_BASE 192 109 #define DONGLE_MANY 8 110 #define INPUT_MANY 6 111 /*---------------------------------------------------------------------------*/ 112 /* 113 * DEFAULT LUMINANCE, CONTRAST, SATURATION AND HUE 114 */ 115 /*---------------------------------------------------------------------------*/ 116 #define SAA_0A_DEFAULT 0x7F 117 #define SAA_0B_DEFAULT 0x3F 118 #define SAA_0C_DEFAULT 0x2F 119 #define SAA_0D_DEFAULT 0x00 120 /*---------------------------------------------------------------------------*/ 121 /* 122 * VIDEO STREAMING PARAMETERS: 123 * USB 2.0 PROVIDES FOR HIGH-BANDWIDTH ENDPOINTS WITH AN UPPER LIMIT 124 * OF 3072 BYTES PER MICROFRAME for wMaxPacketSize. 125 */ 126 /*---------------------------------------------------------------------------*/ 127 #define VIDEO_ISOC_BUFFER_MANY 16 128 #define VIDEO_ISOC_ORDER 3 129 #define VIDEO_ISOC_FRAMESPERDESC ((unsigned int) 1 << VIDEO_ISOC_ORDER) 130 #define USB_2_0_MAXPACKETSIZE 3072 131 #if (USB_2_0_MAXPACKETSIZE > PAGE_SIZE) 132 #error video_isoc_buffer[.] will not be big enough 133 #endif 134 #define VIDEO_JUNK_TOLERATE VIDEO_ISOC_BUFFER_MANY 135 #define VIDEO_LOST_TOLERATE 50 136 /*---------------------------------------------------------------------------*/ 137 /* 138 * VIDEO BUFFERS 139 */ 140 /*---------------------------------------------------------------------------*/ 141 #define FIELD_BUFFER_SIZE (203 * PAGE_SIZE) 142 #define FRAME_BUFFER_SIZE (405 * PAGE_SIZE) 143 #define FIELD_BUFFER_MANY 4 144 #define FRAME_BUFFER_MANY 6 145 /*---------------------------------------------------------------------------*/ 146 /* 147 * AUDIO STREAMING PARAMETERS 148 */ 149 /*---------------------------------------------------------------------------*/ 150 #define AUDIO_ISOC_BUFFER_MANY 16 151 #define AUDIO_ISOC_ORDER 1 152 #define AUDIO_ISOC_FRAMESPERDESC 32 153 #define AUDIO_ISOC_BUFFER_SIZE (PAGE_SIZE << AUDIO_ISOC_ORDER) 154 /*---------------------------------------------------------------------------*/ 155 /* 156 * AUDIO BUFFERS 157 */ 158 /*---------------------------------------------------------------------------*/ 159 #define AUDIO_FRAGMENT_MANY 32 160 #define PAGES_PER_AUDIO_FRAGMENT 4 161 /*---------------------------------------------------------------------------*/ 162 /* 163 * IT IS ESSENTIAL THAT EVEN-NUMBERED STANDARDS ARE 25 FRAMES PER SECOND, 164 * ODD-NUMBERED STANDARDS ARE 30 FRAMES PER SECOND. 165 * THE NUMBERING OF STANDARDS MUST NOT BE CHANGED WITHOUT DUE CARE. NOT 166 * ONLY MUST THE PARAMETER 167 * STANDARD_MANY 168 * BE CHANGED TO CORRESPOND TO THE NEW NUMBER OF STANDARDS, BUT ALSO THE 169 * NUMBERING MUST REMAIN AN UNBROKEN ASCENDING SEQUENCE: DUMMY STANDARDS 170 * MAY NEED TO BE ADDED. APPROPRIATE CHANGES WILL ALWAYS BE REQUIRED IN 171 * ROUTINE fillin_formats() AND POSSIBLY ELSEWHERE. BEWARE. 172 */ 173 /*---------------------------------------------------------------------------*/ 174 #define PAL_BGHIN 0 175 #define PAL_Nc 2 176 #define SECAM 4 177 #define NTSC_N 6 178 #define NTSC_N_443 8 179 #define NTSC_M 1 180 #define NTSC_443 3 181 #define NTSC_M_JP 5 182 #define PAL_60 7 183 #define PAL_M 9 184 #define PAL_BGHIN_SLOW 10 185 #define PAL_Nc_SLOW 12 186 #define SECAM_SLOW 14 187 #define NTSC_N_SLOW 16 188 #define NTSC_N_443_SLOW 18 189 #define NTSC_M_SLOW 11 190 #define NTSC_443_SLOW 13 191 #define NTSC_M_JP_SLOW 15 192 #define PAL_60_SLOW 17 193 #define PAL_M_SLOW 19 194 #define STANDARD_MANY 20 195 /*---------------------------------------------------------------------------*/ 196 /* 197 * ENUMS 198 */ 199 /*---------------------------------------------------------------------------*/ 200 enum { 201 AT_720x576, 202 AT_704x576, 203 AT_640x480, 204 AT_720x480, 205 AT_360x288, 206 AT_320x240, 207 AT_360x240, 208 RESOLUTION_MANY 209 }; 210 enum { 211 FMT_UYVY, 212 FMT_YUY2, 213 FMT_RGB24, 214 FMT_RGB32, 215 FMT_BGR24, 216 FMT_BGR32, 217 PIXELFORMAT_MANY 218 }; 219 enum { 220 FIELD_NONE, 221 FIELD_INTERLACED, 222 INTERLACE_MANY 223 }; 224 #define SETTINGS_MANY (STANDARD_MANY * \ 225 RESOLUTION_MANY * \ 226 2 * \ 227 PIXELFORMAT_MANY * \ 228 INTERLACE_MANY) 229 /*---------------------------------------------------------------------------*/ 230 /* 231 * STRUCTURE DEFINITIONS 232 */ 233 /*---------------------------------------------------------------------------*/ 234 struct easycap_dongle { 235 struct easycap *peasycap; 236 struct mutex mutex_video; 237 struct mutex mutex_audio; 238 }; 239 /*---------------------------------------------------------------------------*/ 240 struct data_buffer { 241 struct list_head list_head; 242 void *pgo; 243 void *pto; 244 u16 kount; 245 u16 input; 246 }; 247 /*---------------------------------------------------------------------------*/ 248 struct data_urb { 249 struct list_head list_head; 250 struct urb *purb; 251 int isbuf; 252 int length; 253 }; 254 /*---------------------------------------------------------------------------*/ 255 struct easycap_standard { 256 u16 mask; 257 struct v4l2_standard v4l2_standard; 258 }; 259 struct easycap_format { 260 u16 mask; 261 char name[128]; 262 struct v4l2_format v4l2_format; 263 }; 264 struct inputset { 265 int input; 266 int input_ok; 267 int standard_offset; 268 int standard_offset_ok; 269 int format_offset; 270 int format_offset_ok; 271 int brightness; 272 int brightness_ok; 273 int contrast; 274 int contrast_ok; 275 int saturation; 276 int saturation_ok; 277 int hue; 278 int hue_ok; 279 }; 280 /*---------------------------------------------------------------------------*/ 281 /* 282 * easycap.ilk == 0 => CVBS+S-VIDEO HARDWARE, AUDIO wMaxPacketSize=256 283 * easycap.ilk == 2 => CVBS+S-VIDEO HARDWARE, AUDIO wMaxPacketSize=9 284 * easycap.ilk == 3 => FOUR-CVBS HARDWARE, AUDIO wMaxPacketSize=9 285 */ 286 /*---------------------------------------------------------------------------*/ 287 struct easycap { 288 #define TELLTALE "expectedstring" 289 char telltale[16]; 290 int isdongle; 291 int minor; 292 293 struct video_device video_device; 294 struct v4l2_device v4l2_device; 295 296 int status; 297 unsigned int audio_pages_per_fragment; 298 unsigned int audio_bytes_per_fragment; 299 unsigned int audio_buffer_page_many; 300 301 #define UPSAMPLE 302 #ifdef UPSAMPLE 303 s16 oldaudio; 304 #endif /*UPSAMPLE*/ 305 306 int ilk; 307 bool microphone; 308 309 struct usb_device *pusb_device; 310 struct usb_interface *pusb_interface; 311 312 struct kref kref; 313 314 int queued[FRAME_BUFFER_MANY]; 315 int done[FRAME_BUFFER_MANY]; 316 317 wait_queue_head_t wq_video; 318 wait_queue_head_t wq_audio; 319 wait_queue_head_t wq_trigger; 320 321 int input; 322 int polled; 323 int standard_offset; 324 int format_offset; 325 struct inputset inputset[INPUT_MANY]; 326 327 bool ntsc; 328 int fps; 329 int usec; 330 int tolerate; 331 int skip; 332 int skipped; 333 int lost[INPUT_MANY]; 334 int merit[180]; 335 336 struct timeval timeval0; 337 struct timeval timeval1; 338 struct timeval timeval2; 339 struct timeval timeval3; 340 struct timeval timeval6; 341 struct timeval timeval7; 342 struct timeval timeval8; 343 long long int dnbydt; 344 345 int video_interface; 346 int video_altsetting_on; 347 int video_altsetting_off; 348 int video_endpointnumber; 349 int video_isoc_maxframesize; 350 int video_isoc_buffer_size; 351 int video_isoc_framesperdesc; 352 353 int video_isoc_streaming; 354 int video_isoc_sequence; 355 int video_idle; 356 int video_eof; 357 int video_junk; 358 359 struct data_buffer video_isoc_buffer[VIDEO_ISOC_BUFFER_MANY]; 360 struct data_buffer field_buffer[FIELD_BUFFER_MANY] 361 [(FIELD_BUFFER_SIZE/PAGE_SIZE)]; 362 struct data_buffer frame_buffer[FRAME_BUFFER_MANY] 363 [(FRAME_BUFFER_SIZE/PAGE_SIZE)]; 364 365 struct list_head urb_video_head; 366 struct list_head *purb_video_head; 367 368 u8 cache[8]; 369 u8 *pcache; 370 int video_mt; 371 int audio_mt; 372 long long audio_bytes; 373 u32 isequence; 374 375 int vma_many; 376 /*---------------------------------------------------------------------------*/ 377 /* 378 * BUFFER INDICATORS 379 */ 380 /*---------------------------------------------------------------------------*/ 381 int field_fill; /* Field buffer being filled by easycap_complete(). */ 382 /* Bumped only by easycap_complete(). */ 383 int field_page; /* Page of field buffer page being filled by */ 384 /* easycap_complete(). */ 385 int field_read; /* Field buffer to be read by field2frame(). */ 386 /* Bumped only by easycap_complete(). */ 387 int frame_fill; /* Frame buffer being filled by field2frame(). */ 388 /* Bumped only by easycap_dqbuf() when */ 389 /* field2frame() has created a complete frame. */ 390 int frame_read; /* Frame buffer offered to user by DQBUF. */ 391 /* Set only by easycap_dqbuf() to trail frame_fill.*/ 392 int frame_lock; /* Flag set to 1 by DQBUF and cleared by QBUF */ 393 /*---------------------------------------------------------------------------*/ 394 /* 395 * IMAGE PROPERTIES 396 */ 397 /*---------------------------------------------------------------------------*/ 398 u32 pixelformat; 399 int width; 400 int height; 401 int bytesperpixel; 402 bool byteswaporder; 403 bool decimatepixel; 404 bool offerfields; 405 int frame_buffer_used; 406 int frame_buffer_many; 407 int videofieldamount; 408 409 int brightness; 410 int contrast; 411 int saturation; 412 int hue; 413 414 int allocation_video_urb; 415 int allocation_video_page; 416 int allocation_video_struct; 417 int registered_video; 418 /*---------------------------------------------------------------------------*/ 419 /* 420 * ALSA 421 */ 422 /*---------------------------------------------------------------------------*/ 423 #ifndef CONFIG_EASYCAP_OSS 424 struct snd_pcm_hardware alsa_hardware; 425 struct snd_card *psnd_card; 426 struct snd_pcm *psnd_pcm; 427 struct snd_pcm_substream *psubstream; 428 int dma_fill; 429 int dma_next; 430 int dma_read; 431 #endif /* !CONFIG_EASYCAP_OSS */ 432 /*---------------------------------------------------------------------------*/ 433 /* 434 * SOUND PROPERTIES 435 */ 436 /*---------------------------------------------------------------------------*/ 437 int audio_interface; 438 int audio_altsetting_on; 439 int audio_altsetting_off; 440 int audio_endpointnumber; 441 int audio_isoc_maxframesize; 442 int audio_isoc_buffer_size; 443 int audio_isoc_framesperdesc; 444 445 int audio_isoc_streaming; 446 int audio_idle; 447 int audio_eof; 448 int volume; 449 int mute; 450 s8 gain; 451 452 struct data_buffer audio_isoc_buffer[AUDIO_ISOC_BUFFER_MANY]; 453 454 struct list_head urb_audio_head; 455 struct list_head *purb_audio_head; 456 /*---------------------------------------------------------------------------*/ 457 /* 458 * BUFFER INDICATORS 459 */ 460 /*---------------------------------------------------------------------------*/ 461 int audio_fill; /* Audio buffer being filled by easycap_complete(). */ 462 /* Bumped only by easycap_complete(). */ 463 int audio_read; /* Audio buffer page being read by easycap_read(). */ 464 /* Set by easycap_read() to trail audio_fill by */ 465 /* one fragment. */ 466 /*---------------------------------------------------------------------------*/ 467 /* 468 * SOUND PROPERTIES 469 */ 470 /*---------------------------------------------------------------------------*/ 471 472 int audio_buffer_many; 473 474 int allocation_audio_urb; 475 int allocation_audio_page; 476 int allocation_audio_struct; 477 int registered_audio; 478 479 long long int audio_sample; 480 long long int audio_niveau; 481 long long int audio_square; 482 483 struct data_buffer audio_buffer[]; 484 }; 485 /*---------------------------------------------------------------------------*/ 486 /* 487 * VIDEO FUNCTION PROTOTYPES 488 */ 489 /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/ 490 long easycap_unlocked_ioctl(struct file *, unsigned int, unsigned long); 491 int easycap_dqbuf(struct easycap *, int); 492 int submit_video_urbs(struct easycap *); 493 int kill_video_urbs(struct easycap *); 494 int field2frame(struct easycap *); 495 int redaub(struct easycap *, void *, void *, 496 int, int, u8, u8, bool); 497 void easycap_testcard(struct easycap *, int); 498 int fillin_formats(void); 499 int newinput(struct easycap *, int); 500 int adjust_standard(struct easycap *, v4l2_std_id); 501 int adjust_format(struct easycap *, u32, u32, u32, 502 int, bool); 503 int adjust_brightness(struct easycap *, int); 504 int adjust_contrast(struct easycap *, int); 505 int adjust_saturation(struct easycap *, int); 506 int adjust_hue(struct easycap *, int); 507 int adjust_volume(struct easycap *, int); 508 /*---------------------------------------------------------------------------*/ 509 /* 510 * AUDIO FUNCTION PROTOTYPES 511 */ 512 /*---------------------------------------------------------------------------*/ 513 #ifndef CONFIG_EASYCAP_OSS 514 int easycap_alsa_probe(struct easycap *); 515 void easycap_alsa_complete(struct urb *); 516 #else /* CONFIG_EASYCAP_OSS */ 517 void easyoss_complete(struct urb *); 518 #endif /* !CONFIG_EASYCAP_OSS */ 519 520 int easycap_sound_setup(struct easycap *); 521 int submit_audio_urbs(struct easycap *); 522 int kill_audio_urbs(struct easycap *); 523 void easyoss_testtone(struct easycap *, int); 524 int audio_setup(struct easycap *); 525 /*---------------------------------------------------------------------------*/ 526 /* 527 * LOW-LEVEL FUNCTION PROTOTYPES 528 */ 529 /*---------------------------------------------------------------------------*/ 530 int audio_gainget(struct usb_device *); 531 int audio_gainset(struct usb_device *, s8); 532 533 int set_interface(struct usb_device *, u16); 534 int wakeup_device(struct usb_device *); 535 int confirm_resolution(struct usb_device *); 536 int confirm_stream(struct usb_device *); 537 538 int setup_stk(struct usb_device *, bool); 539 int setup_saa(struct usb_device *, bool); 540 int setup_vt(struct usb_device *); 541 int check_stk(struct usb_device *, bool); 542 int check_saa(struct usb_device *, bool); 543 int ready_saa(struct usb_device *); 544 int merit_saa(struct usb_device *); 545 int check_vt(struct usb_device *); 546 int select_input(struct usb_device *, int, int); 547 int set_resolution(struct usb_device *, 548 u16, u16, u16, u16); 549 550 int read_saa(struct usb_device *, u16); 551 int read_stk(struct usb_device *, u32); 552 int write_saa(struct usb_device *, u16, u16); 553 int write_000(struct usb_device *, u16, u16); 554 int start_100(struct usb_device *); 555 int stop_100(struct usb_device *); 556 int write_300(struct usb_device *); 557 int read_vt(struct usb_device *, u16); 558 int write_vt(struct usb_device *, u16, u16); 559 int isdongle(struct easycap *); 560 /*---------------------------------------------------------------------------*/ 561 struct signed_div_result { 562 long long int quotient; 563 unsigned long long int remainder; 564 } signed_div(long long int, long long int); 565 566 567 /*---------------------------------------------------------------------------*/ 568 /* 569 * MACROS SAM(...) AND JOM(...) ALLOW DIAGNOSTIC OUTPUT TO BE TAGGED WITH 570 * THE IDENTITY OF THE DONGLE TO WHICH IT APPLIES, BUT IF INVOKED WHEN THE 571 * POINTER peasycap IS INVALID AN Oops IS LIKELY, AND ITS CAUSE MAY NOT BE 572 * IMMEDIATELY OBVIOUS FROM A CASUAL READING OF THE SOURCE CODE. BEWARE. 573 */ 574 /*---------------------------------------------------------------------------*/ 575 const char *strerror(int err); 576 577 #define SAY(format, args...) do { \ 578 printk(KERN_DEBUG "easycap:: %s: " \ 579 format, __func__, ##args); \ 580 } while (0) 581 #define SAM(format, args...) do { \ 582 printk(KERN_DEBUG "easycap::%i%s: " \ 583 format, peasycap->isdongle, __func__, ##args);\ 584 } while (0) 585 586 #ifdef CONFIG_EASYCAP_DEBUG 587 extern int easycap_debug; 588 #define JOT(n, format, args...) do { \ 589 if (n <= easycap_debug) { \ 590 printk(KERN_DEBUG "easycap:: %s: " \ 591 format, __func__, ##args);\ 592 } \ 593 } while (0) 594 #define JOM(n, format, args...) do { \ 595 if (n <= easycap_debug) { \ 596 printk(KERN_DEBUG "easycap::%i%s: " \ 597 format, peasycap->isdongle, __func__, ##args);\ 598 } \ 599 } while (0) 600 601 #else 602 #define JOT(n, format, args...) do {} while (0) 603 #define JOM(n, format, args...) do {} while (0) 604 #endif /* CONFIG_EASYCAP_DEBUG */ 605 606 #define MICROSECONDS(X, Y) \ 607 ((1000000*((long long int)(X.tv_sec - Y.tv_sec))) + \ 608 (long long int)(X.tv_usec - Y.tv_usec)) 609 610 /*---------------------------------------------------------------------------*/ 611 /* 612 * (unsigned char *)P pointer to next byte pair 613 * (long int *)X pointer to accumulating count 614 * (long int *)Y pointer to accumulating sum 615 * (long long int *)Z pointer to accumulating sum of squares 616 */ 617 /*---------------------------------------------------------------------------*/ 618 #define SUMMER(P, X, Y, Z) do { \ 619 unsigned char *p; \ 620 unsigned int u0, u1, u2; \ 621 long int s; \ 622 p = (unsigned char *)(P); \ 623 u0 = (unsigned int) (*p); \ 624 u1 = (unsigned int) (*(p + 1)); \ 625 u2 = (unsigned int) ((u1 << 8) | u0); \ 626 if (0x8000 & u2) \ 627 s = -(long int)(0x7FFF & (~u2)); \ 628 else \ 629 s = (long int)(0x7FFF & u2); \ 630 *((X)) += (long int) 1; \ 631 *((Y)) += (long int) s; \ 632 *((Z)) += ((long long int)(s) * (long long int)(s)); \ 633 } while (0) 634 /*---------------------------------------------------------------------------*/ 635 636 /*---------------------------------------------------------------------------*/ 637 /* globals 638 */ 639 /*---------------------------------------------------------------------------*/ 640 641 extern bool easycap_readback; 642 extern const struct easycap_standard easycap_standard[]; 643 extern struct easycap_format easycap_format[]; 644 extern struct v4l2_queryctrl easycap_control[]; 645 extern struct usb_driver easycap_usb_driver; 646 extern struct easycap_dongle easycapdc60_dongle[]; 647 #ifdef CONFIG_EASYCAP_OSS 648 extern struct usb_class_driver easyoss_class; 649 #endif /* !CONFIG_EASYCAP_OSS */ 650 651 #endif /* !__EASYCAP_H__ */ 652