mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 20:02:17 +00:00
![Tomas Winkler](/assets/img/avatar_default.png)
reduce code duplication in register settings instead of if (ntsc) <CODE BLOCK> else <CODE BLOCK> use cfg = (ntsc) ? <chip>configNTSC : <chip>configPAL; <CODE BLOCK> in addition change while loops to more readable for loops Cc: Mike Thomas <rmthomas@sciolus.org> Signed-off-by: Tomas Winkler <tomas.winkler@intel.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
1129 lines
29 KiB
C
1129 lines
29 KiB
C
/*****************************************************************************
|
|
* *
|
|
* *
|
|
* 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.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;
|
|
}
|
|
/*****************************************************************************/
|