/***************************************************************************** * * * * * easycap_low.c * * * * * *****************************************************************************/ /* * * Copyright (C) 2010 R.M. Thomas * * * 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.h" #define GET(X, Y, Z) do { \ int __rc; \ *(Z) = (u16)0; \ __rc = regget(X, Y, Z, sizeof(u8)); \ if (0 > __rc) { \ JOT(8, ":-(%i\n", __LINE__); return __rc; \ } \ } while (0) #define SET(X, Y, Z) do { \ int __rc; \ __rc = regset(X, Y, Z); \ if (0 > __rc) { \ JOT(8, ":-(%i\n", __LINE__); return __rc; \ } \ } while (0) /*--------------------------------------------------------------------------*/ static const struct stk1160config { int reg; int set; } stk1160configPAL[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}, /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* * RESOLUTION 640x480 */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ {0x110, 0x0008}, {0x111, 0x0000}, {0x112, 0x0020}, {0x113, 0x0000}, {0x114, 0x0508}, {0x115, 0x0005}, {0x116, 0x0110}, {0x117, 0x0001}, /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ {0x202, 0x000F}, {0x203, 0x004A}, {0x2FF, 0x0000}, {0xFFF, 0xFFFF} }; /*--------------------------------------------------------------------------*/ static const struct stk1160config stk1160configNTSC[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}, /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* * RESOLUTION 640x480 */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ {0x110, 0x0008}, {0x111, 0x0000}, {0x112, 0x0003}, {0x113, 0x0000}, {0x114, 0x0508}, {0x115, 0x0005}, {0x116, 0x00F3}, {0x117, 0x0000}, /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ {0x202, 0x000F}, {0x203, 0x004A}, {0x2FF, 0x0000}, {0xFFF, 0xFFFF} }; /*--------------------------------------------------------------------------*/ static const struct saa7113config { int reg; int set; } saa7113configPAL[256] = { {0x01, 0x08}, {0x02, 0x80}, {0x03, 0x33}, {0x04, 0x00}, {0x05, 0x00}, {0x06, 0xE9}, {0x07, 0x0D}, {0x08, 0x38}, {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}, {0x40, 0x02}, {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}, {0x5A, 0x07}, {0x5B, 0x83}, {0xFF, 0xFF} }; /*--------------------------------------------------------------------------*/ static const struct saa7113config saa7113configNTSC[256] = { {0x01, 0x08}, {0x02, 0x80}, {0x03, 0x33}, {0x04, 0x00}, {0x05, 0x00}, {0x06, 0xE9}, {0x07, 0x0D}, {0x08, 0x78}, {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}, {0x40, 0x82}, {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}, {0x5A, 0x0A}, {0x5B, 0x83}, {0xFF, 0xFF} }; static int regget(struct usb_device *pusb_device, u16 index, void *reg, int reg_size) { int rc; if (!pusb_device) return -ENODEV; rc = usb_control_msg(pusb_device, usb_rcvctrlpipe(pusb_device, 0), 0x00, (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE), 0x00, index, reg, reg_size, 50000); return rc; } static int regset(struct usb_device *pusb_device, u16 index, u16 value) { int rc; if (!pusb_device) return -ENODEV; rc = usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0), 0x01, (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE), value, index, NULL, 0, 500); if (rc < 0) return rc; if (easycap_readback) { u16 igot = 0; rc = regget(pusb_device, index, &igot, sizeof(igot)); 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 (igot) JOT(8, "unexpected 0x%02X " "for STK register 0x%03X\n", igot, index); break; default: if ((0xFF & value) != igot) JOT(8, "unexpected 0x%02X != 0x%02X " "for STK register 0x%03X\n", igot, value, index); break; } } return rc; } /*--------------------------------------------------------------------------*/ /* * FUNCTION wait_i2c() RETURNS 0 ON SUCCESS */ /*--------------------------------------------------------------------------*/ static int wait_i2c(struct usb_device *p) { u16 get0; u8 igot; const int max = 2; int k; if (!p) return -ENODEV; for (k = 0; k < max; k++) { GET(p, 0x0201, &igot); get0 = igot; switch (get0) { case 0x04: case 0x01: return 0; case 0x00: msleep(20); continue; default: return get0 - 1; } } return -1; } /****************************************************************************/ int confirm_resolution(struct usb_device *p) { u8 get0, get1, get2, get3, get4, get5, get6, get7; if (!p) return -ENODEV; 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; if (!p) return -ENODEV; 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, bool ntsc) { int i; const struct stk1160config *cfg; if (!p) return -ENODEV; cfg = (ntsc) ? stk1160configNTSC : stk1160configPAL; for (i = 0; cfg[i].reg != 0xFFF; i++) SET(p, cfg[i].reg, cfg[i].set); write_300(p); return 0; } /****************************************************************************/ int setup_saa(struct usb_device *p, bool ntsc) { int i, ir; const struct saa7113config *cfg; if (!p) return -ENODEV; cfg = (ntsc) ? saa7113configNTSC : saa7113configPAL; for (i = 0; cfg[i].reg != 0xFF; i++) ir = write_saa(p, cfg[i].reg, cfg[i].set); return 0; } /****************************************************************************/ int write_000(struct usb_device *p, u16 set2, u16 set0) { u8 igot0, igot2; if (!p) return -ENODEV; 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) { if (!p) return -ENODEV; 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; if (!p) return -ENODEV; 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; if (!p) return -ENODEV; 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) { if (!p) return -ENODEV; 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, bool ntsc) { int i, ir, rc = 0; struct saa7113config const *cfg; if (!p) return -ENODEV; cfg = (ntsc) ? saa7113configNTSC : saa7113configPAL; for (i = 0; cfg[i].reg != 0xFF; i++) { if (0x0F == cfg[i].reg) continue; ir = read_saa(p, cfg[i].reg); if (ir != cfg[i].set) { SAY("SAA register 0x%02X has 0x%02X, expected 0x%02X\n", cfg[i].reg, ir, cfg[i].set); rc--; } } return (rc < -8) ? rc : 0; } /****************************************************************************/ int merit_saa(struct usb_device *p) { int rc; if (!p) return -ENODEV; rc = read_saa(p, 0x1F); return ((0 > rc) || (0x02 & rc)) ? 1 : 0; } /****************************************************************************/ int ready_saa(struct usb_device *p) { int j, rc, rate; const int max = 5, marktime = PATIENCE/5; /*--------------------------------------------------------------------------*/ /* * RETURNS 0 FOR INTERLACED 50 Hz * 1 FOR NON-INTERLACED 50 Hz * 2 FOR INTERLACED 60 Hz * 3 FOR NON-INTERLACED 60 Hz */ /*--------------------------------------------------------------------------*/ if (!p) return -ENODEV; j = 0; while (max > j) { rc = read_saa(p, 0x1F); if (0 <= rc) { if (0 == (0x40 & rc)) break; if (1 == (0x01 & rc)) break; } msleep(marktime); j++; } if (max == j) return -1; else { if (0x20 & rc) { rate = 2; JOT(8, "hardware detects 60 Hz\n"); } else { rate = 0; JOT(8, "hardware detects 50 Hz\n"); } if (0x80 & rc) JOT(8, "hardware detects interlacing\n"); else { rate++; 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, bool ntsc) { int i, ir; const struct stk1160config *cfg; if (!p) return -ENODEV; cfg = (ntsc) ? stk1160configNTSC : stk1160configPAL; for (i = 0; 0xFFF != cfg[i].reg; i++) { if (0x000 == cfg[i].reg || 0x002 == cfg[i].reg) continue; ir = read_stk(p, cfg[i].reg); if (0x100 == cfg[i].reg) { if ((ir != (0xFF & cfg[i].set)) && (ir != (0x80 | (0xFF & cfg[i].set))) && (0xFFFF != cfg[i].set)) { SAY("STK reg[0x%03X]=0x%02X expected 0x%02X\n", cfg[i].reg, ir, cfg[i].set); } continue; } if ((ir != (0xFF & cfg[i].set)) && (0xFFFF != cfg[i].set)) SAY("STK register 0x%03X has 0x%02X,expected 0x%02X\n", cfg[i].reg, ir, cfg[i].set); } return 0; } /****************************************************************************/ int read_saa(struct usb_device *p, u16 reg0) { u8 igot; if (!p) return -ENODEV; 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; if (!p) return -ENODEV; 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) { int ir; if (!p) return -ENODEV; stop_100(p); switch (input) { case 0: case 1: { if (0 != write_saa(p, 0x02, 0x80)) SAY("ERROR: failed to set SAA register 0x02 " "for input %i\n", input); SET(p, 0x0000, 0x0098); SET(p, 0x0002, 0x0078); break; } case 2: { if (0 != write_saa(p, 0x02, 0x80)) SAY("ERROR: failed to set SAA register 0x02 " "for input %i\n", input); SET(p, 0x0000, 0x0090); SET(p, 0x0002, 0x0078); break; } case 3: { if (0 != write_saa(p, 0x02, 0x80)) SAY("ERROR: failed to set SAA register 0x02 " " for input %i\n", input); SET(p, 0x0000, 0x0088); SET(p, 0x0002, 0x0078); break; } case 4: { if (0 != write_saa(p, 0x02, 0x80)) { SAY("ERROR: failed to set SAA register 0x02 " "for input %i\n", input); } SET(p, 0x0000, 0x0080); SET(p, 0x0002, 0x0078); 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); SET(p, 0x0002, 0x0093); break; } default: SAY("ERROR: bad input: %i\n", input); return -1; } ir = read_stk(p, 0x00); JOT(8, "STK register 0x00 has 0x%02X\n", ir); ir = read_saa(p, 0x02); JOT(8, "SAA register 0x02 has 0x%02X\n", ir); 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; if (!p) return -ENODEV; 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 get116, get117, get0; u8 igot116, igot117, igot; if (!p) return -ENODEV; GET(p, 0x0116, &igot116); get116 = igot116; GET(p, 0x0117, &igot117); get117 = igot117; SET(p, 0x0116, 0x0000); SET(p, 0x0117, 0x0000); GET(p, 0x0100, &igot); get0 = igot; SET(p, 0x0100, (0x80 | get0)); SET(p, 0x0116, get116); SET(p, 0x0117, get117); return 0; } /****************************************************************************/ int stop_100(struct usb_device *p) { u16 get0; u8 igot; if (!p) return -ENODEV; GET(p, 0x0100, &igot); get0 = igot; SET(p, 0x0100, (0x7F & get0)); return 0; } /****************************************************************************/ /****************************************************************************/ /*****************************************************************************/ int wakeup_device(struct usb_device *pusb_device) { if (!pusb_device) return -ENODEV; return usb_control_msg(pusb_device, usb_sndctrlpipe(pusb_device, 0), USB_REQ_SET_FEATURE, USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE, USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0, 50000); } /*****************************************************************************/ int audio_setup(struct easycap *peasycap) { struct usb_device *pusb_device; u8 buffer[1]; int rc, id1, id2; /*---------------------------------------------------------------------------*/ /* * 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. */ /*---------------------------------------------------------------------------*/ const u8 request = 0x01; const u8 requesttype = USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE; const u16 value_unmute = 0x0200; const u16 index = 0x0301; const u16 length = 1; if (!peasycap) return -EFAULT; pusb_device = peasycap->pusb_device; if (!pusb_device) return -ENODEV; JOM(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), request, requesttype, value_unmute, index, &buffer[0], length, 50000); JOT(8, "0x%02X=buffer\n", buffer[0]); if (rc != (int)length) { switch (rc) { case -EPIPE: SAY("usb_control_msg returned -EPIPE\n"); break; default: SAY("ERROR: usb_control_msg returned %i\n", rc); break; } } /*--------------------------------------------------------------------------*/ /* * 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); SAM("0x%04X:0x%04X is audio vendor id\n", id1, id2); /*---------------------------------------------------------------------------*/ /* * SELECT AUDIO SOURCE "LINE IN" AND SET THE AUDIO GAIN. */ /*---------------------------------------------------------------------------*/ if (0 != audio_gainset(pusb_device, peasycap->gain)) SAY("ERROR: audio_gainset() failed\n"); check_vt(pusb_device); return 0; } /*****************************************************************************/ int check_vt(struct usb_device *pusb_device) { int igot; if (!pusb_device) return -ENODEV; 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, 0x0014); if (0 > igot) SAY("ERROR: failed to read VT1612A register 0x14\n"); if (0x8000 & igot) SAY("register 0x%02X muted\n", 0x14); 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, 0x0018); if (0 > igot) SAY("ERROR: failed to read VT1612A register 0x18\n"); if (0x8000 & igot) SAY("register 0x%02X muted\n", 0x18); 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); * * loud dB register 0x10 dB register 0x1C dB total * 0 -34.5 0 -34.5 * .. .... . .... * 15 10.5 0 10.5 * 16 12.0 0 12.0 * 17 12.0 1.5 13.5 * .. .... .... .... * 31 12.0 22.5 34.5 */ /*---------------------------------------------------------------------------*/ int audio_gainset(struct usb_device *pusb_device, s8 loud) { int igot; u8 tmp; u16 mute; if (!pusb_device) return -ENODEV; if (0 > loud) loud = 0; if (31 < loud) loud = 31; write_vt(pusb_device, 0x0002, 0x8000); /*---------------------------------------------------------------------------*/ igot = read_vt(pusb_device, 0x000E); if (0 > igot) { SAY("ERROR: failed to read VT1612A register 0x0E\n"); mute = 0x0000; } else mute = 0x8000 & ((unsigned int)igot); mute = 0; if (16 > loud) tmp = 0x01 | (0x001F & (((u8)(15 - loud)) << 1)); else tmp = 0; JOT(8, "0x%04X=(mute|tmp) for VT1612A register 0x0E\n", mute | tmp); write_vt(pusb_device, 0x000E, (mute | tmp)); /*---------------------------------------------------------------------------*/ igot = read_vt(pusb_device, 0x0010); if (0 > igot) { SAY("ERROR: failed to read VT1612A register 0x10\n"); mute = 0x0000; } else mute = 0x8000 & ((unsigned int)igot); mute = 0; JOT(8, "0x%04X=(mute|tmp|(tmp<<8)) for VT1612A register 0x10,...0x18\n", mute | tmp | (tmp << 8)); write_vt(pusb_device, 0x0010, (mute | tmp | (tmp << 8))); write_vt(pusb_device, 0x0012, (mute | tmp | (tmp << 8))); write_vt(pusb_device, 0x0014, (mute | tmp | (tmp << 8))); write_vt(pusb_device, 0x0016, (mute | tmp | (tmp << 8))); write_vt(pusb_device, 0x0018, (mute | tmp | (tmp << 8))); /*---------------------------------------------------------------------------*/ 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); mute = 0; if (16 <= loud) tmp = 0x000F & (u8)(loud - 16); else tmp = 0; JOT(8, "0x%04X=(mute|tmp|(tmp<<8)) for VT1612A register 0x1C\n", mute | tmp | (tmp << 8)); write_vt(pusb_device, 0x001C, (mute | tmp | (tmp << 8))); write_vt(pusb_device, 0x001A, 0x0404); write_vt(pusb_device, 0x0002, 0x0000); return 0; } /*****************************************************************************/ int audio_gainget(struct usb_device *pusb_device) { int igot; if (!pusb_device) return -ENODEV; igot = read_vt(pusb_device, 0x001C); if (0 > igot) SAY("ERROR: failed to read VT1612A register 0x1C\n"); return igot; } /*****************************************************************************/