drivers/staging/media/easycap/easycap_low.c

   1 /*****************************************************************************
   2 *                                                                            *
   3 *                                                                            *
   4 *  easycap_low.c                                                             *
   5 *                                                                            *
   6 *                                                                            *
   7 *****************************************************************************/
   8 /*
   9  *
  10  *  Copyright (C) 2010 R.M. Thomas  <rmthomas@sciolus.org>
  11  *
  12  *
  13  *  This is free software; you can redistribute it and/or modify
  14  *  it under the terms of the GNU General Public License as published by
  15  *  the Free Software Foundation; either version 2 of the License, or
  16  *  (at your option) any later version.
  17  *
  18  *  The software is distributed in the hope that it will be useful,
  19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *  GNU General Public License for more details.
  22  *
  23  *  You should have received a copy of the GNU General Public License
  24  *  along with this software; if not, write to the Free Software
  25  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26  *
  27 */
  28 /*****************************************************************************/
  29 /*
  30  *  ACKNOWLEGEMENTS AND REFERENCES
  31  *  ------------------------------
  32  *  This driver makes use of register information contained in the Syntek
  33  *  Semicon DC-1125 driver hosted at
  34  *               http://sourceforge.net/projects/syntekdriver/.
  35  *  Particularly useful has been a patch to the latter driver provided by
  36  *  Ivor Hewitt in January 2009.  The NTSC implementation is taken from the
  37  *  work of Ben Trask.
  38 */
  39 /****************************************************************************/
  40
  41 #include "easycap.h"
  42
  43
  44 #define GET(X, Y, Z) do { \
  45         int __rc; \
  46         *(Z) = (u16)0; \
  47         __rc = regget(X, Y, Z, sizeof(u8)); \
  48         if (0 > __rc) { \
  49                 JOT(8, ":-(%i\n", __LINE__);  return __rc; \
  50         } \
  51 } while (0)
  52
  53 #define SET(X, Y, Z) do { \
  54         int __rc; \
  55         __rc = regset(X, Y, Z); \
  56         if (0 > __rc) { \
  57                 JOT(8, ":-(%i\n", __LINE__);  return __rc; \
  58         } \
  59 } while (0)
  60
  61 /*--------------------------------------------------------------------------*/
  62 static const struct stk1160config {
  63         u16 reg;
  64         u16 set;
  65 } stk1160configPAL[] = {
  66                 {0x000, 0x0098},
  67                 {0x002, 0x0093},
  68
  69                 {0x001, 0x0003},
  70                 {0x003, 0x0080},
  71                 {0x00D, 0x0000},
  72                 {0x00F, 0x0002},
  73                 {0x018, 0x0010},
  74                 {0x019, 0x0000},
  75                 {0x01A, 0x0014},
  76                 {0x01B, 0x000E},
  77                 {0x01C, 0x0046},
  78
  79                 {0x100, 0x0033},
  80                 {0x103, 0x0000},
  81                 {0x104, 0x0000},
  82                 {0x105, 0x0000},
  83                 {0x106, 0x0000},
  84
  85 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  86 /*
  87  *  RESOLUTION 640x480
  88 */
  89 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  90                 {0x110, 0x0008},
  91                 {0x111, 0x0000},
  92                 {0x112, 0x0020},
  93                 {0x113, 0x0000},
  94                 {0x114, 0x0508},
  95                 {0x115, 0x0005},
  96                 {0x116, 0x0110},
  97                 {0x117, 0x0001},
  98 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  99
 100                 {0x202, 0x000F},
 101                 {0x203, 0x004A},
 102                 {0x2FF, 0x0000},
 103
 104                 {0xFFF, 0xFFFF}
 105 };
 106 /*--------------------------------------------------------------------------*/
 107 static const struct stk1160config stk1160configNTSC[] = {
 108                 {0x000, 0x0098},
 109                 {0x002, 0x0093},
 110
 111                 {0x001, 0x0003},
 112                 {0x003, 0x0080},
 113                 {0x00D, 0x0000},
 114                 {0x00F, 0x0002},
 115                 {0x018, 0x0010},
 116                 {0x019, 0x0000},
 117                 {0x01A, 0x0014},
 118                 {0x01B, 0x000E},
 119                 {0x01C, 0x0046},
 120
 121                 {0x100, 0x0033},
 122                 {0x103, 0x0000},
 123                 {0x104, 0x0000},
 124                 {0x105, 0x0000},
 125                 {0x106, 0x0000},
 126
 127 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 128 /*
 129  *  RESOLUTION 640x480
 130 */
 131 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 132                 {0x110, 0x0008},
 133                 {0x111, 0x0000},
 134                 {0x112, 0x0003},
 135                 {0x113, 0x0000},
 136                 {0x114, 0x0508},
 137                 {0x115, 0x0005},
 138                 {0x116, 0x00F3},
 139                 {0x117, 0x0000},
 140 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 141
 142                 {0x202, 0x000F},
 143                 {0x203, 0x004A},
 144                 {0x2FF, 0x0000},
 145
 146                 {0xFFF, 0xFFFF}
 147 };
 148 /*--------------------------------------------------------------------------*/
 149 static const struct saa7113config {
 150         u8 reg;
 151         u8 set;
 152 } saa7113configPAL[] = {
 153                 {0x01, 0x08},
 154                 {0x02, 0x80},
 155                 {0x03, 0x33},
 156                 {0x04, 0x00},
 157                 {0x05, 0x00},
 158                 {0x06, 0xE9},
 159                 {0x07, 0x0D},
 160                 {0x08, 0x38},
 161                 {0x09, 0x00},
 162                 {0x0A, SAA_0A_DEFAULT},
 163                 {0x0B, SAA_0B_DEFAULT},
 164                 {0x0C, SAA_0C_DEFAULT},
 165                 {0x0D, SAA_0D_DEFAULT},
 166                 {0x0E, 0x01},
 167                 {0x0F, 0x36},
 168                 {0x10, 0x00},
 169                 {0x11, 0x0C},
 170                 {0x12, 0xE7},
 171                 {0x13, 0x00},
 172                 {0x15, 0x00},
 173                 {0x16, 0x00},
 174                 {0x40, 0x02},
 175                 {0x41, 0xFF},
 176                 {0x42, 0xFF},
 177                 {0x43, 0xFF},
 178                 {0x44, 0xFF},
 179                 {0x45, 0xFF},
 180                 {0x46, 0xFF},
 181                 {0x47, 0xFF},
 182                 {0x48, 0xFF},
 183                 {0x49, 0xFF},
 184                 {0x4A, 0xFF},
 185                 {0x4B, 0xFF},
 186                 {0x4C, 0xFF},
 187                 {0x4D, 0xFF},
 188                 {0x4E, 0xFF},
 189                 {0x4F, 0xFF},
 190                 {0x50, 0xFF},
 191                 {0x51, 0xFF},
 192                 {0x52, 0xFF},
 193                 {0x53, 0xFF},
 194                 {0x54, 0xFF},
 195                 {0x55, 0xFF},
 196                 {0x56, 0xFF},
 197                 {0x57, 0xFF},
 198                 {0x58, 0x40},
 199                 {0x59, 0x54},
 200                 {0x5A, 0x07},
 201                 {0x5B, 0x83},
 202
 203                 {0xFF, 0xFF}
 204 };
 205 /*--------------------------------------------------------------------------*/
 206 static const struct saa7113config saa7113configNTSC[] = {
 207                 {0x01, 0x08},
 208                 {0x02, 0x80},
 209                 {0x03, 0x33},
 210                 {0x04, 0x00},
 211                 {0x05, 0x00},
 212                 {0x06, 0xE9},
 213                 {0x07, 0x0D},
 214                 {0x08, 0x78},
 215                 {0x09, 0x00},
 216                 {0x0A, SAA_0A_DEFAULT},
 217                 {0x0B, SAA_0B_DEFAULT},
 218                 {0x0C, SAA_0C_DEFAULT},
 219                 {0x0D, SAA_0D_DEFAULT},
 220                 {0x0E, 0x01},
 221                 {0x0F, 0x36},
 222                 {0x10, 0x00},
 223                 {0x11, 0x0C},
 224                 {0x12, 0xE7},
 225                 {0x13, 0x00},
 226                 {0x15, 0x00},
 227                 {0x16, 0x00},
 228                 {0x40, 0x82},
 229                 {0x41, 0xFF},
 230                 {0x42, 0xFF},
 231                 {0x43, 0xFF},
 232                 {0x44, 0xFF},
 233                 {0x45, 0xFF},
 234                 {0x46, 0xFF},
 235                 {0x47, 0xFF},
 236                 {0x48, 0xFF},
 237                 {0x49, 0xFF},
 238                 {0x4A, 0xFF},
 239                 {0x4B, 0xFF},
 240                 {0x4C, 0xFF},
 241                 {0x4D, 0xFF},
 242                 {0x4E, 0xFF},
 243                 {0x4F, 0xFF},
 244                 {0x50, 0xFF},
 245                 {0x51, 0xFF},
 246                 {0x52, 0xFF},
 247                 {0x53, 0xFF},
 248                 {0x54, 0xFF},
 249                 {0x55, 0xFF},
 250                 {0x56, 0xFF},
 251                 {0x57, 0xFF},
 252                 {0x58, 0x40},
 253                 {0x59, 0x54},
 254                 {0x5A, 0x0A},
 255                 {0x5B, 0x83},
 256
 257                 {0xFF, 0xFF}
 258 };
 259
 260 static int regget(struct usb_device *pusb_device,
 261                 u16 index, void *reg, int reg_size)
 262 {
 263         int rc;
 264
 265         if (!pusb_device)
 266                 return -ENODEV;
 267
 268         rc = usb_control_msg(pusb_device, usb_rcvctrlpipe(pusb_device, 0),
 269                         0x00,
 270                         (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE),
 271                         0x00,
 272                         index, reg, reg_size, 50000);
 273
 274         return rc;
 275 }
 276
 277 static int regset(struct usb_device *pusb_device, u16 index, u16 value)
 278 {
 279         int rc;
 280
 281         if (!pusb_device)
 282                 return -ENODEV;
 283
 284         rc = usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0),
 285                         0x01,
 286                         (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE),
 287                         value, index, NULL, 0, 500);
 288
 289         if (rc < 0)
 290                 return rc;
 291
 292         if (easycap_readback) {
 293                 u16 igot = 0;
 294                 rc = regget(pusb_device, index, &igot, sizeof(igot));
 295                 igot = 0xFF & igot;
 296                 switch (index) {
 297                 case 0x000:
 298                 case 0x500:
 299                 case 0x502:
 300                 case 0x503:
 301                 case 0x504:
 302                 case 0x506:
 303                 case 0x507:
 304                         break;
 305
 306                 case 0x204:
 307                 case 0x205:
 308                 case 0x350:
 309                 case 0x351:
 310                         if (igot)
 311                                 JOT(8, "unexpected 0x%02X "
 312                                         "for STK register 0x%03X\n",
 313                                         igot, index);
 314                         break;
 315
 316                 default:
 317                         if ((0xFF & value) != igot)
 318                                 JOT(8, "unexpected 0x%02X != 0x%02X "
 319                                         "for STK register 0x%03X\n",
 320                                                 igot, value, index);
 321                         break;
 322                 }
 323         }
 324
 325         return rc;
 326 }
 327 /*--------------------------------------------------------------------------*/
 328 /*
 329  *  FUNCTION wait_i2c() RETURNS 0 ON SUCCESS
 330 */
 331 /*--------------------------------------------------------------------------*/
 332 static int wait_i2c(struct usb_device *p)
 333 {
 334         u16 get0;
 335         u8 igot;
 336         const int max = 2;
 337         int k;
 338
 339         if (!p)
 340                 return -ENODEV;
 341
 342         for (k = 0;  k < max;  k++) {
 343                 GET(p, 0x0201, &igot);  get0 = igot;
 344                 switch (get0) {
 345                 case 0x04:
 346                 case 0x01:
 347                         return 0;
 348                 case 0x00:
 349                         msleep(20);
 350                         continue;
 351                 default:
 352                         return get0 - 1;
 353                 }
 354         }
 355         return -1;
 356 }
 357
 358 /****************************************************************************/
 359 int write_saa(struct usb_device *p, u16 reg0, u16 set0)
 360 {
 361         if (!p)
 362                 return -ENODEV;
 363         SET(p, 0x200, 0x00);
 364         SET(p, 0x204, reg0);
 365         SET(p, 0x205, set0);
 366         SET(p, 0x200, 0x01);
 367         return wait_i2c(p);
 368 }
 369 /****************************************************************************/
 370 /*--------------------------------------------------------------------------*/
 371 /*
 372  *  REGISTER 500:  SETTING VALUE TO 0x008B READS FROM VT1612A (?)
 373  *  REGISTER 500:  SETTING VALUE TO 0x008C WRITES TO  VT1612A
 374  *  REGISTER 502:  LEAST SIGNIFICANT BYTE OF VALUE TO SET
 375  *  REGISTER 503:  MOST SIGNIFICANT BYTE OF VALUE TO SET
 376  *  REGISTER 504:  TARGET ADDRESS ON VT1612A
 377  */
 378 /*--------------------------------------------------------------------------*/
 379 static int write_vt(struct usb_device *p, u16 reg0, u16 set0)
 380 {
 381         u8 igot;
 382         u16 got502, got503;
 383         u16 set502, set503;
 384
 385         if (!p)
 386                 return -ENODEV;
 387         SET(p, 0x0504, reg0);
 388         SET(p, 0x0500, 0x008B);
 389
 390         GET(p, 0x0502, &igot);  got502 = (0xFF & igot);
 391         GET(p, 0x0503, &igot);  got503 = (0xFF & igot);
 392
 393         JOT(16, "write_vt(., 0x%04X, 0x%04X): was 0x%04X\n",
 394                                 reg0, set0, ((got503 << 8) | got502));
 395
 396         set502 =  (0x00FF & set0);
 397         set503 = ((0xFF00 & set0) >> 8);
 398
 399         SET(p, 0x0504, reg0);
 400         SET(p, 0x0502, set502);
 401         SET(p, 0x0503, set503);
 402         SET(p, 0x0500, 0x008C);
 403
 404         return 0;
 405 }
 406 /****************************************************************************/
 407 /*--------------------------------------------------------------------------*/
 408 /*
 409  *  REGISTER 500:  SETTING VALUE TO 0x008B READS FROM VT1612A (?)
 410  *  REGISTER 500:  SETTING VALUE TO 0x008C WRITES TO  VT1612A
 411  *  REGISTER 502:  LEAST SIGNIFICANT BYTE OF VALUE TO GET
 412  *  REGISTER 503:  MOST SIGNIFICANT BYTE OF VALUE TO GET
 413  *  REGISTER 504:  TARGET ADDRESS ON VT1612A
 414  */
 415 /*--------------------------------------------------------------------------*/
 416 static int read_vt(struct usb_device *p, u16 reg0)
 417 {
 418         u8 igot;
 419         u16 got502, got503;
 420
 421         if (!p)
 422                 return -ENODEV;
 423         SET(p, 0x0504, reg0);
 424         SET(p, 0x0500, 0x008B);
 425
 426         GET(p, 0x0502, &igot);  got502 = (0xFF & igot);
 427         GET(p, 0x0503, &igot);  got503 = (0xFF & igot);
 428
 429         JOT(16, "read_vt(., 0x%04X): has 0x%04X\n",
 430                         reg0, ((got503 << 8) | got502));
 431
 432         return (got503 << 8) | got502;
 433 }
 434 /****************************************************************************/
 435 /*--------------------------------------------------------------------------*/
 436 /*
 437  *  THESE APPEAR TO HAVE NO EFFECT ON EITHER VIDEO OR AUDIO.
 438  */
 439 /*--------------------------------------------------------------------------*/
 440 static int write_300(struct usb_device *p)
 441 {
 442         if (!p)
 443                 return -ENODEV;
 444         SET(p, 0x300, 0x0012);
 445         SET(p, 0x350, 0x002D);
 446         SET(p, 0x351, 0x0001);
 447         SET(p, 0x352, 0x0000);
 448         SET(p, 0x353, 0x0000);
 449         SET(p, 0x300, 0x0080);
 450         return 0;
 451 }
 452 /****************************************************************************/
 453 /****************************************************************************/
 454 int setup_stk(struct usb_device *p, bool ntsc)
 455 {
 456         int i;
 457         const struct stk1160config *cfg;
 458         if (!p)
 459                 return -ENODEV;
 460         cfg = (ntsc) ? stk1160configNTSC : stk1160configPAL;
 461         for (i = 0; cfg[i].reg != 0xFFF; i++)
 462                 SET(p, cfg[i].reg, cfg[i].set);
 463
 464         write_300(p);
 465
 466         return 0;
 467 }
 468 /****************************************************************************/
 469 int setup_saa(struct usb_device *p, bool ntsc)
 470 {
 471         int i, rc;
 472         const struct saa7113config *cfg;
 473         if (!p)
 474                 return -ENODEV;
 475         cfg = (ntsc) ?  saa7113configNTSC : saa7113configPAL;
 476         for (i = 0; cfg[i].reg != 0xFF; i++) {
 477                 rc = write_saa(p, cfg[i].reg, cfg[i].set);
 478                 if (rc)
 479                         dev_err(&p->dev,
 480                                 "Failed to set SAA register %d", cfg[i].reg);
 481         }
 482         return 0;
 483 }
 484 /****************************************************************************/
 485 int merit_saa(struct usb_device *p)
 486 {
 487         int rc;
 488
 489         if (!p)
 490                 return -ENODEV;
 491         rc = read_saa(p, 0x1F);
 492         return ((0 > rc) || (0x02 & rc)) ? 1 : 0;
 493 }
 494 /****************************************************************************/
 495 int ready_saa(struct usb_device *p)
 496 {
 497         int j, rc, rate;
 498         const int max = 5, marktime = PATIENCE/5;
 499 /*--------------------------------------------------------------------------*/
 500 /*
 501  *   RETURNS    0     FOR INTERLACED       50 Hz
 502  *              1     FOR NON-INTERLACED   50 Hz
 503  *              2     FOR INTERLACED       60 Hz
 504  *              3     FOR NON-INTERLACED   60 Hz
 505 */
 506 /*--------------------------------------------------------------------------*/
 507         if (!p)
 508                 return -ENODEV;
 509         j = 0;
 510         while (max > j) {
 511                 rc = read_saa(p, 0x1F);
 512                 if (0 <= rc) {
 513                         if (0 == (0x40 & rc))
 514                                 break;
 515                         if (1 == (0x01 & rc))
 516                                 break;
 517                 }
 518                 msleep(marktime);
 519                 j++;
 520         }
 521
 522         if (max == j)
 523                 return -1;
 524
 525         if (0x20 & rc) {
 526                 rate = 2;
 527                 JOT(8, "hardware detects 60 Hz\n");
 528         } else {
 529                 rate = 0;
 530                 JOT(8, "hardware detects 50 Hz\n");
 531         }
 532         if (0x80 & rc)
 533                 JOT(8, "hardware detects interlacing\n");
 534         else {
 535                 rate++;
 536                 JOT(8, "hardware detects no interlacing\n");
 537         }
 538         return 0;
 539 }
 540 /****************************************************************************/
 541 int read_saa(struct usb_device *p, u16 reg0)
 542 {
 543         u8 igot;
 544
 545         if (!p)
 546                 return -ENODEV;
 547         SET(p, 0x208, reg0);
 548         SET(p, 0x200, 0x20);
 549         if (0 != wait_i2c(p))
 550                 return -1;
 551         igot = 0;
 552         GET(p, 0x0209, &igot);
 553         return igot;
 554 }
 555 /****************************************************************************/
 556 static int read_stk(struct usb_device *p, u32 reg0)
 557 {
 558         u8 igot;
 559
 560         if (!p)
 561                 return -ENODEV;
 562         igot = 0;
 563         GET(p, reg0, &igot);
 564         return igot;
 565 }
 566 int select_input(struct usb_device *p, int input, int mode)
 567 {
 568         int ir;
 569
 570         if (!p)
 571                 return -ENODEV;
 572         stop_100(p);
 573         switch (input) {
 574         case 0:
 575         case 1: {
 576                 if (0 != write_saa(p, 0x02, 0x80))
 577                         SAY("ERROR: failed to set SAA register 0x02 "
 578                                                 "for input %i\n", input);
 579
 580                 SET(p, 0x0000, 0x0098);
 581                 SET(p, 0x0002, 0x0078);
 582                 break;
 583         }
 584         case 2: {
 585                 if (0 != write_saa(p, 0x02, 0x80))
 586                         SAY("ERROR: failed to set SAA register 0x02 "
 587                                                 "for input %i\n", input);
 588
 589                 SET(p, 0x0000, 0x0090);
 590                 SET(p, 0x0002, 0x0078);
 591                 break;
 592         }
 593         case 3: {
 594                 if (0 != write_saa(p, 0x02, 0x80))
 595                         SAY("ERROR: failed to set SAA register 0x02 "
 596                                         " for input %i\n", input);
 597
 598                 SET(p, 0x0000, 0x0088);
 599                 SET(p, 0x0002, 0x0078);
 600                 break;
 601         }
 602         case 4: {
 603                 if (0 != write_saa(p, 0x02, 0x80)) {
 604                         SAY("ERROR: failed to set SAA register 0x02 "
 605                                                 "for input %i\n", input);
 606                 }
 607                 SET(p, 0x0000, 0x0080);
 608                 SET(p, 0x0002, 0x0078);
 609                 break;
 610         }
 611         case 5: {
 612                 if (9 != mode)
 613                         mode = 7;
 614                 switch (mode) {
 615                 case 7: {
 616                         if (0 != write_saa(p, 0x02, 0x87))
 617                                 SAY("ERROR: failed to set SAA register 0x02 "
 618                                                 "for input %i\n", input);
 619
 620                         if (0 != write_saa(p, 0x05, 0xFF))
 621                                 SAY("ERROR: failed to set SAA register 0x05 "
 622                                                 "for input %i\n", input);
 623
 624                         break;
 625                 }
 626                 case 9: {
 627                         if (0 != write_saa(p, 0x02, 0x89))
 628                                 SAY("ERROR: failed to set SAA register 0x02 "
 629                                                 "for input %i\n", input);
 630
 631                         if (0 != write_saa(p, 0x05, 0x00))
 632                                 SAY("ERROR: failed to set SAA register 0x05 "
 633                                                 "for input %i\n", input);
 634
 635                         break;
 636                 }
 637                 default:
 638                         SAY("MISTAKE:  bad mode: %i\n", mode);
 639                         return -1;
 640                 }
 641
 642                 if (0 != write_saa(p, 0x04, 0x00))
 643                         SAY("ERROR: failed to set SAA register 0x04 "
 644                                         "for input %i\n", input);
 645
 646                 if (0 != write_saa(p, 0x09, 0x80))
 647                         SAY("ERROR: failed to set SAA register 0x09 "
 648                                                 "for input %i\n", input);
 649
 650                 SET(p, 0x0002, 0x0093);
 651                 break;
 652         }
 653         default:
 654                 SAY("ERROR:  bad input: %i\n", input);
 655                 return -1;
 656         }
 657
 658         ir = read_stk(p, 0x00);
 659         JOT(8, "STK register 0x00 has 0x%02X\n", ir);
 660         ir = read_saa(p, 0x02);
 661         JOT(8, "SAA register 0x02 has 0x%02X\n", ir);
 662
 663         start_100(p);
 664
 665         return 0;
 666 }
 667 /****************************************************************************/
 668 int set_resolution(struct usb_device *p,
 669                    u16 set0, u16 set1, u16 set2, u16 set3)
 670 {
 671         u16 u0x0111, u0x0113, u0x0115, u0x0117;
 672
 673         if (!p)
 674                 return -ENODEV;
 675         u0x0111 = ((0xFF00 & set0) >> 8);
 676         u0x0113 = ((0xFF00 & set1) >> 8);
 677         u0x0115 = ((0xFF00 & set2) >> 8);
 678         u0x0117 = ((0xFF00 & set3) >> 8);
 679
 680         SET(p, 0x0110, (0x00FF & set0));
 681         SET(p, 0x0111, u0x0111);
 682         SET(p, 0x0112, (0x00FF & set1));
 683         SET(p, 0x0113, u0x0113);
 684         SET(p, 0x0114, (0x00FF & set2));
 685         SET(p, 0x0115, u0x0115);
 686         SET(p, 0x0116, (0x00FF & set3));
 687         SET(p, 0x0117, u0x0117);
 688
 689         return 0;
 690 }
 691 /****************************************************************************/
 692 int start_100(struct usb_device *p)
 693 {
 694         u16 get116, get117, get0;
 695         u8 igot116, igot117, igot;
 696
 697         if (!p)
 698                 return -ENODEV;
 699         GET(p, 0x0116, &igot116);
 700         get116 = igot116;
 701         GET(p, 0x0117, &igot117);
 702         get117 = igot117;
 703         SET(p, 0x0116, 0x0000);
 704         SET(p, 0x0117, 0x0000);
 705
 706         GET(p, 0x0100, &igot);
 707         get0 = igot;
 708         SET(p, 0x0100, (0x80 | get0));
 709
 710         SET(p, 0x0116, get116);
 711         SET(p, 0x0117, get117);
 712
 713         return 0;
 714 }
 715 /****************************************************************************/
 716 int stop_100(struct usb_device *p)
 717 {
 718         u16 get0;
 719         u8 igot;
 720
 721         if (!p)
 722                 return -ENODEV;
 723         GET(p, 0x0100, &igot);
 724         get0 = igot;
 725         SET(p, 0x0100, (0x7F & get0));
 726         return 0;
 727 }
 728 /****************************************************************************/
 729 /****************************************************************************/
 730 /*****************************************************************************/
 731 int easycap_wakeup_device(struct usb_device *pusb_device)
 732 {
 733         if (!pusb_device)
 734                 return -ENODEV;
 735
 736         return usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0),
 737                         USB_REQ_SET_FEATURE,
 738                         USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
 739                         USB_DEVICE_REMOTE_WAKEUP,
 740                         0, NULL, 0, 50000);
 741 }
 742 /*****************************************************************************/
 743 int easycap_audio_setup(struct easycap *peasycap)
 744 {
 745         struct usb_device *pusb_device;
 746         u8 buffer[1];
 747         int rc, id1, id2;
 748 /*---------------------------------------------------------------------------*/
 749 /*
 750  *                                IMPORTANT:
 751  *  THE MESSAGE OF TYPE (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE)
 752  *  CAUSES MUTING IF THE VALUE 0x0100 IS SENT.
 753  *  TO ENABLE AUDIO  THE VALUE 0x0200 MUST BE SENT.
 754  */
 755 /*---------------------------------------------------------------------------*/
 756         const u8 request = 0x01;
 757         const u8 requesttype = USB_DIR_OUT |
 758                                USB_TYPE_CLASS |
 759                                USB_RECIP_INTERFACE;
 760         const u16 value_unmute = 0x0200;
 761         const u16 index = 0x0301;
 762         const u16 length = 1;
 763
 764         if (!peasycap)
 765                 return -EFAULT;
 766
 767         pusb_device = peasycap->pusb_device;
 768         if (!pusb_device)
 769                 return -ENODEV;
 770
 771         JOM(8, "%02X %02X %02X %02X %02X %02X %02X %02X\n",
 772                                 requesttype, request,
 773                                 (0x00FF & value_unmute),
 774                                 (0xFF00 & value_unmute) >> 8,
 775                                 (0x00FF & index),
 776                                 (0xFF00 & index) >> 8,
 777                                 (0x00FF & length),
 778                                 (0xFF00 & length) >> 8);
 779
 780         buffer[0] = 0x01;
 781
 782         rc = usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0),
 783                                 request, requesttype, value_unmute,
 784                                 index, &buffer[0], length, 50000);
 785
 786         JOT(8, "0x%02X=buffer\n", buffer[0]);
 787         if (rc != (int)length) {
 788                 switch (rc) {
 789                 case -EPIPE:
 790                         SAY("usb_control_msg returned -EPIPE\n");
 791                         break;
 792                 default:
 793                         SAY("ERROR: usb_control_msg returned %i\n", rc);
 794                         break;
 795                 }
 796         }
 797 /*--------------------------------------------------------------------------*/
 798 /*
 799  *  REGISTER 500:  SETTING VALUE TO 0x0094 RESETS AUDIO CONFIGURATION ???
 800  *  REGISTER 506:  ANALOGUE AUDIO ATTENTUATOR ???
 801  *                 FOR THE CVBS+S-VIDEO HARDWARE:
 802  *                    SETTING VALUE TO 0x0000 GIVES QUIET SOUND.
 803  *                    THE UPPER BYTE SEEMS TO HAVE NO EFFECT.
 804  *                 FOR THE FOUR-CVBS HARDWARE:
 805  *                    SETTING VALUE TO 0x0000 SEEMS TO HAVE NO EFFECT.
 806  *  REGISTER 507:  ANALOGUE AUDIO PREAMPLIFIER ON/OFF ???
 807  *                 FOR THE CVBS-S-VIDEO HARDWARE:
 808  *                    SETTING VALUE TO 0x0001 GIVES VERY LOUD, DISTORTED SOUND.
 809  *                    THE UPPER BYTE SEEMS TO HAVE NO EFFECT.
 810  */
 811 /*--------------------------------------------------------------------------*/
 812         SET(pusb_device, 0x0500, 0x0094);
 813         SET(pusb_device, 0x0500, 0x008C);
 814         SET(pusb_device, 0x0506, 0x0001);
 815         SET(pusb_device, 0x0507, 0x0000);
 816         id1 = read_vt(pusb_device, 0x007C);
 817         id2 = read_vt(pusb_device, 0x007E);
 818         SAM("0x%04X:0x%04X is audio vendor id\n", id1, id2);
 819 /*---------------------------------------------------------------------------*/
 820 /*
 821  *  SELECT AUDIO SOURCE "LINE IN" AND SET THE AUDIO GAIN.
 822 */
 823 /*---------------------------------------------------------------------------*/
 824         if (easycap_audio_gainset(pusb_device, peasycap->gain))
 825                 SAY("ERROR: audio_gainset() failed\n");
 826         check_vt(pusb_device);
 827         return 0;
 828 }
 829 /*****************************************************************************/
 830 int check_vt(struct usb_device *pusb_device)
 831 {
 832         int igot;
 833
 834         if (!pusb_device)
 835                 return -ENODEV;
 836         igot = read_vt(pusb_device, 0x0002);
 837         if (0 > igot)
 838                 SAY("ERROR: failed to read VT1612A register 0x02\n");
 839         if (0x8000 & igot)
 840                 SAY("register 0x%02X muted\n", 0x02);
 841
 842         igot = read_vt(pusb_device, 0x000E);
 843         if (0 > igot)
 844                 SAY("ERROR: failed to read VT1612A register 0x0E\n");
 845         if (0x8000 & igot)
 846                 SAY("register 0x%02X muted\n", 0x0E);
 847
 848         igot = read_vt(pusb_device, 0x0010);
 849         if (0 > igot)
 850                 SAY("ERROR: failed to read VT1612A register 0x10\n");
 851         if (0x8000 & igot)
 852                 SAY("register 0x%02X muted\n", 0x10);
 853
 854         igot = read_vt(pusb_device, 0x0012);
 855         if (0 > igot)
 856                 SAY("ERROR: failed to read VT1612A register 0x12\n");
 857         if (0x8000 & igot)
 858                 SAY("register 0x%02X muted\n", 0x12);
 859
 860         igot = read_vt(pusb_device, 0x0014);
 861         if (0 > igot)
 862                 SAY("ERROR: failed to read VT1612A register 0x14\n");
 863         if (0x8000 & igot)
 864                 SAY("register 0x%02X muted\n", 0x14);
 865
 866         igot = read_vt(pusb_device, 0x0016);
 867         if (0 > igot)
 868                 SAY("ERROR: failed to read VT1612A register 0x16\n");
 869         if (0x8000 & igot)
 870                 SAY("register 0x%02X muted\n", 0x16);
 871
 872         igot = read_vt(pusb_device, 0x0018);
 873         if (0 > igot)
 874                 SAY("ERROR: failed to read VT1612A register 0x18\n");
 875         if (0x8000 & igot)
 876                 SAY("register 0x%02X muted\n", 0x18);
 877
 878         igot = read_vt(pusb_device, 0x001C);
 879         if (0 > igot)
 880                 SAY("ERROR: failed to read VT1612A register 0x1C\n");
 881         if (0x8000 & igot)
 882                 SAY("register 0x%02X muted\n", 0x1C);
 883
 884         return 0;
 885 }
 886 /*****************************************************************************/
 887 /*---------------------------------------------------------------------------*/
 888 /*  NOTE:  THIS DOES INCREASE THE VOLUME DRAMATICALLY:
 889  *                      audio_gainset(pusb_device, 0x000F);
 890  *
 891  *       loud        dB  register 0x10      dB register 0x1C    dB total
 892  *         0               -34.5                   0             -34.5
 893  *        ..                ....                   .              ....
 894  *        15                10.5                   0              10.5
 895  *        16                12.0                   0              12.0
 896  *        17                12.0                   1.5            13.5
 897  *        ..                ....                  ....            ....
 898  *        31                12.0                  22.5            34.5
 899 */
 900 /*---------------------------------------------------------------------------*/
 901 int easycap_audio_gainset(struct usb_device *pusb_device, s8 loud)
 902 {
 903         int igot;
 904         u8 tmp;
 905         u16 mute;
 906
 907         if (!pusb_device)
 908                 return -ENODEV;
 909         if (0 > loud)
 910                 loud = 0;
 911         if (31 < loud)
 912                 loud = 31;
 913
 914         write_vt(pusb_device, 0x0002, 0x8000);
 915 /*---------------------------------------------------------------------------*/
 916         igot = read_vt(pusb_device, 0x000E);
 917         if (0 > igot) {
 918                 SAY("ERROR: failed to read VT1612A register 0x0E\n");
 919                 mute = 0x0000;
 920         } else
 921                 mute = 0x8000 & ((unsigned int)igot);
 922         mute = 0;
 923
 924         if (16 > loud)
 925                 tmp = 0x01 | (0x001F & (((u8)(15 - loud)) << 1));
 926         else
 927                 tmp = 0;
 928
 929         JOT(8, "0x%04X=(mute|tmp) for VT1612A register 0x0E\n", mute | tmp);
 930         write_vt(pusb_device, 0x000E, (mute | tmp));
 931 /*---------------------------------------------------------------------------*/
 932         igot = read_vt(pusb_device, 0x0010);
 933         if (0 > igot) {
 934                 SAY("ERROR: failed to read VT1612A register 0x10\n");
 935                 mute = 0x0000;
 936         } else
 937                 mute = 0x8000 & ((unsigned int)igot);
 938         mute = 0;
 939
 940         JOT(8, "0x%04X=(mute|tmp|(tmp<<8)) for VT1612A register 0x10,...0x18\n",
 941                                                 mute | tmp | (tmp << 8));
 942         write_vt(pusb_device, 0x0010, (mute | tmp | (tmp << 8)));
 943         write_vt(pusb_device, 0x0012, (mute | tmp | (tmp << 8)));
 944         write_vt(pusb_device, 0x0014, (mute | tmp | (tmp << 8)));
 945         write_vt(pusb_device, 0x0016, (mute | tmp | (tmp << 8)));
 946         write_vt(pusb_device, 0x0018, (mute | tmp | (tmp << 8)));
 947 /*---------------------------------------------------------------------------*/
 948         igot = read_vt(pusb_device, 0x001C);
 949         if (0 > igot) {
 950                 SAY("ERROR: failed to read VT1612A register 0x1C\n");
 951                 mute = 0x0000;
 952         } else
 953                 mute = 0x8000 & ((unsigned int)igot);
 954         mute = 0;
 955
 956         if (16 <= loud)
 957                 tmp = 0x000F & (u8)(loud - 16);
 958         else
 959                 tmp = 0;
 960
 961         JOT(8, "0x%04X=(mute|tmp|(tmp<<8)) for VT1612A register 0x1C\n",
 962                                                 mute | tmp | (tmp << 8));
 963         write_vt(pusb_device, 0x001C, (mute | tmp | (tmp << 8)));
 964         write_vt(pusb_device, 0x001A, 0x0404);
 965         write_vt(pusb_device, 0x0002, 0x0000);
 966         return 0;
 967 }
 968 /*****************************************************************************/