diff options
author | Tomas Winkler <tomas.winkler@intel.com> | 2011-02-10 07:55:22 -0500 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@suse.de> | 2011-02-18 15:40:00 -0500 |
commit | 72075789ea6eba8b67516c5fc7e5c12fa1dac1c3 (patch) | |
tree | 09e05f51012b46cba0e92b10e232de96c206903d /drivers/staging | |
parent | 1b3909e5c57032d9e4d9cf6a56c9f7c46149409d (diff) |
staging/easycap: add first level indetnation for easycap_low.c
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Reviewed-by: Dan Carpenter <error27@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat (limited to 'drivers/staging')
-rw-r--r-- | drivers/staging/easycap/easycap_low.c | 1302 |
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 | /****************************************************************************/ |
329 | int | 329 | int confirm_resolution(struct usb_device *p) |
330 | confirm_resolution(struct usb_device *p) | ||
331 | { | 330 | { |
332 | u8 get0, get1, get2, get3, get4, get5, get6, get7; | 331 | u8 get0, get1, get2, get3, get4, get5, get6, get7; |
333 | 332 | ||
334 | if (NULL == p) | 333 | if (NULL == p) |
335 | return -ENODEV; | 334 | return -ENODEV; |
336 | GET(p, 0x0110, &get0); | 335 | GET(p, 0x0110, &get0); |
337 | GET(p, 0x0111, &get1); | 336 | GET(p, 0x0111, &get1); |
338 | GET(p, 0x0112, &get2); | 337 | GET(p, 0x0112, &get2); |
339 | GET(p, 0x0113, &get3); | 338 | GET(p, 0x0113, &get3); |
340 | GET(p, 0x0114, &get4); | 339 | GET(p, 0x0114, &get4); |
341 | GET(p, 0x0115, &get5); | 340 | GET(p, 0x0115, &get5); |
342 | GET(p, 0x0116, &get6); | 341 | GET(p, 0x0116, &get6); |
343 | GET(p, 0x0117, &get7); | 342 | GET(p, 0x0117, &get7); |
344 | JOT(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); |
349 | JOT(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); |
355 | JOT(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); |
361 | JOT(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); |
367 | return 0; | 366 | return 0; |
368 | } | 367 | } |
369 | /****************************************************************************/ | 368 | /****************************************************************************/ |
370 | int | 369 | int confirm_stream(struct usb_device *p) |
371 | confirm_stream(struct usb_device *p) | ||
372 | { | 370 | { |
373 | u16 get2; | 371 | u16 get2; |
374 | u8 igot; | 372 | u8 igot; |
375 | 373 | ||
376 | if (NULL == p) | 374 | if (NULL == p) |
377 | return -ENODEV; | 375 | return -ENODEV; |
378 | GET(p, 0x0100, &igot); get2 = 0x80 & igot; | 376 | GET(p, 0x0100, &igot); get2 = 0x80 & igot; |
379 | if (0x80 == get2) | 377 | if (0x80 == get2) |
380 | JOT(8, "confirm_stream: OK\n"); | 378 | JOT(8, "confirm_stream: OK\n"); |
381 | else | 379 | else |
382 | JOT(8, "confirm_stream: STUCK\n"); | 380 | JOT(8, "confirm_stream: STUCK\n"); |
383 | return 0; | 381 | return 0; |
384 | } | 382 | } |
385 | /****************************************************************************/ | 383 | /****************************************************************************/ |
386 | int | 384 | int setup_stk(struct usb_device *p, bool ntsc) |
387 | setup_stk(struct usb_device *p, bool ntsc) | ||
388 | { | 385 | { |
389 | int i0; | 386 | int i0; |
390 | 387 | ||
391 | if (NULL == p) | 388 | if (NULL == p) |
392 | return -ENODEV; | 389 | return -ENODEV; |
393 | i0 = 0; | 390 | i0 = 0; |
394 | if (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 | ||
406 | write_300(p); | 405 | write_300(p); |
407 | 406 | ||
408 | return 0; | 407 | return 0; |
409 | } | 408 | } |
410 | /****************************************************************************/ | 409 | /****************************************************************************/ |
411 | int | 410 | int setup_saa(struct usb_device *p, bool ntsc) |
412 | setup_saa(struct usb_device *p, bool ntsc) | ||
413 | { | 411 | { |
414 | int i0, ir; | 412 | int i0, ir; |
415 | 413 | ||
416 | if (NULL == p) | 414 | if (NULL == p) |
417 | return -ENODEV; | 415 | return -ENODEV; |
418 | i0 = 0; | 416 | i0 = 0; |
419 | if (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; |
432 | return 0; | ||
433 | } | 431 | } |
434 | /****************************************************************************/ | 432 | /****************************************************************************/ |
435 | int | 433 | int write_000(struct usb_device *p, u16 set2, u16 set0) |
436 | write_000(struct usb_device *p, u16 set2, u16 set0) | ||
437 | { | 434 | { |
438 | u8 igot0, igot2; | 435 | u8 igot0, igot2; |
439 | 436 | ||
440 | if (NULL == p) | 437 | if (NULL == p) |
441 | return -ENODEV; | 438 | return -ENODEV; |
442 | GET(p, 0x0002, &igot2); | 439 | GET(p, 0x0002, &igot2); |
443 | GET(p, 0x0000, &igot0); | 440 | GET(p, 0x0000, &igot0); |
444 | SET(p, 0x0002, set2); | 441 | SET(p, 0x0002, set2); |
445 | SET(p, 0x0000, set0); | 442 | SET(p, 0x0000, set0); |
446 | return 0; | 443 | return 0; |
447 | } | 444 | } |
448 | /****************************************************************************/ | 445 | /****************************************************************************/ |
449 | int | 446 | int write_saa(struct usb_device *p, u16 reg0, u16 set0) |
450 | write_saa(struct usb_device *p, u16 reg0, u16 set0) | ||
451 | { | 447 | { |
452 | if (NULL == p) | 448 | if (NULL == p) |
453 | return -ENODEV; | 449 | return -ENODEV; |
454 | SET(p, 0x200, 0x00); | 450 | SET(p, 0x200, 0x00); |
455 | SET(p, 0x204, reg0); | 451 | SET(p, 0x204, reg0); |
456 | SET(p, 0x205, set0); | 452 | SET(p, 0x205, set0); |
457 | SET(p, 0x200, 0x01); | 453 | SET(p, 0x200, 0x01); |
458 | return wait_i2c(p); | 454 | return wait_i2c(p); |
459 | } | 455 | } |
460 | /****************************************************************************/ | 456 | /****************************************************************************/ |
461 | /*--------------------------------------------------------------------------*/ | 457 | /*--------------------------------------------------------------------------*/ |
@@ -470,30 +466,30 @@ return wait_i2c(p); | |||
470 | int | 466 | int |
471 | write_vt(struct usb_device *p, u16 reg0, u16 set0) | 467 | write_vt(struct usb_device *p, u16 reg0, u16 set0) |
472 | { | 468 | { |
473 | u8 igot; | 469 | u8 igot; |
474 | u16 got502, got503; | 470 | u16 got502, got503; |
475 | u16 set502, set503; | 471 | u16 set502, set503; |
476 | 472 | ||
477 | if (NULL == p) | 473 | if (NULL == p) |
478 | return -ENODEV; | 474 | return -ENODEV; |
479 | SET(p, 0x0504, reg0); | 475 | SET(p, 0x0504, reg0); |
480 | SET(p, 0x0500, 0x008B); | 476 | SET(p, 0x0500, 0x008B); |
481 | 477 | ||
482 | GET(p, 0x0502, &igot); got502 = (0xFF & igot); | 478 | GET(p, 0x0502, &igot); got502 = (0xFF & igot); |
483 | GET(p, 0x0503, &igot); got503 = (0xFF & igot); | 479 | GET(p, 0x0503, &igot); got503 = (0xFF & igot); |
484 | 480 | ||
485 | JOT(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 | ||
488 | set502 = (0x00FF & set0); | 484 | set502 = (0x00FF & set0); |
489 | set503 = ((0xFF00 & set0) >> 8); | 485 | set503 = ((0xFF00 & set0) >> 8); |
490 | 486 | ||
491 | SET(p, 0x0504, reg0); | 487 | SET(p, 0x0504, reg0); |
492 | SET(p, 0x0502, set502); | 488 | SET(p, 0x0502, set502); |
493 | SET(p, 0x0503, set503); | 489 | SET(p, 0x0503, set503); |
494 | SET(p, 0x0500, 0x008C); | 490 | SET(p, 0x0500, 0x008C); |
495 | 491 | ||
496 | return 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 | /*--------------------------------------------------------------------------*/ |
508 | int | 504 | int read_vt(struct usb_device *p, u16 reg0) |
509 | read_vt(struct usb_device *p, u16 reg0) | ||
510 | { | 505 | { |
511 | u8 igot; | 506 | u8 igot; |
512 | u16 got502, got503; | 507 | u16 got502, got503; |
513 | 508 | ||
514 | if (NULL == p) | 509 | if (NULL == p) |
515 | return -ENODEV; | 510 | return -ENODEV; |
516 | SET(p, 0x0504, reg0); | 511 | SET(p, 0x0504, reg0); |
517 | SET(p, 0x0500, 0x008B); | 512 | SET(p, 0x0500, 0x008B); |
518 | 513 | ||
519 | GET(p, 0x0502, &igot); got502 = (0xFF & igot); | 514 | GET(p, 0x0502, &igot); got502 = (0xFF & igot); |
520 | GET(p, 0x0503, &igot); got503 = (0xFF & igot); | 515 | GET(p, 0x0503, &igot); got503 = (0xFF & igot); |
521 | 516 | ||
522 | JOT(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 | ||
524 | return (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 | /*--------------------------------------------------------------------------*/ |
532 | int | 528 | int write_300(struct usb_device *p) |
533 | write_300(struct usb_device *p) | ||
534 | { | 529 | { |
535 | if (NULL == p) | 530 | if (NULL == p) |
536 | return -ENODEV; | 531 | return -ENODEV; |
537 | SET(p, 0x300, 0x0012); | 532 | SET(p, 0x300, 0x0012); |
538 | SET(p, 0x350, 0x002D); | 533 | SET(p, 0x350, 0x002D); |
539 | SET(p, 0x351, 0x0001); | 534 | SET(p, 0x351, 0x0001); |
540 | SET(p, 0x352, 0x0000); | 535 | SET(p, 0x352, 0x0000); |
541 | SET(p, 0x353, 0x0000); | 536 | SET(p, 0x353, 0x0000); |
542 | SET(p, 0x300, 0x0080); | 537 | SET(p, 0x300, 0x0080); |
543 | return 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 | /*--------------------------------------------------------------------------*/ |
552 | int | 547 | int check_saa(struct usb_device *p, bool ntsc) |
553 | check_saa(struct usb_device *p, bool ntsc) | ||
554 | { | 548 | { |
555 | int i0, ir, rc; | 549 | int i0, ir, rc; |
556 | |||
557 | if (NULL == p) | ||
558 | return -ENODEV; | ||
559 | i0 = 0; | ||
560 | rc = 0; | ||
561 | if (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) |
596 | if (-8 > rc) | 591 | return rc; |
597 | return rc; | 592 | else |
598 | else | 593 | return 0; |
599 | return 0; | ||
600 | } | 594 | } |
601 | /****************************************************************************/ | 595 | /****************************************************************************/ |
602 | int | 596 | int merit_saa(struct usb_device *p) |
603 | merit_saa(struct usb_device *p) | ||
604 | { | 597 | { |
605 | int rc; | 598 | int rc; |
606 | 599 | ||
607 | if (NULL == p) | 600 | if (NULL == p) |
608 | return -ENODEV; | 601 | return -ENODEV; |
609 | rc = read_saa(p, 0x1F); | 602 | rc = read_saa(p, 0x1F); |
610 | if ((0 > rc) || (0x02 & rc)) | 603 | if ((0 > rc) || (0x02 & rc)) |
611 | return 1 ; | 604 | return 1 ; |
612 | else | 605 | else |
613 | return 0; | 606 | return 0; |
614 | } | 607 | } |
615 | /****************************************************************************/ | 608 | /****************************************************************************/ |
616 | int | 609 | int ready_saa(struct usb_device *p) |
617 | ready_saa(struct usb_device *p) | ||
618 | { | 610 | { |
619 | int j, rc, rate; | 611 | int j, rc, rate; |
620 | const 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 | /*--------------------------------------------------------------------------*/ |
629 | if (NULL == p) | 621 | if (NULL == p) |
630 | return -ENODEV; | 622 | return -ENODEV; |
631 | j = 0; | 623 | j = 0; |
632 | while (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 | } | ||
643 | if (max == j) | ||
644 | return -1; | ||
645 | else { | ||
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; |
660 | return 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 | /*--------------------------------------------------------------------------*/ |
670 | int | 662 | int check_stk(struct usb_device *p, bool ntsc) |
671 | check_stk(struct usb_device *p, bool ntsc) | ||
672 | { | 663 | { |
673 | int i0, ir; | 664 | int i0, ir; |
674 | 665 | ||
675 | if (NULL == p) | 666 | if (NULL == p) |
676 | return -ENODEV; | 667 | return -ENODEV; |
677 | i0 = 0; | 668 | i0 = 0; |
678 | if (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; |
741 | return 0; | ||
742 | } | 731 | } |
743 | /****************************************************************************/ | 732 | /****************************************************************************/ |
744 | int | 733 | int read_saa(struct usb_device *p, u16 reg0) |
745 | read_saa(struct usb_device *p, u16 reg0) | ||
746 | { | 734 | { |
747 | u8 igot; | 735 | u8 igot; |
748 | 736 | ||
749 | if (NULL == p) | 737 | if (NULL == p) |
750 | return -ENODEV; | 738 | return -ENODEV; |
751 | SET(p, 0x208, reg0); | 739 | SET(p, 0x208, reg0); |
752 | SET(p, 0x200, 0x20); | 740 | SET(p, 0x200, 0x20); |
753 | if (0 != wait_i2c(p)) | 741 | if (0 != wait_i2c(p)) |
754 | return -1; | 742 | return -1; |
755 | igot = 0; | 743 | igot = 0; |
756 | GET(p, 0x0209, &igot); | 744 | GET(p, 0x0209, &igot); |
757 | return igot; | 745 | return igot; |
758 | } | 746 | } |
759 | /****************************************************************************/ | 747 | /****************************************************************************/ |
760 | int | 748 | int read_stk(struct usb_device *p, u32 reg0) |
761 | read_stk(struct usb_device *p, u32 reg0) | ||
762 | { | 749 | { |
763 | u8 igot; | 750 | u8 igot; |
764 | 751 | ||
765 | if (NULL == p) | 752 | if (NULL == p) |
766 | return -ENODEV; | 753 | return -ENODEV; |
767 | igot = 0; | 754 | igot = 0; |
768 | GET(p, reg0, &igot); | 755 | GET(p, reg0, &igot); |
769 | return igot; | 756 | return igot; |
770 | } | 757 | } |
771 | /****************************************************************************/ | 758 | /****************************************************************************/ |
772 | /*--------------------------------------------------------------------------*/ | 759 | /*--------------------------------------------------------------------------*/ |
@@ -790,168 +777,165 @@ return igot; | |||
790 | int | 777 | int |
791 | select_input(struct usb_device *p, int input, int mode) | 778 | select_input(struct usb_device *p, int input, int mode) |
792 | { | 779 | { |
793 | int ir; | 780 | int ir; |
794 | 781 | ||
795 | if (NULL == p) | 782 | if (NULL == p) |
796 | return -ENODEV; | 783 | return -ENODEV; |
797 | stop_100(p); | 784 | stop_100(p); |
798 | switch (input) { | 785 | switch (input) { |
799 | case 0: | 786 | case 0: |
800 | case 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 | } | ||
809 | case 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 | } | ||
818 | case 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 | } | ||
827 | case 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 | } | ||
836 | case 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 | } | ||
878 | default: { | ||
879 | SAY("ERROR: bad input: %i\n", input); | ||
880 | return -1; | ||
881 | } | ||
882 | } | ||
883 | ir = read_stk(p, 0x00); | ||
884 | JOT(8, "STK register 0x00 has 0x%02X\n", ir); | ||
885 | ir = read_saa(p, 0x02); | ||
886 | JOT(8, "SAA register 0x02 has 0x%02X\n", ir); | ||
887 | 874 | ||
888 | start_100(p); | 875 | start_100(p); |
889 | 876 | ||
890 | return 0; | 877 | return 0; |
891 | } | 878 | } |
892 | /****************************************************************************/ | 879 | /****************************************************************************/ |
893 | int | 880 | int set_resolution(struct usb_device *p, |
894 | set_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 | { |
897 | u16 u0x0111, u0x0113, u0x0115, u0x0117; | 883 | u16 u0x0111, u0x0113, u0x0115, u0x0117; |
898 | 884 | ||
899 | if (NULL == p) | 885 | if (NULL == p) |
900 | return -ENODEV; | 886 | return -ENODEV; |
901 | u0x0111 = ((0xFF00 & set0) >> 8); | 887 | u0x0111 = ((0xFF00 & set0) >> 8); |
902 | u0x0113 = ((0xFF00 & set1) >> 8); | 888 | u0x0113 = ((0xFF00 & set1) >> 8); |
903 | u0x0115 = ((0xFF00 & set2) >> 8); | 889 | u0x0115 = ((0xFF00 & set2) >> 8); |
904 | u0x0117 = ((0xFF00 & set3) >> 8); | 890 | u0x0117 = ((0xFF00 & set3) >> 8); |
905 | 891 | ||
906 | SET(p, 0x0110, (0x00FF & set0)); | 892 | SET(p, 0x0110, (0x00FF & set0)); |
907 | SET(p, 0x0111, u0x0111); | 893 | SET(p, 0x0111, u0x0111); |
908 | SET(p, 0x0112, (0x00FF & set1)); | 894 | SET(p, 0x0112, (0x00FF & set1)); |
909 | SET(p, 0x0113, u0x0113); | 895 | SET(p, 0x0113, u0x0113); |
910 | SET(p, 0x0114, (0x00FF & set2)); | 896 | SET(p, 0x0114, (0x00FF & set2)); |
911 | SET(p, 0x0115, u0x0115); | 897 | SET(p, 0x0115, u0x0115); |
912 | SET(p, 0x0116, (0x00FF & set3)); | 898 | SET(p, 0x0116, (0x00FF & set3)); |
913 | SET(p, 0x0117, u0x0117); | 899 | SET(p, 0x0117, u0x0117); |
914 | 900 | ||
915 | return 0; | 901 | return 0; |
916 | } | 902 | } |
917 | /****************************************************************************/ | 903 | /****************************************************************************/ |
918 | int | 904 | int start_100(struct usb_device *p) |
919 | start_100(struct usb_device *p) | ||
920 | { | 905 | { |
921 | u16 get116, get117, get0; | 906 | u16 get116, get117, get0; |
922 | u8 igot116, igot117, igot; | 907 | u8 igot116, igot117, igot; |
923 | 908 | ||
924 | if (NULL == p) | 909 | if (NULL == p) |
925 | return -ENODEV; | 910 | return -ENODEV; |
926 | GET(p, 0x0116, &igot116); | 911 | GET(p, 0x0116, &igot116); |
927 | get116 = igot116; | 912 | get116 = igot116; |
928 | GET(p, 0x0117, &igot117); | 913 | GET(p, 0x0117, &igot117); |
929 | get117 = igot117; | 914 | get117 = igot117; |
930 | SET(p, 0x0116, 0x0000); | 915 | SET(p, 0x0116, 0x0000); |
931 | SET(p, 0x0117, 0x0000); | 916 | SET(p, 0x0117, 0x0000); |
932 | 917 | ||
933 | GET(p, 0x0100, &igot); | 918 | GET(p, 0x0100, &igot); |
934 | get0 = igot; | 919 | get0 = igot; |
935 | SET(p, 0x0100, (0x80 | get0)); | 920 | SET(p, 0x0100, (0x80 | get0)); |
936 | 921 | ||
937 | SET(p, 0x0116, get116); | 922 | SET(p, 0x0116, get116); |
938 | SET(p, 0x0117, get117); | 923 | SET(p, 0x0117, get117); |
939 | 924 | ||
940 | return 0; | 925 | return 0; |
941 | } | 926 | } |
942 | /****************************************************************************/ | 927 | /****************************************************************************/ |
943 | int | 928 | int stop_100(struct usb_device *p) |
944 | stop_100(struct usb_device *p) | ||
945 | { | 929 | { |
946 | u16 get0; | 930 | u16 get0; |
947 | u8 igot; | 931 | u8 igot; |
948 | 932 | ||
949 | if (NULL == p) | 933 | if (NULL == p) |
950 | return -ENODEV; | 934 | return -ENODEV; |
951 | GET(p, 0x0100, &igot); | 935 | GET(p, 0x0100, &igot); |
952 | get0 = igot; | 936 | get0 = igot; |
953 | SET(p, 0x0100, (0x7F & get0)); | 937 | SET(p, 0x0100, (0x7F & get0)); |
954 | return 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 | /*--------------------------------------------------------------------------*/ |
962 | int | 946 | int wait_i2c(struct usb_device *p) |
963 | wait_i2c(struct usb_device *p) | ||
964 | { | 947 | { |
965 | u16 get0; | 948 | u16 get0; |
966 | u8 igot; | 949 | u8 igot; |
967 | const int max = 2; | 950 | const int max = 2; |
968 | int k; | 951 | int k; |
969 | 952 | ||
970 | if (NULL == p) | 953 | if (NULL == p) |
971 | return -ENODEV; | 954 | return -ENODEV; |
972 | for (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; |
988 | return -1; | ||
989 | } | 972 | } |
990 | /****************************************************************************/ | 973 | /****************************************************************************/ |
991 | /*****************************************************************************/ | 974 | /*****************************************************************************/ |
992 | int | 975 | int wakeup_device(struct usb_device *pusb_device) |
993 | wakeup_device(struct usb_device *pusb_device) | ||
994 | { | 976 | { |
995 | if (!pusb_device) | 977 | if (!pusb_device) |
996 | return -ENODEV; | 978 | return -ENODEV; |
997 | return 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 | /*****************************************************************************/ |
1007 | int | 989 | int |
1008 | audio_setup(struct easycap *peasycap) | 990 | audio_setup(struct easycap *peasycap) |
1009 | { | 991 | { |
1010 | struct usb_device *pusb_device; | 992 | struct usb_device *pusb_device; |
1011 | unsigned char buffer[1]; | 993 | unsigned char buffer[1]; |
1012 | int 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 | /*---------------------------------------------------------------------------*/ |
1021 | const u8 request = 0x01; | 1003 | const u8 request = 0x01; |
1022 | const u8 requesttype = | 1004 | const u8 requesttype = USB_DIR_OUT | |
1023 | (u8)(USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE); | 1005 | USB_TYPE_CLASS | |
1024 | const u16 value_unmute = 0x0200; | 1006 | USB_RECIP_INTERFACE; |
1025 | const u16 index = 0x0301; | 1007 | const u16 value_unmute = 0x0200; |
1026 | const u16 length = 1; | 1008 | const u16 index = 0x0301; |
1027 | 1009 | const u16 length = 1; | |
1028 | if (NULL == peasycap) | 1010 | |
1029 | return -EFAULT; | 1011 | if (NULL == peasycap) |
1030 | 1012 | return -EFAULT; | |
1031 | pusb_device = peasycap->pusb_device; | 1013 | |
1032 | if (NULL == pusb_device) | 1014 | pusb_device = peasycap->pusb_device; |
1033 | return -ENODEV; | 1015 | if (NULL == pusb_device) |
1034 | 1016 | return -ENODEV; | |
1035 | JOM(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 | |||
1044 | buffer[0] = 0x01; | ||
1045 | |||
1046 | rc = 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 | ||
1055 | JOT(8, "0x%02X=buffer\n", *((u8 *) &buffer[0])); | 1018 | JOM(8, "%02X %02X %02X %02X %02X %02X %02X %02X\n", |
1056 | if (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 | /*--------------------------------------------------------------------------*/ |
1083 | SET(pusb_device, 0x0500, 0x0094); | 1066 | SET(pusb_device, 0x0500, 0x0094); |
1084 | SET(pusb_device, 0x0500, 0x008C); | 1067 | SET(pusb_device, 0x0500, 0x008C); |
1085 | SET(pusb_device, 0x0506, 0x0001); | 1068 | SET(pusb_device, 0x0506, 0x0001); |
1086 | SET(pusb_device, 0x0507, 0x0000); | 1069 | SET(pusb_device, 0x0507, 0x0000); |
1087 | id1 = read_vt(pusb_device, 0x007C); | 1070 | id1 = read_vt(pusb_device, 0x007C); |
1088 | id2 = read_vt(pusb_device, 0x007E); | 1071 | id2 = read_vt(pusb_device, 0x007E); |
1089 | SAM("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 | /*---------------------------------------------------------------------------*/ |
1095 | if (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"); |
1097 | check_vt(pusb_device); | 1080 | check_vt(pusb_device); |
1098 | return 0; | 1081 | return 0; |
1099 | } | 1082 | } |
1100 | /*****************************************************************************/ | 1083 | /*****************************************************************************/ |
1101 | int | 1084 | int check_vt(struct usb_device *pusb_device) |
1102 | check_vt(struct usb_device *pusb_device) | ||
1103 | { | 1085 | { |
1104 | int igot; | 1086 | int igot; |
1105 | 1087 | ||
1106 | if (!pusb_device) | 1088 | if (!pusb_device) |
1107 | return -ENODEV; | 1089 | return -ENODEV; |
1108 | igot = read_vt(pusb_device, 0x0002); | 1090 | igot = read_vt(pusb_device, 0x0002); |
1109 | if (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"); |
1111 | if (0x8000 & igot) | 1093 | if (0x8000 & igot) |
1112 | SAY("register 0x%02X muted\n", 0x02); | 1094 | SAY("register 0x%02X muted\n", 0x02); |
1113 | 1095 | ||
1114 | igot = read_vt(pusb_device, 0x000E); | 1096 | igot = read_vt(pusb_device, 0x000E); |
1115 | if (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"); |
1117 | if (0x8000 & igot) | 1099 | if (0x8000 & igot) |
1118 | SAY("register 0x%02X muted\n", 0x0E); | 1100 | SAY("register 0x%02X muted\n", 0x0E); |
1119 | 1101 | ||
1120 | igot = read_vt(pusb_device, 0x0010); | 1102 | igot = read_vt(pusb_device, 0x0010); |
1121 | if (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"); |
1123 | if (0x8000 & igot) | 1105 | if (0x8000 & igot) |
1124 | SAY("register 0x%02X muted\n", 0x10); | 1106 | SAY("register 0x%02X muted\n", 0x10); |
1125 | 1107 | ||
1126 | igot = read_vt(pusb_device, 0x0012); | 1108 | igot = read_vt(pusb_device, 0x0012); |
1127 | if (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"); |
1129 | if (0x8000 & igot) | 1111 | if (0x8000 & igot) |
1130 | SAY("register 0x%02X muted\n", 0x12); | 1112 | SAY("register 0x%02X muted\n", 0x12); |
1131 | 1113 | ||
1132 | igot = read_vt(pusb_device, 0x0014); | 1114 | igot = read_vt(pusb_device, 0x0014); |
1133 | if (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"); |
1135 | if (0x8000 & igot) | 1117 | if (0x8000 & igot) |
1136 | SAY("register 0x%02X muted\n", 0x14); | 1118 | SAY("register 0x%02X muted\n", 0x14); |
1137 | 1119 | ||
1138 | igot = read_vt(pusb_device, 0x0016); | 1120 | igot = read_vt(pusb_device, 0x0016); |
1139 | if (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"); |
1141 | if (0x8000 & igot) | 1123 | if (0x8000 & igot) |
1142 | SAY("register 0x%02X muted\n", 0x16); | 1124 | SAY("register 0x%02X muted\n", 0x16); |
1143 | 1125 | ||
1144 | igot = read_vt(pusb_device, 0x0018); | 1126 | igot = read_vt(pusb_device, 0x0018); |
1145 | if (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"); |
1147 | if (0x8000 & igot) | 1129 | if (0x8000 & igot) |
1148 | SAY("register 0x%02X muted\n", 0x18); | 1130 | SAY("register 0x%02X muted\n", 0x18); |
1149 | 1131 | ||
1150 | igot = read_vt(pusb_device, 0x001C); | 1132 | igot = read_vt(pusb_device, 0x001C); |
1151 | if (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"); |
1153 | if (0x8000 & igot) | 1135 | if (0x8000 & igot) |
1154 | SAY("register 0x%02X muted\n", 0x1C); | 1136 | SAY("register 0x%02X muted\n", 0x1C); |
1155 | 1137 | ||
1156 | return 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 | /*---------------------------------------------------------------------------*/ |
1173 | int | 1155 | int audio_gainset(struct usb_device *pusb_device, s8 loud) |
1174 | audio_gainset(struct usb_device *pusb_device, s8 loud) | ||
1175 | { | 1156 | { |
1176 | int igot; | 1157 | int igot; |
1177 | u8 tmp; | 1158 | u8 tmp; |
1178 | u16 mute; | 1159 | u16 mute; |
1179 | 1160 | ||
1180 | if (NULL == pusb_device) | 1161 | if (NULL == pusb_device) |
1181 | return -ENODEV; | 1162 | return -ENODEV; |
1182 | if (0 > loud) | 1163 | if (0 > loud) |
1183 | loud = 0; | 1164 | loud = 0; |
1184 | if (31 < loud) | 1165 | if (31 < loud) |
1185 | loud = 31; | 1166 | loud = 31; |
1186 | 1167 | ||
1187 | write_vt(pusb_device, 0x0002, 0x8000); | 1168 | write_vt(pusb_device, 0x0002, 0x8000); |
1188 | /*---------------------------------------------------------------------------*/ | 1169 | /*---------------------------------------------------------------------------*/ |
1189 | igot = read_vt(pusb_device, 0x000E); | 1170 | igot = read_vt(pusb_device, 0x000E); |
1190 | if (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); |
1195 | mute = 0; | 1176 | mute = 0; |
1196 | 1177 | ||
1197 | if (16 > loud) | 1178 | if (16 > loud) |
1198 | tmp = 0x01 | (0x001F & (((u8)(15 - loud)) << 1)); | 1179 | tmp = 0x01 | (0x001F & (((u8)(15 - loud)) << 1)); |
1199 | else | 1180 | else |
1200 | tmp = 0; | 1181 | tmp = 0; |
1201 | 1182 | ||
1202 | JOT(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); |
1203 | write_vt(pusb_device, 0x000E, (mute | tmp)); | 1184 | write_vt(pusb_device, 0x000E, (mute | tmp)); |
1204 | /*---------------------------------------------------------------------------*/ | 1185 | /*---------------------------------------------------------------------------*/ |
1205 | igot = read_vt(pusb_device, 0x0010); | 1186 | igot = read_vt(pusb_device, 0x0010); |
1206 | if (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); |
1211 | mute = 0; | 1192 | mute = 0; |
1212 | 1193 | ||
1213 | JOT(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)); |
1215 | write_vt(pusb_device, 0x0010, (mute | tmp | (tmp << 8))); | 1196 | write_vt(pusb_device, 0x0010, (mute | tmp | (tmp << 8))); |
1216 | write_vt(pusb_device, 0x0012, (mute | tmp | (tmp << 8))); | 1197 | write_vt(pusb_device, 0x0012, (mute | tmp | (tmp << 8))); |
1217 | write_vt(pusb_device, 0x0014, (mute | tmp | (tmp << 8))); | 1198 | write_vt(pusb_device, 0x0014, (mute | tmp | (tmp << 8))); |
1218 | write_vt(pusb_device, 0x0016, (mute | tmp | (tmp << 8))); | 1199 | write_vt(pusb_device, 0x0016, (mute | tmp | (tmp << 8))); |
1219 | write_vt(pusb_device, 0x0018, (mute | tmp | (tmp << 8))); | 1200 | write_vt(pusb_device, 0x0018, (mute | tmp | (tmp << 8))); |
1220 | /*---------------------------------------------------------------------------*/ | 1201 | /*---------------------------------------------------------------------------*/ |
1221 | igot = read_vt(pusb_device, 0x001C); | 1202 | igot = read_vt(pusb_device, 0x001C); |
1222 | if (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); |
1227 | mute = 0; | 1208 | mute = 0; |
1228 | 1209 | ||
1229 | if (16 <= loud) | 1210 | if (16 <= loud) |
1230 | tmp = 0x000F & (u8)(loud - 16); | 1211 | tmp = 0x000F & (u8)(loud - 16); |
1231 | else | 1212 | else |
1232 | tmp = 0; | 1213 | tmp = 0; |
1233 | 1214 | ||
1234 | JOT(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)); |
1236 | write_vt(pusb_device, 0x001C, (mute | tmp | (tmp << 8))); | 1217 | write_vt(pusb_device, 0x001C, (mute | tmp | (tmp << 8))); |
1237 | write_vt(pusb_device, 0x001A, 0x0404); | 1218 | write_vt(pusb_device, 0x001A, 0x0404); |
1238 | write_vt(pusb_device, 0x0002, 0x0000); | 1219 | write_vt(pusb_device, 0x0002, 0x0000); |
1239 | return 0; | 1220 | return 0; |
1240 | } | 1221 | } |
1241 | /*****************************************************************************/ | 1222 | /*****************************************************************************/ |
1242 | int | 1223 | int audio_gainget(struct usb_device *pusb_device) |
1243 | audio_gainget(struct usb_device *pusb_device) | ||
1244 | { | 1224 | { |
1245 | int igot; | 1225 | int igot; |
1246 | 1226 | ||
1247 | if (NULL == pusb_device) | 1227 | if (NULL == pusb_device) |
1248 | return -ENODEV; | 1228 | return -ENODEV; |
1249 | igot = read_vt(pusb_device, 0x001C); | 1229 | igot = read_vt(pusb_device, 0x001C); |
1250 | if (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"); |
1252 | return igot; | 1232 | return igot; |
1253 | } | 1233 | } |
1254 | /*****************************************************************************/ | 1234 | /*****************************************************************************/ |