drivers/staging/easycap/easycap.h

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