aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/staging
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/staging')
-rw-r--r--drivers/staging/easycap/easycap_low.c1302
1 files changed, 641 insertions, 661 deletions
diff --git a/drivers/staging/easycap/easycap_low.c b/drivers/staging/easycap/easycap_low.c
index a345a1bc69d..7b2de10bc68 100644
--- a/drivers/staging/easycap/easycap_low.c
+++ b/drivers/staging/easycap/easycap_low.c
@@ -326,136 +326,132 @@ static int regset(struct usb_device *pusb_device, u16 index, u16 value)
326/*****************************************************************************/ 326/*****************************************************************************/
327 327
328/****************************************************************************/ 328/****************************************************************************/
329int 329int confirm_resolution(struct usb_device *p)
330confirm_resolution(struct usb_device *p)
331{ 330{
332u8 get0, get1, get2, get3, get4, get5, get6, get7; 331 u8 get0, get1, get2, get3, get4, get5, get6, get7;
333 332
334if (NULL == p) 333 if (NULL == p)
335 return -ENODEV; 334 return -ENODEV;
336GET(p, 0x0110, &get0); 335 GET(p, 0x0110, &get0);
337GET(p, 0x0111, &get1); 336 GET(p, 0x0111, &get1);
338GET(p, 0x0112, &get2); 337 GET(p, 0x0112, &get2);
339GET(p, 0x0113, &get3); 338 GET(p, 0x0113, &get3);
340GET(p, 0x0114, &get4); 339 GET(p, 0x0114, &get4);
341GET(p, 0x0115, &get5); 340 GET(p, 0x0115, &get5);
342GET(p, 0x0116, &get6); 341 GET(p, 0x0116, &get6);
343GET(p, 0x0117, &get7); 342 GET(p, 0x0117, &get7);
344JOT(8, "0x%03X, 0x%03X, " 343 JOT(8, "0x%03X, 0x%03X, "
345 "0x%03X, 0x%03X, " 344 "0x%03X, 0x%03X, "
346 "0x%03X, 0x%03X, " 345 "0x%03X, 0x%03X, "
347 "0x%03X, 0x%03X\n", 346 "0x%03X, 0x%03X\n",
348 get0, get1, get2, get3, get4, get5, get6, get7); 347 get0, get1, get2, get3, get4, get5, get6, get7);
349JOT(8, "....cf PAL_720x526: " 348 JOT(8, "....cf PAL_720x526: "
350 "0x%03X, 0x%03X, " 349 "0x%03X, 0x%03X, "
351 "0x%03X, 0x%03X, " 350 "0x%03X, 0x%03X, "
352 "0x%03X, 0x%03X, " 351 "0x%03X, 0x%03X, "
353 "0x%03X, 0x%03X\n", 352 "0x%03X, 0x%03X\n",
354 0x000, 0x000, 0x001, 0x000, 0x5A0, 0x005, 0x121, 0x001); 353 0x000, 0x000, 0x001, 0x000, 0x5A0, 0x005, 0x121, 0x001);
355JOT(8, "....cf PAL_704x526: " 354 JOT(8, "....cf PAL_704x526: "
356 "0x%03X, 0x%03X, " 355 "0x%03X, 0x%03X, "
357 "0x%03X, 0x%03X, " 356 "0x%03X, 0x%03X, "
358 "0x%03X, 0x%03X, " 357 "0x%03X, 0x%03X, "
359 "0x%03X, 0x%03X\n", 358 "0x%03X, 0x%03X\n",
360 0x004, 0x000, 0x001, 0x000, 0x584, 0x005, 0x121, 0x001); 359 0x004, 0x000, 0x001, 0x000, 0x584, 0x005, 0x121, 0x001);
361JOT(8, "....cf VGA_640x480: " 360 JOT(8, "....cf VGA_640x480: "
362 "0x%03X, 0x%03X, " 361 "0x%03X, 0x%03X, "
363 "0x%03X, 0x%03X, " 362 "0x%03X, 0x%03X, "
364 "0x%03X, 0x%03X, " 363 "0x%03X, 0x%03X, "
365 "0x%03X, 0x%03X\n", 364 "0x%03X, 0x%03X\n",
366 0x008, 0x000, 0x020, 0x000, 0x508, 0x005, 0x110, 0x001); 365 0x008, 0x000, 0x020, 0x000, 0x508, 0x005, 0x110, 0x001);
367return 0; 366 return 0;
368} 367}
369/****************************************************************************/ 368/****************************************************************************/
370int 369int confirm_stream(struct usb_device *p)
371confirm_stream(struct usb_device *p)
372{ 370{
373u16 get2; 371 u16 get2;
374u8 igot; 372 u8 igot;
375 373
376if (NULL == p) 374 if (NULL == p)
377 return -ENODEV; 375 return -ENODEV;
378GET(p, 0x0100, &igot); get2 = 0x80 & igot; 376 GET(p, 0x0100, &igot); get2 = 0x80 & igot;
379if (0x80 == get2) 377 if (0x80 == get2)
380 JOT(8, "confirm_stream: OK\n"); 378 JOT(8, "confirm_stream: OK\n");
381else 379 else
382 JOT(8, "confirm_stream: STUCK\n"); 380 JOT(8, "confirm_stream: STUCK\n");
383return 0; 381 return 0;
384} 382}
385/****************************************************************************/ 383/****************************************************************************/
386int 384int setup_stk(struct usb_device *p, bool ntsc)
387setup_stk(struct usb_device *p, bool ntsc)
388{ 385{
389int i0; 386 int i0;
390 387
391if (NULL == p) 388 if (NULL == p)
392 return -ENODEV; 389 return -ENODEV;
393i0 = 0; 390 i0 = 0;
394if (true == ntsc) { 391 if (true == ntsc) {
395 while (0xFFF != stk1160configNTSC[i0].reg) { 392 while (0xFFF != stk1160configNTSC[i0].reg) {
396 SET(p, stk1160configNTSC[i0].reg, stk1160configNTSC[i0].set); 393 SET(p, stk1160configNTSC[i0].reg,
397 i0++; 394 stk1160configNTSC[i0].set);
398 } 395 i0++;
399} else { 396 }
400 while (0xFFF != stk1160configPAL[i0].reg) { 397 } else {
401 SET(p, stk1160configPAL[i0].reg, stk1160configPAL[i0].set); 398 while (0xFFF != stk1160configPAL[i0].reg) {
402 i0++; 399 SET(p, stk1160configPAL[i0].reg,
400 stk1160configPAL[i0].set);
401 i0++;
402 }
403 } 403 }
404}
405 404
406write_300(p); 405 write_300(p);
407 406
408return 0; 407 return 0;
409} 408}
410/****************************************************************************/ 409/****************************************************************************/
411int 410int setup_saa(struct usb_device *p, bool ntsc)
412setup_saa(struct usb_device *p, bool ntsc)
413{ 411{
414int i0, ir; 412 int i0, ir;
415 413
416if (NULL == p) 414 if (NULL == p)
417 return -ENODEV; 415 return -ENODEV;
418i0 = 0; 416 i0 = 0;
419if (true == ntsc) { 417 if (true == ntsc) {
420 while (0xFF != saa7113configNTSC[i0].reg) { 418 while (0xFF != saa7113configNTSC[i0].reg) {
421 ir = write_saa(p, saa7113configNTSC[i0].reg, 419 ir = write_saa(p, saa7113configNTSC[i0].reg,
422 saa7113configNTSC[i0].set); 420 saa7113configNTSC[i0].set);
423 i0++; 421 i0++;
424 } 422 }
425} else { 423 } else {
426 while (0xFF != saa7113configPAL[i0].reg) { 424 while (0xFF != saa7113configPAL[i0].reg) {
427 ir = write_saa(p, saa7113configPAL[i0].reg, 425 ir = write_saa(p, saa7113configPAL[i0].reg,
428 saa7113configPAL[i0].set); 426 saa7113configPAL[i0].set);
429 i0++; 427 i0++;
428 }
430 } 429 }
431} 430 return 0;
432return 0;
433} 431}
434/****************************************************************************/ 432/****************************************************************************/
435int 433int write_000(struct usb_device *p, u16 set2, u16 set0)
436write_000(struct usb_device *p, u16 set2, u16 set0)
437{ 434{
438u8 igot0, igot2; 435 u8 igot0, igot2;
439 436
440if (NULL == p) 437 if (NULL == p)
441 return -ENODEV; 438 return -ENODEV;
442GET(p, 0x0002, &igot2); 439 GET(p, 0x0002, &igot2);
443GET(p, 0x0000, &igot0); 440 GET(p, 0x0000, &igot0);
444SET(p, 0x0002, set2); 441 SET(p, 0x0002, set2);
445SET(p, 0x0000, set0); 442 SET(p, 0x0000, set0);
446return 0; 443 return 0;
447} 444}
448/****************************************************************************/ 445/****************************************************************************/
449int 446int write_saa(struct usb_device *p, u16 reg0, u16 set0)
450write_saa(struct usb_device *p, u16 reg0, u16 set0)
451{ 447{
452if (NULL == p) 448 if (NULL == p)
453 return -ENODEV; 449 return -ENODEV;
454SET(p, 0x200, 0x00); 450 SET(p, 0x200, 0x00);
455SET(p, 0x204, reg0); 451 SET(p, 0x204, reg0);
456SET(p, 0x205, set0); 452 SET(p, 0x205, set0);
457SET(p, 0x200, 0x01); 453 SET(p, 0x200, 0x01);
458return wait_i2c(p); 454 return wait_i2c(p);
459} 455}
460/****************************************************************************/ 456/****************************************************************************/
461/*--------------------------------------------------------------------------*/ 457/*--------------------------------------------------------------------------*/
@@ -470,30 +466,30 @@ return wait_i2c(p);
470int 466int
471write_vt(struct usb_device *p, u16 reg0, u16 set0) 467write_vt(struct usb_device *p, u16 reg0, u16 set0)
472{ 468{
473u8 igot; 469 u8 igot;
474u16 got502, got503; 470 u16 got502, got503;
475u16 set502, set503; 471 u16 set502, set503;
476 472
477if (NULL == p) 473 if (NULL == p)
478 return -ENODEV; 474 return -ENODEV;
479SET(p, 0x0504, reg0); 475 SET(p, 0x0504, reg0);
480SET(p, 0x0500, 0x008B); 476 SET(p, 0x0500, 0x008B);
481 477
482GET(p, 0x0502, &igot); got502 = (0xFF & igot); 478 GET(p, 0x0502, &igot); got502 = (0xFF & igot);
483GET(p, 0x0503, &igot); got503 = (0xFF & igot); 479 GET(p, 0x0503, &igot); got503 = (0xFF & igot);
484 480
485JOT(16, "write_vt(., 0x%04X, 0x%04X): was 0x%04X\n", 481 JOT(16, "write_vt(., 0x%04X, 0x%04X): was 0x%04X\n",
486 reg0, set0, ((got503 << 8) | got502)); 482 reg0, set0, ((got503 << 8) | got502));
487 483
488set502 = (0x00FF & set0); 484 set502 = (0x00FF & set0);
489set503 = ((0xFF00 & set0) >> 8); 485 set503 = ((0xFF00 & set0) >> 8);
490 486
491SET(p, 0x0504, reg0); 487 SET(p, 0x0504, reg0);
492SET(p, 0x0502, set502); 488 SET(p, 0x0502, set502);
493SET(p, 0x0503, set503); 489 SET(p, 0x0503, set503);
494SET(p, 0x0500, 0x008C); 490 SET(p, 0x0500, 0x008C);
495 491
496return 0; 492 return 0;
497} 493}
498/****************************************************************************/ 494/****************************************************************************/
499/*--------------------------------------------------------------------------*/ 495/*--------------------------------------------------------------------------*/
@@ -505,23 +501,23 @@ return 0;
505 * REGISTER 504: TARGET ADDRESS ON VT1612A 501 * REGISTER 504: TARGET ADDRESS ON VT1612A
506 */ 502 */
507/*--------------------------------------------------------------------------*/ 503/*--------------------------------------------------------------------------*/
508int 504int read_vt(struct usb_device *p, u16 reg0)
509read_vt(struct usb_device *p, u16 reg0)
510{ 505{
511u8 igot; 506 u8 igot;
512u16 got502, got503; 507 u16 got502, got503;
513 508
514if (NULL == p) 509 if (NULL == p)
515 return -ENODEV; 510 return -ENODEV;
516SET(p, 0x0504, reg0); 511 SET(p, 0x0504, reg0);
517SET(p, 0x0500, 0x008B); 512 SET(p, 0x0500, 0x008B);
518 513
519GET(p, 0x0502, &igot); got502 = (0xFF & igot); 514 GET(p, 0x0502, &igot); got502 = (0xFF & igot);
520GET(p, 0x0503, &igot); got503 = (0xFF & igot); 515 GET(p, 0x0503, &igot); got503 = (0xFF & igot);
521 516
522JOT(16, "read_vt(., 0x%04X): has 0x%04X\n", reg0, ((got503 << 8) | got502)); 517 JOT(16, "read_vt(., 0x%04X): has 0x%04X\n",
518 reg0, ((got503 << 8) | got502));
523 519
524return (got503 << 8) | got502; 520 return (got503 << 8) | got502;
525} 521}
526/****************************************************************************/ 522/****************************************************************************/
527/*--------------------------------------------------------------------------*/ 523/*--------------------------------------------------------------------------*/
@@ -529,18 +525,17 @@ return (got503 << 8) | got502;
529 * THESE APPEAR TO HAVE NO EFFECT ON EITHER VIDEO OR AUDIO. 525 * THESE APPEAR TO HAVE NO EFFECT ON EITHER VIDEO OR AUDIO.
530 */ 526 */
531/*--------------------------------------------------------------------------*/ 527/*--------------------------------------------------------------------------*/
532int 528int write_300(struct usb_device *p)
533write_300(struct usb_device *p)
534{ 529{
535if (NULL == p) 530 if (NULL == p)
536 return -ENODEV; 531 return -ENODEV;
537SET(p, 0x300, 0x0012); 532 SET(p, 0x300, 0x0012);
538SET(p, 0x350, 0x002D); 533 SET(p, 0x350, 0x002D);
539SET(p, 0x351, 0x0001); 534 SET(p, 0x351, 0x0001);
540SET(p, 0x352, 0x0000); 535 SET(p, 0x352, 0x0000);
541SET(p, 0x353, 0x0000); 536 SET(p, 0x353, 0x0000);
542SET(p, 0x300, 0x0080); 537 SET(p, 0x300, 0x0080);
543return 0; 538 return 0;
544} 539}
545/****************************************************************************/ 540/****************************************************************************/
546/*--------------------------------------------------------------------------*/ 541/*--------------------------------------------------------------------------*/
@@ -549,75 +544,72 @@ return 0;
549 * REGISTER 0x0F, WHICH IS INVOLVED IN CHROMINANCE AUTOMATIC GAIN CONTROL. 544 * REGISTER 0x0F, WHICH IS INVOLVED IN CHROMINANCE AUTOMATIC GAIN CONTROL.
550 */ 545 */
551/*--------------------------------------------------------------------------*/ 546/*--------------------------------------------------------------------------*/
552int 547int check_saa(struct usb_device *p, bool ntsc)
553check_saa(struct usb_device *p, bool ntsc)
554{ 548{
555int i0, ir, rc; 549 int i0, ir, rc;
556
557if (NULL == p)
558 return -ENODEV;
559i0 = 0;
560rc = 0;
561if (true == ntsc) {
562 while (0xFF != saa7113configNTSC[i0].reg) {
563 if (0x0F == saa7113configNTSC[i0].reg) {
564 i0++;
565 continue;
566 }
567 550
568 ir = read_saa(p, saa7113configNTSC[i0].reg); 551 if (NULL == p)
569 if (ir != saa7113configNTSC[i0].set) { 552 return -ENODEV;
570 SAY("SAA register 0x%02X has 0x%02X, " 553 i0 = 0;
554 rc = 0;
555 if (true == ntsc) {
556 while (0xFF != saa7113configNTSC[i0].reg) {
557 if (0x0F == saa7113configNTSC[i0].reg) {
558 i0++;
559 continue;
560 }
561
562 ir = read_saa(p, saa7113configNTSC[i0].reg);
563 if (ir != saa7113configNTSC[i0].set) {
564 SAY("SAA register 0x%02X has 0x%02X, "
571 "expected 0x%02X\n", 565 "expected 0x%02X\n",
572 saa7113configNTSC[i0].reg, 566 saa7113configNTSC[i0].reg,
573 ir, saa7113configNTSC[i0].set); 567 ir, saa7113configNTSC[i0].set);
574 rc--; 568 rc--;
575 } 569 }
576 i0++;
577 }
578} else {
579 while (0xFF != saa7113configPAL[i0].reg) {
580 if (0x0F == saa7113configPAL[i0].reg) {
581 i0++; 570 i0++;
582 continue;
583 } 571 }
572 } else {
573 while (0xFF != saa7113configPAL[i0].reg) {
574 if (0x0F == saa7113configPAL[i0].reg) {
575 i0++;
576 continue;
577 }
584 578
585 ir = read_saa(p, saa7113configPAL[i0].reg); 579 ir = read_saa(p, saa7113configPAL[i0].reg);
586 if (ir != saa7113configPAL[i0].set) { 580 if (ir != saa7113configPAL[i0].set) {
587 SAY("SAA register 0x%02X has 0x%02X, " 581 SAY("SAA register 0x%02X has 0x%02X, "
588 "expected 0x%02X\n", 582 "expected 0x%02X\n",
589 saa7113configPAL[i0].reg, 583 saa7113configPAL[i0].reg,
590 ir, saa7113configPAL[i0].set); 584 ir, saa7113configPAL[i0].set);
591 rc--; 585 rc--;
586 }
587 i0++;
592 } 588 }
593 i0++;
594 } 589 }
595} 590 if (-8 > rc)
596if (-8 > rc) 591 return rc;
597 return rc; 592 else
598else 593 return 0;
599 return 0;
600} 594}
601/****************************************************************************/ 595/****************************************************************************/
602int 596int merit_saa(struct usb_device *p)
603merit_saa(struct usb_device *p)
604{ 597{
605int rc; 598 int rc;
606 599
607if (NULL == p) 600 if (NULL == p)
608 return -ENODEV; 601 return -ENODEV;
609rc = read_saa(p, 0x1F); 602 rc = read_saa(p, 0x1F);
610if ((0 > rc) || (0x02 & rc)) 603 if ((0 > rc) || (0x02 & rc))
611 return 1 ; 604 return 1 ;
612else 605 else
613 return 0; 606 return 0;
614} 607}
615/****************************************************************************/ 608/****************************************************************************/
616int 609int ready_saa(struct usb_device *p)
617ready_saa(struct usb_device *p)
618{ 610{
619int j, rc, rate; 611 int j, rc, rate;
620const int max = 5, marktime = PATIENCE/5; 612 const int max = 5, marktime = PATIENCE/5;
621/*--------------------------------------------------------------------------*/ 613/*--------------------------------------------------------------------------*/
622/* 614/*
623 * RETURNS 0 FOR INTERLACED 50 Hz 615 * RETURNS 0 FOR INTERLACED 50 Hz
@@ -626,38 +618,38 @@ const int max = 5, marktime = PATIENCE/5;
626 * 3 FOR NON-INTERLACED 60 Hz 618 * 3 FOR NON-INTERLACED 60 Hz
627*/ 619*/
628/*--------------------------------------------------------------------------*/ 620/*--------------------------------------------------------------------------*/
629if (NULL == p) 621 if (NULL == p)
630 return -ENODEV; 622 return -ENODEV;
631j = 0; 623 j = 0;
632while (max > j) { 624 while (max > j) {
633 rc = read_saa(p, 0x1F); 625 rc = read_saa(p, 0x1F);
634 if (0 <= rc) { 626 if (0 <= rc) {
635 if (0 == (0x40 & rc)) 627 if (0 == (0x40 & rc))
636 break; 628 break;
637 if (1 == (0x01 & rc)) 629 if (1 == (0x01 & rc))
638 break; 630 break;
639 } 631 }
640 msleep(marktime); 632 msleep(marktime);
641 j++; 633 j++;
642}
643if (max == j)
644 return -1;
645else {
646 if (0x20 & rc) {
647 rate = 2;
648 JOT(8, "hardware detects 60 Hz\n");
649 } else {
650 rate = 0;
651 JOT(8, "hardware detects 50 Hz\n");
652 } 634 }
653 if (0x80 & rc) 635 if (max == j)
654 JOT(8, "hardware detects interlacing\n"); 636 return -1;
655 else { 637 else {
656 rate++; 638 if (0x20 & rc) {
657 JOT(8, "hardware detects no interlacing\n"); 639 rate = 2;
640 JOT(8, "hardware detects 60 Hz\n");
641 } else {
642 rate = 0;
643 JOT(8, "hardware detects 50 Hz\n");
644 }
645 if (0x80 & rc)
646 JOT(8, "hardware detects interlacing\n");
647 else {
648 rate++;
649 JOT(8, "hardware detects no interlacing\n");
650 }
658 } 651 }
659} 652 return 0;
660return 0;
661} 653}
662/****************************************************************************/ 654/****************************************************************************/
663/*--------------------------------------------------------------------------*/ 655/*--------------------------------------------------------------------------*/
@@ -667,106 +659,101 @@ return 0;
667 * REGISTER 0x100: ACCEPT ALSO (0x80 | stk1160config....[.].set) 659 * REGISTER 0x100: ACCEPT ALSO (0x80 | stk1160config....[.].set)
668 */ 660 */
669/*--------------------------------------------------------------------------*/ 661/*--------------------------------------------------------------------------*/
670int 662int check_stk(struct usb_device *p, bool ntsc)
671check_stk(struct usb_device *p, bool ntsc)
672{ 663{
673int i0, ir; 664 int i0, ir;
674 665
675if (NULL == p) 666 if (NULL == p)
676 return -ENODEV; 667 return -ENODEV;
677i0 = 0; 668 i0 = 0;
678if (true == ntsc) { 669 if (true == ntsc) {
679 while (0xFFF != stk1160configNTSC[i0].reg) { 670 while (0xFFF != stk1160configNTSC[i0].reg) {
680 if (0x000 == stk1160configNTSC[i0].reg) { 671 if (0x000 == stk1160configNTSC[i0].reg) {
681 i0++; continue; 672 i0++; continue;
682 } 673 }
683 if (0x002 == stk1160configNTSC[i0].reg) { 674 if (0x002 == stk1160configNTSC[i0].reg) {
684 i0++; continue; 675 i0++; continue;
685 } 676 }
686 ir = read_stk(p, stk1160configNTSC[i0].reg); 677 ir = read_stk(p, stk1160configNTSC[i0].reg);
687 if (0x100 == stk1160configNTSC[i0].reg) { 678 if (0x100 == stk1160configNTSC[i0].reg) {
688 if ((ir != (0xFF & stk1160configNTSC[i0].set)) && 679 if ((ir != (0xFF & stk1160configNTSC[i0].set)) &&
689 (ir != (0x80 | (0xFF & 680 (ir != (0x80 | (0xFF & stk1160configNTSC[i0].set))) &&
690 stk1160configNTSC[i0].set))) && 681 (0xFFFF != stk1160configNTSC[i0].set)) {
691 (0xFFFF != 682 SAY("STK register 0x%03X has 0x%02X, "
692 stk1160configNTSC[i0].set)) {
693 SAY("STK register 0x%03X has 0x%02X, "
694 "expected 0x%02X\n", 683 "expected 0x%02X\n",
695 stk1160configNTSC[i0].reg, 684 stk1160configNTSC[i0].reg,
696 ir, stk1160configNTSC[i0].set); 685 ir, stk1160configNTSC[i0].set);
686 }
687 i0++; continue;
697 } 688 }
698 i0++; continue; 689 if ((ir != (0xFF & stk1160configNTSC[i0].set)) &&
699 } 690 (0xFFFF != stk1160configNTSC[i0].set)) {
700 if ((ir != (0xFF & stk1160configNTSC[i0].set)) && 691 SAY("STK register 0x%03X has 0x%02X, "
701 (0xFFFF != stk1160configNTSC[i0].set)) {
702 SAY("STK register 0x%03X has 0x%02X, "
703 "expected 0x%02X\n", 692 "expected 0x%02X\n",
704 stk1160configNTSC[i0].reg, 693 stk1160configNTSC[i0].reg,
705 ir, stk1160configNTSC[i0].set); 694 ir, stk1160configNTSC[i0].set);
695 }
696 i0++;
706 } 697 }
707 i0++; 698 } else {
708 } 699 while (0xFFF != stk1160configPAL[i0].reg) {
709} else { 700 if (0x000 == stk1160configPAL[i0].reg) {
710 while (0xFFF != stk1160configPAL[i0].reg) { 701 i0++; continue;
711 if (0x000 == stk1160configPAL[i0].reg) { 702 }
712 i0++; continue; 703 if (0x002 == stk1160configPAL[i0].reg) {
713 } 704 i0++; continue;
714 if (0x002 == stk1160configPAL[i0].reg) { 705 }
715 i0++; continue; 706 ir = read_stk(p, stk1160configPAL[i0].reg);
716 } 707 if (0x100 == stk1160configPAL[i0].reg) {
717 ir = read_stk(p, stk1160configPAL[i0].reg); 708 if ((ir != (0xFF & stk1160configPAL[i0].set)) &&
718 if (0x100 == stk1160configPAL[i0].reg) { 709 (ir != (0x80 | (0xFF &
719 if ((ir != (0xFF & stk1160configPAL[i0].set)) && 710 stk1160configPAL[i0].set))) &&
720 (ir != (0x80 | (0xFF & 711 (0xFFFF !=
721 stk1160configPAL[i0].set))) && 712 stk1160configPAL[i0].set)) {
722 (0xFFFF != 713 SAY("STK register 0x%03X has 0x%02X, "
723 stk1160configPAL[i0].set)) {
724 SAY("STK register 0x%03X has 0x%02X, "
725 "expected 0x%02X\n", 714 "expected 0x%02X\n",
726 stk1160configPAL[i0].reg, 715 stk1160configPAL[i0].reg,
727 ir, stk1160configPAL[i0].set); 716 ir, stk1160configPAL[i0].set);
717 }
718 i0++; continue;
728 } 719 }
729 i0++; continue; 720 if ((ir != (0xFF & stk1160configPAL[i0].set)) &&
730 } 721 (0xFFFF != stk1160configPAL[i0].set)) {
731 if ((ir != (0xFF & stk1160configPAL[i0].set)) && 722 SAY("STK register 0x%03X has 0x%02X, "
732 (0xFFFF != stk1160configPAL[i0].set)) {
733 SAY("STK register 0x%03X has 0x%02X, "
734 "expected 0x%02X\n", 723 "expected 0x%02X\n",
735 stk1160configPAL[i0].reg, 724 stk1160configPAL[i0].reg,
736 ir, stk1160configPAL[i0].set); 725 ir, stk1160configPAL[i0].set);
726 }
727 i0++;
737 } 728 }
738 i0++;
739 } 729 }
740} 730 return 0;
741return 0;
742} 731}
743/****************************************************************************/ 732/****************************************************************************/
744int 733int read_saa(struct usb_device *p, u16 reg0)
745read_saa(struct usb_device *p, u16 reg0)
746{ 734{
747u8 igot; 735 u8 igot;
748 736
749if (NULL == p) 737 if (NULL == p)
750 return -ENODEV; 738 return -ENODEV;
751SET(p, 0x208, reg0); 739 SET(p, 0x208, reg0);
752SET(p, 0x200, 0x20); 740 SET(p, 0x200, 0x20);
753if (0 != wait_i2c(p)) 741 if (0 != wait_i2c(p))
754 return -1; 742 return -1;
755igot = 0; 743 igot = 0;
756GET(p, 0x0209, &igot); 744 GET(p, 0x0209, &igot);
757return igot; 745 return igot;
758} 746}
759/****************************************************************************/ 747/****************************************************************************/
760int 748int read_stk(struct usb_device *p, u32 reg0)
761read_stk(struct usb_device *p, u32 reg0)
762{ 749{
763u8 igot; 750 u8 igot;
764 751
765if (NULL == p) 752 if (NULL == p)
766 return -ENODEV; 753 return -ENODEV;
767igot = 0; 754 igot = 0;
768GET(p, reg0, &igot); 755 GET(p, reg0, &igot);
769return igot; 756 return igot;
770} 757}
771/****************************************************************************/ 758/****************************************************************************/
772/*--------------------------------------------------------------------------*/ 759/*--------------------------------------------------------------------------*/
@@ -790,168 +777,165 @@ return igot;
790int 777int
791select_input(struct usb_device *p, int input, int mode) 778select_input(struct usb_device *p, int input, int mode)
792{ 779{
793int ir; 780 int ir;
794 781
795if (NULL == p) 782 if (NULL == p)
796 return -ENODEV; 783 return -ENODEV;
797stop_100(p); 784 stop_100(p);
798switch (input) { 785 switch (input) {
799case 0: 786 case 0:
800case 1: { 787 case 1: {
801 if (0 != write_saa(p, 0x02, 0x80)) { 788 if (0 != write_saa(p, 0x02, 0x80)) {
802 SAY("ERROR: failed to set SAA register 0x02 for input %i\n",
803 input);
804 }
805 SET(p, 0x0000, 0x0098);
806 SET(p, 0x0002, 0x0078);
807 break;
808}
809case 2: {
810 if (0 != write_saa(p, 0x02, 0x80)) {
811 SAY("ERROR: failed to set SAA register 0x02 for input %i\n",
812 input);
813 }
814 SET(p, 0x0000, 0x0090);
815 SET(p, 0x0002, 0x0078);
816 break;
817}
818case 3: {
819 if (0 != write_saa(p, 0x02, 0x80)) {
820 SAY("ERROR: failed to set SAA register 0x02 for input %i\n",
821 input);
822 }
823 SET(p, 0x0000, 0x0088);
824 SET(p, 0x0002, 0x0078);
825 break;
826}
827case 4: {
828 if (0 != write_saa(p, 0x02, 0x80)) {
829 SAY("ERROR: failed to set SAA register 0x02 for input %i\n",
830 input);
831 }
832 SET(p, 0x0000, 0x0080);
833 SET(p, 0x0002, 0x0078);
834 break;
835}
836case 5: {
837 if (9 != mode)
838 mode = 7;
839 switch (mode) {
840 case 7: {
841 if (0 != write_saa(p, 0x02, 0x87)) {
842 SAY("ERROR: failed to set SAA register 0x02 " 789 SAY("ERROR: failed to set SAA register 0x02 "
843 "for input %i\n", input); 790 "for input %i\n", input);
844 } 791 }
845 if (0 != write_saa(p, 0x05, 0xFF)) { 792 SET(p, 0x0000, 0x0098);
846 SAY("ERROR: failed to set SAA register 0x05 " 793 SET(p, 0x0002, 0x0078);
794 break;
795 }
796 case 2: {
797 if (0 != write_saa(p, 0x02, 0x80)) {
798 SAY("ERROR: failed to set SAA register 0x02 "
847 "for input %i\n", input); 799 "for input %i\n", input);
848 } 800 }
801 SET(p, 0x0000, 0x0090);
802 SET(p, 0x0002, 0x0078);
803 break;
804 }
805 case 3: {
806 if (0 != write_saa(p, 0x02, 0x80)) {
807 SAY("ERROR: failed to set SAA register 0x02 "
808 " for input %i\n", input);
809 }
810 SET(p, 0x0000, 0x0088);
811 SET(p, 0x0002, 0x0078);
849 break; 812 break;
850 } 813 }
851 case 9: { 814 case 4: {
852 if (0 != write_saa(p, 0x02, 0x89)) { 815 if (0 != write_saa(p, 0x02, 0x80)) {
853 SAY("ERROR: failed to set SAA register 0x02 " 816 SAY("ERROR: failed to set SAA register 0x02 "
854 "for input %i\n", input); 817 "for input %i\n", input);
855 } 818 }
856 if (0 != write_saa(p, 0x05, 0x00)) { 819 SET(p, 0x0000, 0x0080);
857 SAY("ERROR: failed to set SAA register 0x05 " 820 SET(p, 0x0002, 0x0078);
821 break;
822 }
823 case 5: {
824 if (9 != mode)
825 mode = 7;
826 switch (mode) {
827 case 7: {
828 if (0 != write_saa(p, 0x02, 0x87)) {
829 SAY("ERROR: failed to set SAA register 0x02 "
830 "for input %i\n", input);
831 }
832 if (0 != write_saa(p, 0x05, 0xFF)) {
833 SAY("ERROR: failed to set SAA register 0x05 "
858 "for input %i\n", input); 834 "for input %i\n", input);
835 }
836 break;
859 } 837 }
860 break; 838 case 9: {
839 if (0 != write_saa(p, 0x02, 0x89)) {
840 SAY("ERROR: failed to set SAA register 0x02 "
841 "for input %i\n", input);
842 }
843 if (0 != write_saa(p, 0x05, 0x00)) {
844 SAY("ERROR: failed to set SAA register 0x05 "
845 "for input %i\n", input);
846 }
847 break;
848 }
849 default: {
850 SAY("MISTAKE: bad mode: %i\n", mode);
851 return -1;
852 }
853 }
854 if (0 != write_saa(p, 0x04, 0x00)) {
855 SAY("ERROR: failed to set SAA register 0x04 "
856 "for input %i\n", input);
857 }
858 if (0 != write_saa(p, 0x09, 0x80)) {
859 SAY("ERROR: failed to set SAA register 0x09 "
860 "for input %i\n", input);
861 }
862 SET(p, 0x0002, 0x0093);
863 break;
861 } 864 }
862 default: { 865 default: {
863 SAY("MISTAKE: bad mode: %i\n", mode); 866 SAY("ERROR: bad input: %i\n", input);
864 return -1; 867 return -1;
865 } 868 }
866 } 869 }
867 if (0 != write_saa(p, 0x04, 0x00)) { 870 ir = read_stk(p, 0x00);
868 SAY("ERROR: failed to set SAA register 0x04 for input %i\n", 871 JOT(8, "STK register 0x00 has 0x%02X\n", ir);
869 input); 872 ir = read_saa(p, 0x02);
870 } 873 JOT(8, "SAA register 0x02 has 0x%02X\n", ir);
871 if (0 != write_saa(p, 0x09, 0x80)) {
872 SAY("ERROR: failed to set SAA register 0x09 for input %i\n",
873 input);
874 }
875 SET(p, 0x0002, 0x0093);
876 break;
877}
878default: {
879 SAY("ERROR: bad input: %i\n", input);
880 return -1;
881}
882}
883ir = read_stk(p, 0x00);
884JOT(8, "STK register 0x00 has 0x%02X\n", ir);
885ir = read_saa(p, 0x02);
886JOT(8, "SAA register 0x02 has 0x%02X\n", ir);
887 874
888start_100(p); 875 start_100(p);
889 876
890return 0; 877 return 0;
891} 878}
892/****************************************************************************/ 879/****************************************************************************/
893int 880int set_resolution(struct usb_device *p,
894set_resolution(struct usb_device *p, 881 u16 set0, u16 set1, u16 set2, u16 set3)
895 u16 set0, u16 set1, u16 set2, u16 set3)
896{ 882{
897u16 u0x0111, u0x0113, u0x0115, u0x0117; 883 u16 u0x0111, u0x0113, u0x0115, u0x0117;
898 884
899if (NULL == p) 885 if (NULL == p)
900 return -ENODEV; 886 return -ENODEV;
901u0x0111 = ((0xFF00 & set0) >> 8); 887 u0x0111 = ((0xFF00 & set0) >> 8);
902u0x0113 = ((0xFF00 & set1) >> 8); 888 u0x0113 = ((0xFF00 & set1) >> 8);
903u0x0115 = ((0xFF00 & set2) >> 8); 889 u0x0115 = ((0xFF00 & set2) >> 8);
904u0x0117 = ((0xFF00 & set3) >> 8); 890 u0x0117 = ((0xFF00 & set3) >> 8);
905 891
906SET(p, 0x0110, (0x00FF & set0)); 892 SET(p, 0x0110, (0x00FF & set0));
907SET(p, 0x0111, u0x0111); 893 SET(p, 0x0111, u0x0111);
908SET(p, 0x0112, (0x00FF & set1)); 894 SET(p, 0x0112, (0x00FF & set1));
909SET(p, 0x0113, u0x0113); 895 SET(p, 0x0113, u0x0113);
910SET(p, 0x0114, (0x00FF & set2)); 896 SET(p, 0x0114, (0x00FF & set2));
911SET(p, 0x0115, u0x0115); 897 SET(p, 0x0115, u0x0115);
912SET(p, 0x0116, (0x00FF & set3)); 898 SET(p, 0x0116, (0x00FF & set3));
913SET(p, 0x0117, u0x0117); 899 SET(p, 0x0117, u0x0117);
914 900
915return 0; 901 return 0;
916} 902}
917/****************************************************************************/ 903/****************************************************************************/
918int 904int start_100(struct usb_device *p)
919start_100(struct usb_device *p)
920{ 905{
921u16 get116, get117, get0; 906 u16 get116, get117, get0;
922u8 igot116, igot117, igot; 907 u8 igot116, igot117, igot;
923 908
924if (NULL == p) 909 if (NULL == p)
925 return -ENODEV; 910 return -ENODEV;
926GET(p, 0x0116, &igot116); 911 GET(p, 0x0116, &igot116);
927get116 = igot116; 912 get116 = igot116;
928GET(p, 0x0117, &igot117); 913 GET(p, 0x0117, &igot117);
929get117 = igot117; 914 get117 = igot117;
930SET(p, 0x0116, 0x0000); 915 SET(p, 0x0116, 0x0000);
931SET(p, 0x0117, 0x0000); 916 SET(p, 0x0117, 0x0000);
932 917
933GET(p, 0x0100, &igot); 918 GET(p, 0x0100, &igot);
934get0 = igot; 919 get0 = igot;
935SET(p, 0x0100, (0x80 | get0)); 920 SET(p, 0x0100, (0x80 | get0));
936 921
937SET(p, 0x0116, get116); 922 SET(p, 0x0116, get116);
938SET(p, 0x0117, get117); 923 SET(p, 0x0117, get117);
939 924
940return 0; 925 return 0;
941} 926}
942/****************************************************************************/ 927/****************************************************************************/
943int 928int stop_100(struct usb_device *p)
944stop_100(struct usb_device *p)
945{ 929{
946u16 get0; 930 u16 get0;
947u8 igot; 931 u8 igot;
948 932
949if (NULL == p) 933 if (NULL == p)
950 return -ENODEV; 934 return -ENODEV;
951GET(p, 0x0100, &igot); 935 GET(p, 0x0100, &igot);
952get0 = igot; 936 get0 = igot;
953SET(p, 0x0100, (0x7F & get0)); 937 SET(p, 0x0100, (0x7F & get0));
954return 0; 938 return 0;
955} 939}
956/****************************************************************************/ 940/****************************************************************************/
957/*--------------------------------------------------------------------------*/ 941/*--------------------------------------------------------------------------*/
@@ -959,57 +943,55 @@ return 0;
959 * FUNCTION wait_i2c() RETURNS 0 ON SUCCESS 943 * FUNCTION wait_i2c() RETURNS 0 ON SUCCESS
960*/ 944*/
961/*--------------------------------------------------------------------------*/ 945/*--------------------------------------------------------------------------*/
962int 946int wait_i2c(struct usb_device *p)
963wait_i2c(struct usb_device *p)
964{ 947{
965u16 get0; 948 u16 get0;
966u8 igot; 949 u8 igot;
967const int max = 2; 950 const int max = 2;
968int k; 951 int k;
969 952
970if (NULL == p) 953 if (NULL == p)
971 return -ENODEV; 954 return -ENODEV;
972for (k = 0; k < max; k++) { 955 for (k = 0; k < max; k++) {
973 GET(p, 0x0201, &igot); get0 = igot; 956 GET(p, 0x0201, &igot); get0 = igot;
974 switch (get0) { 957 switch (get0) {
975 case 0x04: 958 case 0x04:
976 case 0x01: { 959 case 0x01: {
977 return 0; 960 return 0;
978 } 961 }
979 case 0x00: { 962 case 0x00: {
980 msleep(20); 963 msleep(20);
981 continue; 964 continue;
982 } 965 }
983 default: { 966 default: {
984 return get0 - 1; 967 return get0 - 1;
985 } 968 }
969 }
986 } 970 }
987} 971 return -1;
988return -1;
989} 972}
990/****************************************************************************/ 973/****************************************************************************/
991/*****************************************************************************/ 974/*****************************************************************************/
992int 975int wakeup_device(struct usb_device *pusb_device)
993wakeup_device(struct usb_device *pusb_device)
994{ 976{
995if (!pusb_device) 977 if (!pusb_device)
996 return -ENODEV; 978 return -ENODEV;
997return usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0), 979 return usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0),
998 (u8)USB_REQ_SET_FEATURE, 980 (u8)USB_REQ_SET_FEATURE,
999 (u8)(USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE), 981 USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
1000 USB_DEVICE_REMOTE_WAKEUP, 982 USB_DEVICE_REMOTE_WAKEUP,
1001 (u16)0, 983 (u16)0,
1002 (void *) NULL, 984 (void *) NULL,
1003 (u16)0, 985 (u16)0,
1004 (int)50000); 986 (int)50000);
1005} 987}
1006/*****************************************************************************/ 988/*****************************************************************************/
1007int 989int
1008audio_setup(struct easycap *peasycap) 990audio_setup(struct easycap *peasycap)
1009{ 991{
1010struct usb_device *pusb_device; 992 struct usb_device *pusb_device;
1011unsigned char buffer[1]; 993 unsigned char buffer[1];
1012int rc, id1, id2; 994 int rc, id1, id2;
1013/*---------------------------------------------------------------------------*/ 995/*---------------------------------------------------------------------------*/
1014/* 996/*
1015 * IMPORTANT: 997 * IMPORTANT:
@@ -1018,53 +1000,54 @@ int rc, id1, id2;
1018 * TO ENABLE AUDIO THE VALUE 0x0200 MUST BE SENT. 1000 * TO ENABLE AUDIO THE VALUE 0x0200 MUST BE SENT.
1019 */ 1001 */
1020/*---------------------------------------------------------------------------*/ 1002/*---------------------------------------------------------------------------*/
1021const u8 request = 0x01; 1003 const u8 request = 0x01;
1022const u8 requesttype = 1004 const u8 requesttype = USB_DIR_OUT |
1023 (u8)(USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE); 1005 USB_TYPE_CLASS |
1024const u16 value_unmute = 0x0200; 1006 USB_RECIP_INTERFACE;
1025const u16 index = 0x0301; 1007 const u16 value_unmute = 0x0200;
1026const u16 length = 1; 1008 const u16 index = 0x0301;
1027 1009 const u16 length = 1;
1028if (NULL == peasycap) 1010
1029 return -EFAULT; 1011 if (NULL == peasycap)
1030 1012 return -EFAULT;
1031pusb_device = peasycap->pusb_device; 1013
1032if (NULL == pusb_device) 1014 pusb_device = peasycap->pusb_device;
1033 return -ENODEV; 1015 if (NULL == pusb_device)
1034 1016 return -ENODEV;
1035JOM(8, "%02X %02X %02X %02X %02X %02X %02X %02X\n",
1036 requesttype, request,
1037 (0x00FF & value_unmute),
1038 (0xFF00 & value_unmute) >> 8,
1039 (0x00FF & index),
1040 (0xFF00 & index) >> 8,
1041 (0x00FF & length),
1042 (0xFF00 & length) >> 8);
1043
1044buffer[0] = 0x01;
1045
1046rc = usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0),
1047 (u8)request,
1048 (u8)requesttype,
1049 (u16)value_unmute,
1050 (u16)index,
1051 (void *)&buffer[0],
1052 (u16)length,
1053 (int)50000);
1054 1017
1055JOT(8, "0x%02X=buffer\n", *((u8 *) &buffer[0])); 1018 JOM(8, "%02X %02X %02X %02X %02X %02X %02X %02X\n",
1056if (rc != (int)length) { 1019 requesttype, request,
1057 switch (rc) { 1020 (0x00FF & value_unmute),
1058 case -EPIPE: { 1021 (0xFF00 & value_unmute) >> 8,
1059 SAY("usb_control_msg returned -EPIPE\n"); 1022 (0x00FF & index),
1060 break; 1023 (0xFF00 & index) >> 8,
1061 } 1024 (0x00FF & length),
1062 default: { 1025 (0xFF00 & length) >> 8);
1063 SAY("ERROR: usb_control_msg returned %i\n", rc); 1026
1064 break; 1027 buffer[0] = 0x01;
1065 } 1028
1029 rc = usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0),
1030 (u8)request,
1031 (u8)requesttype,
1032 (u16)value_unmute,
1033 (u16)index,
1034 (void *)&buffer[0],
1035 (u16)length,
1036 (int)50000);
1037
1038 JOT(8, "0x%02X=buffer\n", *((u8 *) &buffer[0]));
1039 if (rc != (int)length) {
1040 switch (rc) {
1041 case -EPIPE: {
1042 SAY("usb_control_msg returned -EPIPE\n");
1043 break;
1044 }
1045 default: {
1046 SAY("ERROR: usb_control_msg returned %i\n", rc);
1047 break;
1048 }
1049 }
1066 } 1050 }
1067}
1068/*--------------------------------------------------------------------------*/ 1051/*--------------------------------------------------------------------------*/
1069/* 1052/*
1070 * REGISTER 500: SETTING VALUE TO 0x0094 RESETS AUDIO CONFIGURATION ??? 1053 * REGISTER 500: SETTING VALUE TO 0x0094 RESETS AUDIO CONFIGURATION ???
@@ -1080,80 +1063,79 @@ if (rc != (int)length) {
1080 * THE UPPER BYTE SEEMS TO HAVE NO EFFECT. 1063 * THE UPPER BYTE SEEMS TO HAVE NO EFFECT.
1081 */ 1064 */
1082/*--------------------------------------------------------------------------*/ 1065/*--------------------------------------------------------------------------*/
1083SET(pusb_device, 0x0500, 0x0094); 1066 SET(pusb_device, 0x0500, 0x0094);
1084SET(pusb_device, 0x0500, 0x008C); 1067 SET(pusb_device, 0x0500, 0x008C);
1085SET(pusb_device, 0x0506, 0x0001); 1068 SET(pusb_device, 0x0506, 0x0001);
1086SET(pusb_device, 0x0507, 0x0000); 1069 SET(pusb_device, 0x0507, 0x0000);
1087id1 = read_vt(pusb_device, 0x007C); 1070 id1 = read_vt(pusb_device, 0x007C);
1088id2 = read_vt(pusb_device, 0x007E); 1071 id2 = read_vt(pusb_device, 0x007E);
1089SAM("0x%04X:0x%04X is audio vendor id\n", id1, id2); 1072 SAM("0x%04X:0x%04X is audio vendor id\n", id1, id2);
1090/*---------------------------------------------------------------------------*/ 1073/*---------------------------------------------------------------------------*/
1091/* 1074/*
1092 * SELECT AUDIO SOURCE "LINE IN" AND SET THE AUDIO GAIN. 1075 * SELECT AUDIO SOURCE "LINE IN" AND SET THE AUDIO GAIN.
1093*/ 1076*/
1094/*---------------------------------------------------------------------------*/ 1077/*---------------------------------------------------------------------------*/
1095if (0 != audio_gainset(pusb_device, peasycap->gain)) 1078 if (0 != audio_gainset(pusb_device, peasycap->gain))
1096 SAY("ERROR: audio_gainset() failed\n"); 1079 SAY("ERROR: audio_gainset() failed\n");
1097check_vt(pusb_device); 1080 check_vt(pusb_device);
1098return 0; 1081 return 0;
1099} 1082}
1100/*****************************************************************************/ 1083/*****************************************************************************/
1101int 1084int check_vt(struct usb_device *pusb_device)
1102check_vt(struct usb_device *pusb_device)
1103{ 1085{
1104int igot; 1086 int igot;
1105 1087
1106if (!pusb_device) 1088 if (!pusb_device)
1107 return -ENODEV; 1089 return -ENODEV;
1108igot = read_vt(pusb_device, 0x0002); 1090 igot = read_vt(pusb_device, 0x0002);
1109if (0 > igot) 1091 if (0 > igot)
1110 SAY("ERROR: failed to read VT1612A register 0x02\n"); 1092 SAY("ERROR: failed to read VT1612A register 0x02\n");
1111if (0x8000 & igot) 1093 if (0x8000 & igot)
1112 SAY("register 0x%02X muted\n", 0x02); 1094 SAY("register 0x%02X muted\n", 0x02);
1113 1095
1114igot = read_vt(pusb_device, 0x000E); 1096 igot = read_vt(pusb_device, 0x000E);
1115if (0 > igot) 1097 if (0 > igot)
1116 SAY("ERROR: failed to read VT1612A register 0x0E\n"); 1098 SAY("ERROR: failed to read VT1612A register 0x0E\n");
1117if (0x8000 & igot) 1099 if (0x8000 & igot)
1118 SAY("register 0x%02X muted\n", 0x0E); 1100 SAY("register 0x%02X muted\n", 0x0E);
1119 1101
1120igot = read_vt(pusb_device, 0x0010); 1102 igot = read_vt(pusb_device, 0x0010);
1121if (0 > igot) 1103 if (0 > igot)
1122 SAY("ERROR: failed to read VT1612A register 0x10\n"); 1104 SAY("ERROR: failed to read VT1612A register 0x10\n");
1123if (0x8000 & igot) 1105 if (0x8000 & igot)
1124 SAY("register 0x%02X muted\n", 0x10); 1106 SAY("register 0x%02X muted\n", 0x10);
1125 1107
1126igot = read_vt(pusb_device, 0x0012); 1108 igot = read_vt(pusb_device, 0x0012);
1127if (0 > igot) 1109 if (0 > igot)
1128 SAY("ERROR: failed to read VT1612A register 0x12\n"); 1110 SAY("ERROR: failed to read VT1612A register 0x12\n");
1129if (0x8000 & igot) 1111 if (0x8000 & igot)
1130 SAY("register 0x%02X muted\n", 0x12); 1112 SAY("register 0x%02X muted\n", 0x12);
1131 1113
1132igot = read_vt(pusb_device, 0x0014); 1114 igot = read_vt(pusb_device, 0x0014);
1133if (0 > igot) 1115 if (0 > igot)
1134 SAY("ERROR: failed to read VT1612A register 0x14\n"); 1116 SAY("ERROR: failed to read VT1612A register 0x14\n");
1135if (0x8000 & igot) 1117 if (0x8000 & igot)
1136 SAY("register 0x%02X muted\n", 0x14); 1118 SAY("register 0x%02X muted\n", 0x14);
1137 1119
1138igot = read_vt(pusb_device, 0x0016); 1120 igot = read_vt(pusb_device, 0x0016);
1139if (0 > igot) 1121 if (0 > igot)
1140 SAY("ERROR: failed to read VT1612A register 0x16\n"); 1122 SAY("ERROR: failed to read VT1612A register 0x16\n");
1141if (0x8000 & igot) 1123 if (0x8000 & igot)
1142 SAY("register 0x%02X muted\n", 0x16); 1124 SAY("register 0x%02X muted\n", 0x16);
1143 1125
1144igot = read_vt(pusb_device, 0x0018); 1126 igot = read_vt(pusb_device, 0x0018);
1145if (0 > igot) 1127 if (0 > igot)
1146 SAY("ERROR: failed to read VT1612A register 0x18\n"); 1128 SAY("ERROR: failed to read VT1612A register 0x18\n");
1147if (0x8000 & igot) 1129 if (0x8000 & igot)
1148 SAY("register 0x%02X muted\n", 0x18); 1130 SAY("register 0x%02X muted\n", 0x18);
1149 1131
1150igot = read_vt(pusb_device, 0x001C); 1132 igot = read_vt(pusb_device, 0x001C);
1151if (0 > igot) 1133 if (0 > igot)
1152 SAY("ERROR: failed to read VT1612A register 0x1C\n"); 1134 SAY("ERROR: failed to read VT1612A register 0x1C\n");
1153if (0x8000 & igot) 1135 if (0x8000 & igot)
1154 SAY("register 0x%02X muted\n", 0x1C); 1136 SAY("register 0x%02X muted\n", 0x1C);
1155 1137
1156return 0; 1138 return 0;
1157} 1139}
1158/*****************************************************************************/ 1140/*****************************************************************************/
1159/*---------------------------------------------------------------------------*/ 1141/*---------------------------------------------------------------------------*/
@@ -1170,85 +1152,83 @@ return 0;
1170 * 31 12.0 22.5 34.5 1152 * 31 12.0 22.5 34.5
1171*/ 1153*/
1172/*---------------------------------------------------------------------------*/ 1154/*---------------------------------------------------------------------------*/
1173int 1155int audio_gainset(struct usb_device *pusb_device, s8 loud)
1174audio_gainset(struct usb_device *pusb_device, s8 loud)
1175{ 1156{
1176int igot; 1157 int igot;
1177u8 tmp; 1158 u8 tmp;
1178u16 mute; 1159 u16 mute;
1179 1160
1180if (NULL == pusb_device) 1161 if (NULL == pusb_device)
1181 return -ENODEV; 1162 return -ENODEV;
1182if (0 > loud) 1163 if (0 > loud)
1183 loud = 0; 1164 loud = 0;
1184if (31 < loud) 1165 if (31 < loud)
1185 loud = 31; 1166 loud = 31;
1186 1167
1187write_vt(pusb_device, 0x0002, 0x8000); 1168 write_vt(pusb_device, 0x0002, 0x8000);
1188/*---------------------------------------------------------------------------*/ 1169/*---------------------------------------------------------------------------*/
1189igot = read_vt(pusb_device, 0x000E); 1170 igot = read_vt(pusb_device, 0x000E);
1190if (0 > igot) { 1171 if (0 > igot) {
1191 SAY("ERROR: failed to read VT1612A register 0x0E\n"); 1172 SAY("ERROR: failed to read VT1612A register 0x0E\n");
1192 mute = 0x0000; 1173 mute = 0x0000;
1193} else 1174 } else
1194 mute = 0x8000 & ((unsigned int)igot); 1175 mute = 0x8000 & ((unsigned int)igot);
1195mute = 0; 1176 mute = 0;
1196 1177
1197if (16 > loud) 1178 if (16 > loud)
1198 tmp = 0x01 | (0x001F & (((u8)(15 - loud)) << 1)); 1179 tmp = 0x01 | (0x001F & (((u8)(15 - loud)) << 1));
1199else 1180 else
1200 tmp = 0; 1181 tmp = 0;
1201 1182
1202JOT(8, "0x%04X=(mute|tmp) for VT1612A register 0x0E\n", mute | tmp); 1183 JOT(8, "0x%04X=(mute|tmp) for VT1612A register 0x0E\n", mute | tmp);
1203write_vt(pusb_device, 0x000E, (mute | tmp)); 1184 write_vt(pusb_device, 0x000E, (mute | tmp));
1204/*---------------------------------------------------------------------------*/ 1185/*---------------------------------------------------------------------------*/
1205igot = read_vt(pusb_device, 0x0010); 1186 igot = read_vt(pusb_device, 0x0010);
1206if (0 > igot) { 1187 if (0 > igot) {
1207 SAY("ERROR: failed to read VT1612A register 0x10\n"); 1188 SAY("ERROR: failed to read VT1612A register 0x10\n");
1208 mute = 0x0000; 1189 mute = 0x0000;
1209} else 1190 } else
1210 mute = 0x8000 & ((unsigned int)igot); 1191 mute = 0x8000 & ((unsigned int)igot);
1211mute = 0; 1192 mute = 0;
1212 1193
1213JOT(8, "0x%04X=(mute|tmp|(tmp<<8)) for VT1612A register 0x10,...0x18\n", 1194 JOT(8, "0x%04X=(mute|tmp|(tmp<<8)) for VT1612A register 0x10,...0x18\n",
1214 mute | tmp | (tmp << 8)); 1195 mute | tmp | (tmp << 8));
1215write_vt(pusb_device, 0x0010, (mute | tmp | (tmp << 8))); 1196 write_vt(pusb_device, 0x0010, (mute | tmp | (tmp << 8)));
1216write_vt(pusb_device, 0x0012, (mute | tmp | (tmp << 8))); 1197 write_vt(pusb_device, 0x0012, (mute | tmp | (tmp << 8)));
1217write_vt(pusb_device, 0x0014, (mute | tmp | (tmp << 8))); 1198 write_vt(pusb_device, 0x0014, (mute | tmp | (tmp << 8)));
1218write_vt(pusb_device, 0x0016, (mute | tmp | (tmp << 8))); 1199 write_vt(pusb_device, 0x0016, (mute | tmp | (tmp << 8)));
1219write_vt(pusb_device, 0x0018, (mute | tmp | (tmp << 8))); 1200 write_vt(pusb_device, 0x0018, (mute | tmp | (tmp << 8)));
1220/*---------------------------------------------------------------------------*/ 1201/*---------------------------------------------------------------------------*/
1221igot = read_vt(pusb_device, 0x001C); 1202 igot = read_vt(pusb_device, 0x001C);
1222if (0 > igot) { 1203 if (0 > igot) {
1223 SAY("ERROR: failed to read VT1612A register 0x1C\n"); 1204 SAY("ERROR: failed to read VT1612A register 0x1C\n");
1224 mute = 0x0000; 1205 mute = 0x0000;
1225} else 1206 } else
1226 mute = 0x8000 & ((unsigned int)igot); 1207 mute = 0x8000 & ((unsigned int)igot);
1227mute = 0; 1208 mute = 0;
1228 1209
1229if (16 <= loud) 1210 if (16 <= loud)
1230 tmp = 0x000F & (u8)(loud - 16); 1211 tmp = 0x000F & (u8)(loud - 16);
1231else 1212 else
1232 tmp = 0; 1213 tmp = 0;
1233 1214
1234JOT(8, "0x%04X=(mute|tmp|(tmp<<8)) for VT1612A register 0x1C\n", 1215 JOT(8, "0x%04X=(mute|tmp|(tmp<<8)) for VT1612A register 0x1C\n",
1235 mute | tmp | (tmp << 8)); 1216 mute | tmp | (tmp << 8));
1236write_vt(pusb_device, 0x001C, (mute | tmp | (tmp << 8))); 1217 write_vt(pusb_device, 0x001C, (mute | tmp | (tmp << 8)));
1237write_vt(pusb_device, 0x001A, 0x0404); 1218 write_vt(pusb_device, 0x001A, 0x0404);
1238write_vt(pusb_device, 0x0002, 0x0000); 1219 write_vt(pusb_device, 0x0002, 0x0000);
1239return 0; 1220 return 0;
1240} 1221}
1241/*****************************************************************************/ 1222/*****************************************************************************/
1242int 1223int audio_gainget(struct usb_device *pusb_device)
1243audio_gainget(struct usb_device *pusb_device)
1244{ 1224{
1245int igot; 1225 int igot;
1246 1226
1247if (NULL == pusb_device) 1227 if (NULL == pusb_device)
1248 return -ENODEV; 1228 return -ENODEV;
1249igot = read_vt(pusb_device, 0x001C); 1229 igot = read_vt(pusb_device, 0x001C);
1250if (0 > igot) 1230 if (0 > igot)
1251 SAY("ERROR: failed to read VT1612A register 0x1C\n"); 1231 SAY("ERROR: failed to read VT1612A register 0x1C\n");
1252return igot; 1232 return igot;
1253} 1233}
1254/*****************************************************************************/ 1234/*****************************************************************************/
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-22 11:06:25 -0400