| /***************************************************************************** |
| * * |
| * * |
| * easycap_low.c * |
| * * |
| * * |
| *****************************************************************************/ |
| /* |
| * |
| * Copyright (C) 2010 R.M. Thomas <rmthomas@sciolus.org> |
| * |
| * |
| * This is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * The software is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this software; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| /*****************************************************************************/ |
| /* |
| * ACKNOWLEGEMENTS AND REFERENCES |
| * ------------------------------ |
| * This driver makes use of register information contained in the Syntek |
| * Semicon DC-1125 driver hosted at |
| * http://sourceforge.net/projects/syntekdriver/. |
| * Particularly useful has been a patch to the latter driver provided by |
| * Ivor Hewitt in January 2009. The NTSC implementation is taken from the |
| * work of Ben Trask. |
| */ |
| /****************************************************************************/ |
| |
| #include "easycap_debug.h" |
| #include "easycap.h" |
| |
| /*--------------------------------------------------------------------------*/ |
| const struct stk1160config { int reg; int set; } stk1160config[256] = { |
| {0x000, 0x0098}, |
| {0x002, 0x0093}, |
| |
| {0x001, 0x0003}, |
| {0x003, 0x0080}, |
| {0x00D, 0x0000}, |
| {0x00F, 0x0002}, |
| {0x018, 0x0010}, |
| {0x019, 0x0000}, |
| {0x01A, 0x0014}, |
| {0x01B, 0x000E}, |
| {0x01C, 0x0046}, |
| |
| {0x100, 0x0033}, |
| {0x103, 0x0000}, |
| {0x104, 0x0000}, |
| {0x105, 0x0000}, |
| {0x106, 0x0000}, |
| |
| #if defined(PREFER_NTSC) |
| |
| #undef OLDMARGIN |
| #if defined(OLDMARGIN) |
| {0x110, 0x0008}, |
| #else |
| {0x110, 0x0014}, |
| #endif /*OLDMARGIN*/ |
| |
| {0x111, 0x0000}, |
| {0x112, 0x0003}, |
| {0x113, 0x0000}, |
| |
| #if defined(OLDMARGIN) |
| {0x114, 0x0508}, |
| #else |
| {0x114, 0x0514}, |
| #endif /*OLDMARGIN*/ |
| |
| {0x115, 0x0005}, |
| {0x116, 0x00F3}, |
| {0x117, 0x0000}, |
| |
| #else /* ! PREFER_NTSC*/ |
| |
| #if defined(OLDMARGIN) |
| {0x110, 0x0008}, |
| #else |
| {0x110, 0x0014}, |
| #endif /*OLDMARGIN*/ |
| |
| {0x111, 0x0000}, |
| {0x112, 0x0020}, |
| {0x113, 0x0000}, |
| |
| #if defined(OLDMARGIN) |
| {0x114, 0x0508}, |
| #else |
| {0x114, 0x0514}, |
| #endif /*OLDMARGIN*/ |
| |
| {0x115, 0x0005}, |
| {0x116, 0x0110}, |
| {0x117, 0x0001}, |
| |
| #endif /* ! PREFER_NTSC*/ |
| |
| {0x202, 0x000F}, |
| {0x203, 0x004A}, |
| {0x2FF, 0x0000}, |
| /*---------------------------------------------------------------------------*/ |
| {0xFFF, 0xFFFF} |
| }; |
| /*--------------------------------------------------------------------------*/ |
| const struct saa7113config { int reg; int set; } saa7113config[256] = { |
| {0x01, 0x08}, |
| {0x02, 0x80}, |
| {0x03, 0x33}, |
| {0x04, 0x00}, |
| {0x05, 0x00}, |
| {0x06, 0xE9}, |
| {0x07, 0x0D}, |
| #if defined(PREFER_NTSC) |
| {0x08, 0x78}, |
| #else |
| {0x08, 0x38}, |
| #endif /* ! PREFER_NTSC*/ |
| {0x09, 0x00}, |
| {0x0A, SAA_0A_DEFAULT}, |
| {0x0B, SAA_0B_DEFAULT}, |
| {0x0C, SAA_0C_DEFAULT}, |
| {0x0D, SAA_0D_DEFAULT}, |
| {0x0E, 0x01}, |
| {0x0F, 0x36}, |
| {0x10, 0x00}, |
| {0x11, 0x0C}, |
| {0x12, 0xE7}, |
| {0x13, 0x00}, |
| {0x15, 0x00}, |
| {0x16, 0x00}, |
| #if defined(PREFER_NTSC) |
| {0x40, 0x82}, |
| #else |
| {0x40, 0x02}, |
| #endif /* ! PREFER_NTSC*/ |
| {0x41, 0xFF}, |
| {0x42, 0xFF}, |
| {0x43, 0xFF}, |
| {0x44, 0xFF}, |
| {0x45, 0xFF}, |
| {0x46, 0xFF}, |
| {0x47, 0xFF}, |
| {0x48, 0xFF}, |
| {0x49, 0xFF}, |
| {0x4A, 0xFF}, |
| {0x4B, 0xFF}, |
| {0x4C, 0xFF}, |
| {0x4D, 0xFF}, |
| {0x4E, 0xFF}, |
| {0x4F, 0xFF}, |
| {0x50, 0xFF}, |
| {0x51, 0xFF}, |
| {0x52, 0xFF}, |
| {0x53, 0xFF}, |
| {0x54, 0xFF}, |
| {0x55, 0xFF}, |
| {0x56, 0xFF}, |
| {0x57, 0xFF}, |
| {0x58, 0x40}, |
| {0x59, 0x54}, |
| #if defined(PREFER_NTSC) |
| {0x5A, 0x0A}, |
| #else |
| {0x5A, 0x07}, |
| #endif /* ! PREFER_NTSC*/ |
| {0x5B, 0x83}, |
| {0xFF, 0xFF} |
| }; |
| /*--------------------------------------------------------------------------*/ |
| |
| /****************************************************************************/ |
| int |
| confirm_resolution(struct usb_device *p) |
| { |
| __u8 get0, get1, get2, get3, get4, get5, get6, get7; |
| GET(p, 0x0110, &get0); |
| GET(p, 0x0111, &get1); |
| GET(p, 0x0112, &get2); |
| GET(p, 0x0113, &get3); |
| GET(p, 0x0114, &get4); |
| GET(p, 0x0115, &get5); |
| GET(p, 0x0116, &get6); |
| GET(p, 0x0117, &get7); |
| JOT(8, "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X\n", \ |
| get0, get1, get2, get3, get4, get5, get6, get7); |
| JOT(8, "....cf PAL_720x526: " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X\n", \ |
| 0x000, 0x000, 0x001, 0x000, 0x5A0, 0x005, 0x121, 0x001); |
| JOT(8, "....cf PAL_704x526: " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X\n", \ |
| 0x004, 0x000, 0x001, 0x000, 0x584, 0x005, 0x121, 0x001); |
| JOT(8, "....cf VGA_640x480: " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X, " \ |
| "0x%03X, 0x%03X\n", \ |
| 0x008, 0x000, 0x020, 0x000, 0x508, 0x005, 0x110, 0x001); |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| confirm_stream(struct usb_device *p) |
| { |
| __u16 get2; |
| __u8 igot; |
| |
| GET(p, 0x0100, &igot); get2 = 0x80 & igot; |
| if (0x80 == get2) |
| JOT(8, "confirm_stream: OK\n"); |
| else |
| JOT(8, "confirm_stream: STUCK\n"); |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| setup_stk(struct usb_device *p) |
| { |
| int i0; |
| |
| i0 = 0; |
| while (0xFFF != stk1160config[i0].reg) { |
| SET(p, stk1160config[i0].reg, stk1160config[i0].set); |
| i0++; |
| } |
| |
| write_300(p); |
| |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| setup_saa(struct usb_device *p) |
| { |
| int i0, ir; |
| |
| |
| set2to78(p); |
| |
| |
| i0 = 0; |
| while (0xFF != saa7113config[i0].reg) { |
| ir = write_saa(p, saa7113config[i0].reg, saa7113config[i0].set); |
| i0++; |
| } |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| write_000(struct usb_device *p, __u16 set2, __u16 set0) |
| { |
| __u8 igot0, igot2; |
| |
| GET(p, 0x0002, &igot2); |
| GET(p, 0x0000, &igot0); |
| SET(p, 0x0002, set2); |
| SET(p, 0x0000, set0); |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| write_saa(struct usb_device *p, __u16 reg0, __u16 set0) |
| { |
| SET(p, 0x200, 0x00); |
| SET(p, 0x204, reg0); |
| SET(p, 0x205, set0); |
| SET(p, 0x200, 0x01); |
| return wait_i2c(p); |
| } |
| /****************************************************************************/ |
| /*--------------------------------------------------------------------------*/ |
| /* |
| * REGISTER 500: SETTING VALUE TO 0x008B READS FROM VT1612A (?) |
| * REGISTER 500: SETTING VALUE TO 0x008C WRITES TO VT1612A |
| * REGISTER 502: LEAST SIGNIFICANT BYTE OF VALUE TO SET |
| * REGISTER 503: MOST SIGNIFICANT BYTE OF VALUE TO SET |
| * REGISTER 504: TARGET ADDRESS ON VT1612A |
| */ |
| /*--------------------------------------------------------------------------*/ |
| int |
| write_vt(struct usb_device *p, __u16 reg0, __u16 set0) |
| { |
| __u8 igot; |
| __u16 got502, got503; |
| __u16 set502, set503; |
| |
| SET(p, 0x0504, reg0); |
| SET(p, 0x0500, 0x008B); |
| |
| GET(p, 0x0502, &igot); got502 = (0xFF & igot); |
| GET(p, 0x0503, &igot); got503 = (0xFF & igot); |
| |
| JOT(16, "write_vt(., 0x%04X, 0x%04X): was 0x%04X\n", \ |
| reg0, set0, ((got503 << 8) | got502)); |
| |
| set502 = (0x00FF & set0); |
| set503 = ((0xFF00 & set0) >> 8); |
| |
| SET(p, 0x0504, reg0); |
| SET(p, 0x0502, set502); |
| SET(p, 0x0503, set503); |
| SET(p, 0x0500, 0x008C); |
| |
| return 0; |
| } |
| /****************************************************************************/ |
| /*--------------------------------------------------------------------------*/ |
| /* |
| * REGISTER 500: SETTING VALUE TO 0x008B READS FROM VT1612A (?) |
| * REGISTER 500: SETTING VALUE TO 0x008C WRITES TO VT1612A |
| * REGISTER 502: LEAST SIGNIFICANT BYTE OF VALUE TO GET |
| * REGISTER 503: MOST SIGNIFICANT BYTE OF VALUE TO GET |
| * REGISTER 504: TARGET ADDRESS ON VT1612A |
| */ |
| /*--------------------------------------------------------------------------*/ |
| int |
| read_vt(struct usb_device *p, __u16 reg0) |
| { |
| __u8 igot; |
| __u16 got502, got503; |
| |
| SET(p, 0x0504, reg0); |
| SET(p, 0x0500, 0x008B); |
| |
| GET(p, 0x0502, &igot); got502 = (0xFF & igot); |
| GET(p, 0x0503, &igot); got503 = (0xFF & igot); |
| |
| JOT(16, "read_vt(., 0x%04X): has 0x%04X\n", reg0, ((got503 << 8) | got502)); |
| |
| return (got503 << 8) | got502; |
| } |
| /****************************************************************************/ |
| /*--------------------------------------------------------------------------*/ |
| /* |
| * THESE APPEAR TO HAVE NO EFFECT ON EITHER VIDEO OR AUDIO. |
| */ |
| /*--------------------------------------------------------------------------*/ |
| int |
| write_300(struct usb_device *p) |
| { |
| SET(p, 0x300, 0x0012); |
| SET(p, 0x350, 0x002D); |
| SET(p, 0x351, 0x0001); |
| SET(p, 0x352, 0x0000); |
| SET(p, 0x353, 0x0000); |
| SET(p, 0x300, 0x0080); |
| return 0; |
| } |
| /****************************************************************************/ |
| /*--------------------------------------------------------------------------*/ |
| /* |
| * NOTE: THE FOLLOWING IS NOT CHECKED: |
| * REGISTER 0x0F, WHICH IS INVOLVED IN CHROMINANCE AUTOMATIC GAIN CONTROL. |
| */ |
| /*--------------------------------------------------------------------------*/ |
| int |
| check_saa(struct usb_device *p) |
| { |
| int i0, ir, rc; |
| i0 = 0; |
| |
| rc = 0; |
| while (0xFF != saa7113config[i0].reg) { |
| if (0x0F == saa7113config[i0].reg) { |
| i0++; continue; |
| } |
| |
| ir = read_saa(p, saa7113config[i0].reg); |
| if (ir != saa7113config[i0].set) { |
| SAY("SAA register 0x%02X has 0x%02X, expected 0x%02X\n", \ |
| saa7113config[i0].reg, ir, saa7113config[i0].set); |
| rc--; |
| } |
| i0++; |
| } |
| if (-8 > rc) |
| return rc; |
| else |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| merit_saa(struct usb_device *p) |
| { |
| int rc; |
| |
| rc = read_saa(p, 0x1F); |
| if ((0 > rc) || (0x02 & rc)) |
| return 1 ; |
| else |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| ready_saa(struct usb_device *p) |
| { |
| int j, rc; |
| static int max = 10; |
| |
| j = 0; |
| while (max > j) { |
| rc = read_saa(p, 0x1F); |
| if (0 <= rc) { |
| if ((1 == (0x01 & rc))&&(0 == (0x40 & rc))) |
| break; |
| } |
| msleep(100); j++; |
| } |
| if (max == j) |
| return -1; |
| else { |
| if (0x20 & rc) |
| JOT(8, "hardware detects 60 Hz\n"); |
| else |
| JOT(8, "hardware detects 50 Hz\n"); |
| if (0x80 & rc) |
| JOT(8, "hardware detects interlacing\n"); |
| else |
| JOT(8, "hardware detects no interlacing\n"); |
| } |
| return 0; |
| } |
| /****************************************************************************/ |
| /*--------------------------------------------------------------------------*/ |
| /* |
| * NOTE: THE FOLLOWING ARE NOT CHECKED: |
| * REGISTERS 0x000, 0x002: FUNCTIONALITY IS NOT KNOWN |
| * REGISTER 0x100: ACCEPT ALSO (0x80 | stk1160config[.].set) |
| */ |
| /*--------------------------------------------------------------------------*/ |
| int |
| check_stk(struct usb_device *p) |
| { |
| int i0, ir; |
| i0 = 0; |
| while (0xFFF != stk1160config[i0].reg) { |
| if (0x000 == stk1160config[i0].reg) { |
| i0++; continue; |
| } |
| if (0x002 == stk1160config[i0].reg) { |
| i0++; continue; |
| } |
| |
| ir = read_stk(p, stk1160config[i0].reg); |
| |
| if (0x100 == stk1160config[i0].reg) { |
| if ((ir != (0xFF & stk1160config[i0].set)) && \ |
| (ir != (0x80 | (0xFF & stk1160config[i0].set))) && \ |
| (0xFFFF != stk1160config[i0].set)) { |
| SAY("STK register 0x%03X has 0x%02X, " \ |
| "expected 0x%02X\n", \ |
| stk1160config[i0].reg, ir, \ |
| stk1160config[i0].set); |
| } |
| i0++; continue; |
| } |
| |
| if ((ir != (0xFF & stk1160config[i0].set)) && \ |
| (0xFFFF != stk1160config[i0].set)) { |
| SAY("STK register 0x%03X has 0x%02X, " \ |
| "expected 0x%02X\n", \ |
| stk1160config[i0].reg, ir, \ |
| stk1160config[i0].set); |
| } |
| i0++; |
| } |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| read_saa(struct usb_device *p, __u16 reg0) |
| { |
| __u8 igot; |
| |
| SET(p, 0x208, reg0); |
| SET(p, 0x200, 0x20); |
| if (0 != wait_i2c(p)) |
| return -1; |
| igot = 0; |
| GET(p, 0x0209, &igot); |
| return igot; |
| } |
| /****************************************************************************/ |
| int |
| read_stk(struct usb_device *p, __u32 reg0) |
| { |
| __u8 igot; |
| |
| igot = 0; |
| GET(p, reg0, &igot); |
| return igot; |
| } |
| /*****************************************************************************/ |
| /*---------------------------------------------------------------------------*/ |
| /* |
| * HARDWARE USERSPACE INPUT NUMBER PHYSICAL INPUT DRIVER input VALUE |
| * |
| * CVBS+S-VIDEO 0 or 1 CVBS 1 |
| * FOUR-CVBS 0 or 1 CVBS1 1 |
| * FOUR-CVBS 2 CVBS2 2 |
| * FOUR-CVBS 3 CVBS3 3 |
| * FOUR-CVBS 4 CVBS4 4 |
| * CVBS+S-VIDEO 5 S-VIDEO 5 |
| * |
| * WHEN 5==input THE ARGUMENT mode MUST ALSO BE SUPPLIED: |
| * |
| * mode 7 => GAIN TO BE SET EXPLICITLY USING REGISTER 0x05 (UNTESTED) |
| * mode 9 => USE AUTOMATIC GAIN CONTROL (DEFAULT) |
| * |
| */ |
| /*---------------------------------------------------------------------------*/ |
| int |
| select_input(struct usb_device *p, int input, int mode) |
| { |
| |
| stop_100(p); |
| |
| msleep(20); |
| switch (input) { |
| case 0: |
| case 1: { |
| SET(p, 0x0000, 0x0098); break; |
| } |
| case 2: { |
| SET(p, 0x0000, 0x0090); break; |
| } |
| case 3: { |
| SET(p, 0x0000, 0x0088); break; |
| } |
| case 4: { |
| SET(p, 0x0000, 0x0080); break; |
| } |
| case 5: { |
| if (9 != mode) |
| mode = 7; |
| switch (mode) { |
| case 7: |
| { |
| if (0 != write_saa(p, 0x02, 0x87)) { |
| SAY("ERROR: failed to set SAA " \ |
| "register 0x02 for input " \ |
| "%i\n", input); |
| } |
| if (0 != write_saa(p, 0x05, 0xFF)) { |
| SAY("ERROR: failed to set SAA " \ |
| "register 0x05 for input " \ |
| "%i\n", input); |
| } |
| break; |
| } |
| case 9: |
| { |
| if (0 != write_saa(p, 0x02, 0x89)) { |
| SAY("ERROR: failed to set SAA " \ |
| "register 0x02 for input " \ |
| "%i\n", input); |
| } |
| if (0 != write_saa(p, 0x05, 0x00)) { |
| SAY("ERROR: failed to set SAA " \ |
| "register 0x05 for input " \ |
| "%i\n", input); |
| } |
| break; |
| } |
| default: |
| { |
| SAY("MISTAKE: bad mode: %i\n", mode); |
| return -1; |
| } |
| } |
| if (0 != write_saa(p, 0x04, 0x00)) { |
| SAY("ERROR: failed to set SAA register 0x04 " \ |
| "for input %i\n", input); |
| } |
| if (0 != write_saa(p, 0x09, 0x80)) { |
| SAY("ERROR: failed to set SAA register 0x09 " \ |
| "for input %i\n", input); |
| } |
| break; |
| } |
| default: |
| { |
| SAY("ERROR: bad input: %i\n", input); |
| return -1; |
| } |
| } |
| msleep(20); |
| SET(p, 0x0002, 0x0093); |
| msleep(20); |
| |
| start_100(p); |
| |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| set_resolution(struct usb_device *p, \ |
| __u16 set0, __u16 set1, __u16 set2, __u16 set3) |
| { |
| __u16 u0x0111, u0x0113, u0x0115, u0x0117; |
| |
| u0x0111 = ((0xFF00 & set0) >> 8); |
| u0x0113 = ((0xFF00 & set1) >> 8); |
| u0x0115 = ((0xFF00 & set2) >> 8); |
| u0x0117 = ((0xFF00 & set3) >> 8); |
| |
| SET(p, 0x0110, (0x00FF & set0)); |
| SET(p, 0x0111, u0x0111); |
| SET(p, 0x0112, (0x00FF & set1)); |
| SET(p, 0x0113, u0x0113); |
| SET(p, 0x0114, (0x00FF & set2)); |
| SET(p, 0x0115, u0x0115); |
| SET(p, 0x0116, (0x00FF & set3)); |
| SET(p, 0x0117, u0x0117); |
| |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| start_100(struct usb_device *p) |
| { |
| __u16 get0; |
| __u8 igot; |
| |
| GET(p, 0x0100, &igot); get0 = igot; |
| msleep(0x1f4); |
| SET(p, 0x0100, (0x80 | get0)); |
| msleep(0x1f4); |
| return 0; |
| } |
| /****************************************************************************/ |
| int |
| stop_100(struct usb_device *p) |
| { |
| __u16 get0; |
| __u8 igot; |
| |
| GET(p, 0x0100, &igot); get0 = igot; |
| msleep(0x1f4); |
| SET(p, 0x0100, (0x7F & get0)); |
| msleep(0x1f4); |
| return 0; |
| } |
| /****************************************************************************/ |
| /*--------------------------------------------------------------------------*/ |
| /* |
| * FUNCTION wait_i2c() RETURNS 0 ON SUCCESS |
| */ |
| /*--------------------------------------------------------------------------*/ |
| int |
| wait_i2c(struct usb_device *p) |
| { |
| __u16 get0; |
| __u8 igot; |
| const int max = 4; |
| int k; |
| |
| for (k = 0; k < max; k++) { |
| GET(p, 0x0201, &igot); get0 = igot; |
| switch (get0) { |
| case 0x04: |
| case 0x01: { |
| return 0; |
| } |
| case 0x00: { |
| msleep(10); |
| continue; |
| } |
| default: { |
| return get0 - 1; |
| } |
| } |
| } |
| return -1; |
| } |
| /****************************************************************************/ |
| int |
| regset(struct usb_device *pusb_device, __u16 index, __u16 value) |
| { |
| __u16 igot; |
| int rc0, rc1; |
| |
| if (!pusb_device) |
| return -EFAULT; |
| |
| rc1 = 0; igot = 0; |
| rc0 = usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0), \ |
| (__u8)0x01, \ |
| (__u8)(USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE), \ |
| (__u16)value, \ |
| (__u16)index, \ |
| (void *)NULL, \ |
| (__u16)0, \ |
| (int)500); |
| |
| #if defined(NOREADBACK) |
| # |
| #else |
| rc1 = usb_control_msg(pusb_device, usb_rcvctrlpipe(pusb_device, 0), \ |
| (__u8)0x00, \ |
| (__u8)(USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE), \ |
| (__u16)0x00, \ |
| (__u16)index, \ |
| (void *)&igot, \ |
| (__u16)sizeof(__u16), \ |
| (int)50000); |
| igot = 0xFF & igot; |
| switch (index) { |
| case 0x000: |
| case 0x500: |
| case 0x502: |
| case 0x503: |
| case 0x504: |
| case 0x506: |
| case 0x507: { |
| break; |
| } |
| case 0x204: |
| case 0x205: |
| case 0x350: |
| case 0x351: { |
| if (0 != igot) { |
| JOT(8, "unexpected 0x%02X for STK register 0x%03X\n", \ |
| igot, index); |
| } |
| break; |
| } |
| case 0x114: |
| case 0x116: { |
| if ((0xFF & value) != igot) { |
| JOT(8, "unexpected 0x%02X != 0x%02X " \ |
| "for STK register 0x%03X\n", \ |
| igot, value, index); |
| } |
| break; |
| } |
| case 0x200: { |
| if (0 == igot) |
| break; |
| } |
| default: { |
| if (value != igot) { |
| JOT(8, "unexpected 0x%02X != 0x%02X " \ |
| "for STK register 0x%03X\n", \ |
| igot, value, index); |
| } |
| break; |
| } |
| } |
| #endif /* ! NOREADBACK*/ |
| |
| return (0 > rc0) ? rc0 : rc1; |
| } |
| /*****************************************************************************/ |
| int |
| regget(struct usb_device *pusb_device, __u16 index, void *pvoid) |
| { |
| int ir; |
| |
| if (!pusb_device) |
| return -EFAULT; |
| |
| ir = usb_control_msg(pusb_device, usb_rcvctrlpipe(pusb_device, 0), \ |
| (__u8)0x00, \ |
| (__u8)(USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE), \ |
| (__u16)0x00, \ |
| (__u16)index, \ |
| (void *)pvoid, \ |
| sizeof(__u8), \ |
| (int)50000); |
| return 0xFF & ir; |
| } |
| /*****************************************************************************/ |
| int |
| wakeup_device(struct usb_device *pusb_device) |
| { |
| return usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0), \ |
| (__u8)USB_REQ_SET_FEATURE, \ |
| (__u8)(USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE), \ |
| USB_DEVICE_REMOTE_WAKEUP, \ |
| (__u16)0, \ |
| (void *) NULL, \ |
| (__u16)0, \ |
| (int)50000); |
| } |
| /*****************************************************************************/ |
| /*---------------------------------------------------------------------------*/ |
| /* |
| * IMPORTANT: |
| * THE MESSAGE OF TYPE (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) |
| * CAUSES MUTING IF THE VALUE 0x0100 IS SENT. |
| * TO ENABLE AUDIO THE VALUE 0x0200 MUST BE SENT. |
| */ |
| /*---------------------------------------------------------------------------*/ |
| int |
| audio_setup(struct easycap *peasycap) |
| { |
| struct usb_device *pusb_device; |
| static __u8 request = 0x01; |
| static __u8 requesttype = \ |
| (__u8)(USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE); |
| |
| static __u16 value_unmute = 0x0200; |
| static __u16 index = 0x0301; |
| |
| static unsigned char buffer[1]; |
| static __u16 length = 1; |
| int rc, id1, id2; |
| |
| if (NULL == peasycap) |
| return -EFAULT; |
| |
| pusb_device = peasycap->pusb_device; |
| if (NULL == pusb_device) |
| return -EFAULT; |
| |
| JOT(8, "%02X %02X %02X %02X %02X %02X %02X %02X\n", \ |
| requesttype, request, \ |
| (0x00FF & value_unmute), \ |
| (0xFF00 & value_unmute) >> 8, \ |
| (0x00FF & index), \ |
| (0xFF00 & index) >> 8, \ |
| (0x00FF & length), \ |
| (0xFF00 & length) >> 8); |
| |
| buffer[0] = 0x01; |
| |
| rc = usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0), \ |
| (__u8)request, \ |
| (__u8)requesttype, \ |
| (__u16)value_unmute, \ |
| (__u16)index, \ |
| (void *)&buffer[0], \ |
| (__u16)length, \ |
| (int)50000); |
| |
| JOT(8, "0x%02X=buffer\n", *((__u8 *) &buffer[0])); |
| if (rc != (int)length) |
| SAY("ERROR: usb_control_msg returned %i\n", rc); |
| |
| /*--------------------------------------------------------------------------*/ |
| /* |
| * REGISTER 500: SETTING VALUE TO 0x0094 RESETS AUDIO CONFIGURATION ??? |
| * REGISTER 506: ANALOGUE AUDIO ATTENTUATOR ??? |
| * FOR THE CVBS+S-VIDEO HARDWARE: |
| * SETTING VALUE TO 0x0000 GIVES QUIET SOUND. |
| * THE UPPER BYTE SEEMS TO HAVE NO EFFECT. |
| * FOR THE FOUR-CVBS HARDWARE: |
| * SETTING VALUE TO 0x0000 SEEMS TO HAVE NO EFFECT. |
| * REGISTER 507: ANALOGUE AUDIO PREAMPLIFIER ON/OFF ??? |
| * FOR THE CVBS-S-VIDEO HARDWARE: |
| * SETTING VALUE TO 0x0001 GIVES VERY LOUD, DISTORTED SOUND. |
| * THE UPPER BYTE SEEMS TO HAVE NO EFFECT. |
| */ |
| /*--------------------------------------------------------------------------*/ |
| |
| SET(pusb_device, 0x0500, 0x0094); |
| |
| SET(pusb_device, 0x0500, 0x008C); |
| |
| SET(pusb_device, 0x0506, 0x0001); |
| SET(pusb_device, 0x0507, 0x0000); |
| |
| id1 = read_vt(pusb_device, 0x007C); |
| id2 = read_vt(pusb_device, 0x007E); |
| SAY("0x%04X:0x%04X is audio vendor id\n", id1, id2); |
| |
| /*---------------------------------------------------------------------------*/ |
| /* |
| * SELECT AUDIO SOURCE "LINE IN" AND SET DEFAULT GAIN TO 0 dB. |
| * |
| * THESE COMMANDS SEEM TO BE ACCEPTED (THOUGH POSSIBLY IGNORED) EVEN WHEN |
| * THERE IS NO SEPARATE AUDIO CHIP PRESENT. |
| */ |
| /*---------------------------------------------------------------------------*/ |
| |
| write_vt(pusb_device, 0x0002, 0x8000); |
| write_vt(pusb_device, 0x001C, 0x8000); |
| |
| write_vt(pusb_device, 0x000E, 0x0000); |
| write_vt(pusb_device, 0x0010, 0x0000); |
| write_vt(pusb_device, 0x0012, 0x8000); |
| write_vt(pusb_device, 0x0016, 0x0000); |
| |
| write_vt(pusb_device, 0x001A, 0x0404); |
| write_vt(pusb_device, 0x0002, 0x0000); |
| write_vt(pusb_device, 0x001C, 0x0000); |
| |
| check_vt(pusb_device); |
| |
| return 0; |
| } |
| /*****************************************************************************/ |
| int |
| check_vt(struct usb_device *pusb_device) |
| { |
| int igot; |
| |
| igot = read_vt(pusb_device, 0x0002); |
| if (0 > igot) |
| SAY("ERROR: failed to read VT1612A register 0x02\n"); |
| if (0x8000 & igot) |
| SAY("register 0x%02X muted\n", 0x02); |
| |
| igot = read_vt(pusb_device, 0x000E); |
| if (0 > igot) |
| SAY("ERROR: failed to read VT1612A register 0x0E\n"); |
| if (0x8000 & igot) |
| SAY("register 0x%02X muted\n", 0x0E); |
| |
| igot = read_vt(pusb_device, 0x0010); |
| if (0 > igot) |
| SAY("ERROR: failed to read VT1612A register 0x10\n"); |
| if (0x8000 & igot) |
| SAY("register 0x%02X muted\n", 0x10); |
| |
| igot = read_vt(pusb_device, 0x0012); |
| if (0 > igot) |
| SAY("ERROR: failed to read VT1612A register 0x12\n"); |
| if (0x8000 & igot) |
| SAY("register 0x%02X muted\n", 0x12); |
| |
| igot = read_vt(pusb_device, 0x0016); |
| if (0 > igot) |
| SAY("ERROR: failed to read VT1612A register 0x16\n"); |
| if (0x8000 & igot) |
| SAY("register 0x%02X muted\n", 0x16); |
| |
| igot = read_vt(pusb_device, 0x001A); |
| if (0 > igot) |
| SAY("ERROR: failed to read VT1612A register 0x1A\n"); |
| if (0x8000 & igot) |
| SAY("register 0x%02X muted\n", 0x1A); |
| |
| igot = read_vt(pusb_device, 0x001C); |
| if (0 > igot) |
| SAY("ERROR: failed to read VT1612A register 0x1C\n"); |
| if (0x8000 & igot) |
| SAY("register 0x%02X muted\n", 0x1C); |
| |
| return 0; |
| } |
| /*****************************************************************************/ |
| /*---------------------------------------------------------------------------*/ |
| /* |
| * NOTE: THIS DOES INCREASE THE VOLUME DRAMATICALLY: |
| * audio_gainset(pusb_device, 0x000F); |
| * |
| * IF 16<loud<31 VT1621A REGISTER 0x1C IS SET FOR POSITIVE GAIN. |
| * IF loud<=16 VT1621A REGISTER 0x1C IS SET FOR ZERO GAIN. |
| * THERE IS NEVER ANY (ADDITIONAL) ATTENUATION. |
| */ |
| /*---------------------------------------------------------------------------*/ |
| int |
| audio_gainset(struct usb_device *pusb_device, __s8 loud) |
| { |
| int igot; |
| __u8 u8; |
| __u16 mute; |
| |
| if (16 > loud) |
| loud = 16; |
| u8 = 0x000F & (__u8)(loud - 16); |
| |
| write_vt(pusb_device, 0x0002, 0x8000); |
| |
| igot = read_vt(pusb_device, 0x001C); |
| if (0 > igot) { |
| SAY("ERROR: failed to read VT1612A register 0x1C\n"); |
| mute = 0x0000; |
| } else |
| mute = 0x8000 & ((unsigned int)igot); |
| |
| JOT(8, "0x%04X=(mute|u8|(u8<<8))\n", mute | u8 | (u8 << 8)); |
| |
| write_vt(pusb_device, 0x001C, 0x8000); |
| write_vt(pusb_device, 0x001C, (mute | u8 | (u8 << 8))); |
| write_vt(pusb_device, 0x0002, 0x0000); |
| |
| return 0; |
| } |
| /*****************************************************************************/ |
| int |
| audio_gainget(struct usb_device *pusb_device) |
| { |
| int igot; |
| |
| igot = read_vt(pusb_device, 0x001C); |
| if (0 > igot) |
| SAY("ERROR: failed to read VT1612A register 0x1C\n"); |
| return igot; |
| } |
| /*****************************************************************************/ |
| int |
| set2to78(struct usb_device *p) |
| { |
| int ir; |
| |
| msleep(20); |
| ir = regset(p, 0x0002, 0x0078); |
| if (0 > ir) |
| SAY("ERROR: failed to set register 0x0002 to 0x0078\n"); |
| msleep(20); |
| return ir; |
| } |
| /*****************************************************************************/ |
| int |
| set2to93(struct usb_device *p) |
| { |
| int ir; |
| |
| msleep(20); |
| ir = regset(p, 0x0002, 0x0093); |
| if (0 > ir) |
| SAY("ERROR: failed to set register 0x0002 to 0x0078\n"); |
| msleep(20); |
| return ir; |
| } |
| /*****************************************************************************/ |