[PATCH] v4l: (946) adds support for cx25840 video decoder

Adds support for cx25840 video decoder.

Driver authors: Hans Verkuil, Chris Kennedy, Tyler Trafford, Ulf Eklund.

Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: Chris Kennedy <c@groovy.org>
Signed-off-by: Tyler Trafford <tatrafford@comcast.net>
Thanks-to: Ulf Eklund <ivtv@eklund.to>.
Signed-off-by: Mauro Carvalho Chehab <mchehab@brturbo.com.br>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Hans Verkuil 2005-11-13 16:07:56 -08:00 committed by Linus Torvalds
parent b2f0648ffd
commit bd985160a9
5 changed files with 1960 additions and 0 deletions

View File

@ -0,0 +1,369 @@
/* cx25840 audio functions
*
* This program 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.
*
* This program 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 program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <linux/videodev2.h>
#include <linux/i2c.h>
#include <media/audiochip.h>
#include <media/i2c-compat.h>
#include <media/v4l2-common.h>
#include "cx25840.h"
inline static int set_audclk_freq(struct i2c_client *client,
enum v4l2_audio_clock_freq freq)
{
struct cx25840_state *state = i2c_get_clientdata(client);
/* assert soft reset */
cx25840_and_or(client, 0x810, ~0x1, 0x01);
/* common for all inputs and rates */
/* SA_MCLK_SEL=1, SA_MCLK_DIV=0x10 */
cx25840_write(client, 0x127, 0x50);
switch (state->audio_input) {
case AUDIO_TUNER:
switch (freq) {
case V4L2_AUDCLK_32_KHZ:
/* VID_PLL and AUX_PLL */
cx25840_write4(client, 0x108, 0x0f040610);
/* AUX_PLL_FRAC */
cx25840_write4(client, 0x110, 0xee39bb01);
/* src3/4/6_ctl = 0x0801f77f */
cx25840_write4(client, 0x900, 0x7ff70108);
cx25840_write4(client, 0x904, 0x7ff70108);
cx25840_write4(client, 0x90c, 0x7ff70108);
break;
case V4L2_AUDCLK_441_KHZ:
/* VID_PLL and AUX_PLL */
cx25840_write4(client, 0x108, 0x0f040910);
/* AUX_PLL_FRAC */
cx25840_write4(client, 0x110, 0xd66bec00);
/* src3/4/6_ctl = 0x08016d59 */
cx25840_write4(client, 0x900, 0x596d0108);
cx25840_write4(client, 0x904, 0x596d0108);
cx25840_write4(client, 0x90c, 0x596d0108);
break;
case V4L2_AUDCLK_48_KHZ:
/* VID_PLL and AUX_PLL */
cx25840_write4(client, 0x108, 0x0f040a10);
/* AUX_PLL_FRAC */
cx25840_write4(client, 0x110, 0xe5d69800);
/* src3/4/6_ctl = 0x08014faa */
cx25840_write4(client, 0x900, 0xaa4f0108);
cx25840_write4(client, 0x904, 0xaa4f0108);
cx25840_write4(client, 0x90c, 0xaa4f0108);
break;
}
break;
case AUDIO_EXTERN_1:
case AUDIO_EXTERN_2:
case AUDIO_INTERN:
case AUDIO_RADIO:
switch (freq) {
case V4L2_AUDCLK_32_KHZ:
/* VID_PLL and AUX_PLL */
cx25840_write4(client, 0x108, 0x0f04081e);
/* AUX_PLL_FRAC */
cx25840_write4(client, 0x110, 0x69082a01);
/* src1_ctl = 0x08010000 */
cx25840_write4(client, 0x8f8, 0x00000108);
/* src3/4/6_ctl = 0x08020000 */
cx25840_write4(client, 0x900, 0x00000208);
cx25840_write4(client, 0x904, 0x00000208);
cx25840_write4(client, 0x90c, 0x00000208);
/* SA_MCLK_SEL=1, SA_MCLK_DIV=0x14 */
cx25840_write(client, 0x127, 0x54);
break;
case V4L2_AUDCLK_441_KHZ:
/* VID_PLL and AUX_PLL */
cx25840_write4(client, 0x108, 0x0f040918);
/* AUX_PLL_FRAC */
cx25840_write4(client, 0x110, 0xd66bec00);
/* src1_ctl = 0x08010000 */
cx25840_write4(client, 0x8f8, 0xcd600108);
/* src3/4/6_ctl = 0x08020000 */
cx25840_write4(client, 0x900, 0x85730108);
cx25840_write4(client, 0x904, 0x85730108);
cx25840_write4(client, 0x90c, 0x85730108);
break;
case V4L2_AUDCLK_48_KHZ:
/* VID_PLL and AUX_PLL */
cx25840_write4(client, 0x108, 0x0f040a18);
/* AUX_PLL_FRAC */
cx25840_write4(client, 0x110, 0xe5d69800);
/* src1_ctl = 0x08010000 */
cx25840_write4(client, 0x8f8, 0x00800108);
/* src3/4/6_ctl = 0x08020000 */
cx25840_write4(client, 0x900, 0x55550108);
cx25840_write4(client, 0x904, 0x55550108);
cx25840_write4(client, 0x90c, 0x55550108);
break;
}
break;
}
/* deassert soft reset */
cx25840_and_or(client, 0x810, ~0x1, 0x00);
state->audclk_freq = freq;
return 0;
}
static int set_input(struct i2c_client *client, int audio_input)
{
struct cx25840_state *state = i2c_get_clientdata(client);
cx25840_dbg("set audio input (%d)\n", audio_input);
/* stop microcontroller */
cx25840_and_or(client, 0x803, ~0x10, 0);
/* Mute everything to prevent the PFFT! */
cx25840_write(client, 0x8d3, 0x1f);
switch (audio_input) {
case AUDIO_TUNER:
/* Set Path1 to Analog Demod Main Channel */
cx25840_write4(client, 0x8d0, 0x7038061f);
/* When the microcontroller detects the
* audio format, it will unmute the lines */
cx25840_and_or(client, 0x803, ~0x10, 0x10);
break;
case AUDIO_EXTERN_1:
case AUDIO_EXTERN_2:
case AUDIO_INTERN:
case AUDIO_RADIO:
/* Set Path1 to Serial Audio Input */
cx25840_write4(client, 0x8d0, 0x12100101);
/* The microcontroller should not be started for the
* non-tuner inputs: autodetection is specific for
* TV audio. */
break;
default:
cx25840_dbg("Invalid audio input selection %d\n", audio_input);
return -EINVAL;
}
state->audio_input = audio_input;
return set_audclk_freq(client, state->audclk_freq);
}
inline static int get_volume(struct i2c_client *client)
{
/* Volume runs +18dB to -96dB in 1/2dB steps
* change to fit the msp3400 -114dB to +12dB range */
/* check PATH1_VOLUME */
int vol = 228 - cx25840_read(client, 0x8d4);
vol = (vol / 2) + 23;
return vol << 9;
}
inline static void set_volume(struct i2c_client *client, int volume)
{
/* First convert the volume to msp3400 values (0-127) */
int vol = volume >> 9;
/* now scale it up to cx25840 values
* -114dB to -96dB maps to 0
* this should be 19, but in my testing that was 4dB too loud */
if (vol <= 23) {
vol = 0;
} else {
vol -= 23;
}
/* PATH1_VOLUME */
cx25840_write(client, 0x8d4, 228 - (vol * 2));
}
inline static int get_bass(struct i2c_client *client)
{
/* bass is 49 steps +12dB to -12dB */
/* check PATH1_EQ_BASS_VOL */
int bass = cx25840_read(client, 0x8d9) & 0x3f;
bass = (((48 - bass) * 0xffff) + 47) / 48;
return bass;
}
inline static void set_bass(struct i2c_client *client, int bass)
{
/* PATH1_EQ_BASS_VOL */
cx25840_and_or(client, 0x8d9, ~0x3f, 48 - (bass * 48 / 0xffff));
}
inline static int get_treble(struct i2c_client *client)
{
/* treble is 49 steps +12dB to -12dB */
/* check PATH1_EQ_TREBLE_VOL */
int treble = cx25840_read(client, 0x8db) & 0x3f;
treble = (((48 - treble) * 0xffff) + 47) / 48;
return treble;
}
inline static void set_treble(struct i2c_client *client, int treble)
{
/* PATH1_EQ_TREBLE_VOL */
cx25840_and_or(client, 0x8db, ~0x3f, 48 - (treble * 48 / 0xffff));
}
inline static int get_balance(struct i2c_client *client)
{
/* balance is 7 bit, 0 to -96dB */
/* check PATH1_BAL_LEVEL */
int balance = cx25840_read(client, 0x8d5) & 0x7f;
/* check PATH1_BAL_LEFT */
if ((cx25840_read(client, 0x8d5) & 0x80) == 0)
balance = 0x80 - balance;
else
balance = 0x80 + balance;
return balance << 8;
}
inline static void set_balance(struct i2c_client *client, int balance)
{
int bal = balance >> 8;
if (bal > 0x80) {
/* PATH1_BAL_LEFT */
cx25840_and_or(client, 0x8d5, 0x7f, 0x80);
/* PATH1_BAL_LEVEL */
cx25840_and_or(client, 0x8d5, ~0x7f, bal & 0x7f);
} else {
/* PATH1_BAL_LEFT */
cx25840_and_or(client, 0x8d5, 0x7f, 0x00);
/* PATH1_BAL_LEVEL */
cx25840_and_or(client, 0x8d5, ~0x7f, 0x80 - bal);
}
}
inline static int get_mute(struct i2c_client *client)
{
/* check SRC1_MUTE_EN */
return cx25840_read(client, 0x8d3) & 0x2 ? 1 : 0;
}
inline static void set_mute(struct i2c_client *client, int mute)
{
struct cx25840_state *state = i2c_get_clientdata(client);
if (state->audio_input == AUDIO_TUNER) {
/* Must turn off microcontroller in order to mute sound.
* Not sure if this is the best method, but it does work.
* If the microcontroller is running, then it will undo any
* changes to the mute register. */
if (mute) {
/* disable microcontroller */
cx25840_and_or(client, 0x803, ~0x10, 0x00);
cx25840_write(client, 0x8d3, 0x1f);
} else {
/* enable microcontroller */
cx25840_and_or(client, 0x803, ~0x10, 0x10);
}
} else {
/* SRC1_MUTE_EN */
cx25840_and_or(client, 0x8d3, ~0x2, mute ? 0x02 : 0x00);
}
}
int cx25840_audio(struct i2c_client *client, unsigned int cmd, void *arg)
{
struct v4l2_control *ctrl = arg;
switch (cmd) {
case AUDC_SET_INPUT:
return set_input(client, *(int *)arg);
case VIDIOC_INT_AUDIO_CLOCK_FREQ:
return set_audclk_freq(client, *(enum v4l2_audio_clock_freq *)arg);
case VIDIOC_G_CTRL:
switch (ctrl->id) {
case V4L2_CID_AUDIO_VOLUME:
ctrl->value = get_volume(client);
break;
case V4L2_CID_AUDIO_BASS:
ctrl->value = get_bass(client);
break;
case V4L2_CID_AUDIO_TREBLE:
ctrl->value = get_treble(client);
break;
case V4L2_CID_AUDIO_BALANCE:
ctrl->value = get_balance(client);
break;
case V4L2_CID_AUDIO_MUTE:
ctrl->value = get_mute(client);
break;
default:
return -EINVAL;
}
break;
case VIDIOC_S_CTRL:
switch (ctrl->id) {
case V4L2_CID_AUDIO_VOLUME:
set_volume(client, ctrl->value);
break;
case V4L2_CID_AUDIO_BASS:
set_bass(client, ctrl->value);
break;
case V4L2_CID_AUDIO_TREBLE:
set_treble(client, ctrl->value);
break;
case V4L2_CID_AUDIO_BALANCE:
set_balance(client, ctrl->value);
break;
case V4L2_CID_AUDIO_MUTE:
set_mute(client, ctrl->value);
break;
default:
return -EINVAL;
}
break;
default:
return -EINVAL;
}
return 0;
}

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,167 @@
/* cx25840 firmware functions
*
* This program 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.
*
* This program 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 program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/i2c-algo-bit.h>
#include <linux/firmware.h>
#include <media/v4l2-common.h>
#include "cx25840.h"
#define FWFILE "HcwMakoA.ROM"
#define FWSEND 1024
#define FWDEV(x) &((x)->adapter->dev)
static int fastfw = 1;
static char *firmware = FWFILE;
module_param(fastfw, bool, 0444);
module_param(firmware, charp, 0444);
MODULE_PARM_DESC(fastfw, "Load firmware fast [0=100MHz 1=333MHz (default)]");
MODULE_PARM_DESC(firmware, "Firmware image [default: " FWFILE "]");
static inline void set_i2c_delay(struct i2c_client *client, int delay)
{
struct i2c_algo_bit_data *algod = client->adapter->algo_data;
/* We aren't guaranteed to be using algo_bit,
* so avoid the null pointer dereference
* and disable the 'fast firmware load' */
if (algod) {
algod->udelay = delay;
} else {
fastfw = 0;
}
}
static inline void start_fw_load(struct i2c_client *client)
{
/* DL_ADDR_LB=0 DL_ADDR_HB=0 */
cx25840_write(client, 0x800, 0x00);
cx25840_write(client, 0x801, 0x00);
// DL_MAP=3 DL_AUTO_INC=0 DL_ENABLE=1
cx25840_write(client, 0x803, 0x0b);
/* AUTO_INC_DIS=1 */
cx25840_write(client, 0x000, 0x20);
if (fastfw)
set_i2c_delay(client, 3);
}
static inline void end_fw_load(struct i2c_client *client)
{
if (fastfw)
set_i2c_delay(client, 10);
/* AUTO_INC_DIS=0 */
cx25840_write(client, 0x000, 0x00);
/* DL_ENABLE=0 */
cx25840_write(client, 0x803, 0x03);
}
static inline int check_fw_load(struct i2c_client *client, int size)
{
/* DL_ADDR_HB DL_ADDR_LB */
int s = cx25840_read(client, 0x801) << 8;
s |= cx25840_read(client, 0x800);
if (size != s) {
cx25840_err("firmware %s load failed\n", firmware);
return -EINVAL;
}
cx25840_info("loaded %s firmware (%d bytes)\n", firmware, size);
return 0;
}
static inline int fw_write(struct i2c_client *client, u8 * data, int size)
{
if (i2c_master_send(client, data, size) < size) {
if (fastfw) {
cx25840_err("333MHz i2c firmware load failed\n");
fastfw = 0;
set_i2c_delay(client, 10);
if (i2c_master_send(client, data, size) < size) {
cx25840_err
("100MHz i2c firmware load failed\n");
return -ENOSYS;
}
} else {
cx25840_err("firmware load i2c failure\n");
return -ENOSYS;
}
}
return 0;
}
int cx25840_loadfw(struct i2c_client *client)
{
const struct firmware *fw = NULL;
u8 buffer[4], *ptr;
int size, send, retval;
if (request_firmware(&fw, firmware, FWDEV(client)) != 0) {
cx25840_err("unable to open firmware %s\n", firmware);
return -EINVAL;
}
start_fw_load(client);
buffer[0] = 0x08;
buffer[1] = 0x02;
buffer[2] = fw->data[0];
buffer[3] = fw->data[1];
retval = fw_write(client, buffer, 4);
if (retval < 0) {
release_firmware(fw);
return retval;
}
size = fw->size - 2;
ptr = fw->data;
while (size > 0) {
ptr[0] = 0x08;
ptr[1] = 0x02;
send = size > (FWSEND - 2) ? FWSEND : size + 2;
retval = fw_write(client, ptr, send);
if (retval < 0) {
release_firmware(fw);
return retval;
}
size -= FWSEND - 2;
ptr += FWSEND - 2;
}
end_fw_load(client);
size = fw->size;
release_firmware(fw);
return check_fw_load(client, size);
}

View File

@ -0,0 +1,315 @@
/* cx25840 VBI functions
*
* This program 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.
*
* This program 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 program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <linux/videodev2.h>
#include <linux/i2c.h>
#include <media/v4l2-common.h>
#include "cx25840.h"
static inline int odd_parity(u8 c)
{
c ^= (c >> 4);
c ^= (c >> 2);
c ^= (c >> 1);
return c & 1;
}
static inline int decode_vps(u8 * dst, u8 * p)
{
static const u8 biphase_tbl[] = {
0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
0xd2, 0x5a, 0x52, 0xd2, 0x96, 0x1e, 0x16, 0x96,
0x92, 0x1a, 0x12, 0x92, 0xd2, 0x5a, 0x52, 0xd2,
0xd0, 0x58, 0x50, 0xd0, 0x94, 0x1c, 0x14, 0x94,
0x90, 0x18, 0x10, 0x90, 0xd0, 0x58, 0x50, 0xd0,
0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
0xe1, 0x69, 0x61, 0xe1, 0xa5, 0x2d, 0x25, 0xa5,
0xa1, 0x29, 0x21, 0xa1, 0xe1, 0x69, 0x61, 0xe1,
0xc3, 0x4b, 0x43, 0xc3, 0x87, 0x0f, 0x07, 0x87,
0x83, 0x0b, 0x03, 0x83, 0xc3, 0x4b, 0x43, 0xc3,
0xc1, 0x49, 0x41, 0xc1, 0x85, 0x0d, 0x05, 0x85,
0x81, 0x09, 0x01, 0x81, 0xc1, 0x49, 0x41, 0xc1,
0xe1, 0x69, 0x61, 0xe1, 0xa5, 0x2d, 0x25, 0xa5,
0xa1, 0x29, 0x21, 0xa1, 0xe1, 0x69, 0x61, 0xe1,
0xe0, 0x68, 0x60, 0xe0, 0xa4, 0x2c, 0x24, 0xa4,
0xa0, 0x28, 0x20, 0xa0, 0xe0, 0x68, 0x60, 0xe0,
0xc2, 0x4a, 0x42, 0xc2, 0x86, 0x0e, 0x06, 0x86,
0x82, 0x0a, 0x02, 0x82, 0xc2, 0x4a, 0x42, 0xc2,
0xc0, 0x48, 0x40, 0xc0, 0x84, 0x0c, 0x04, 0x84,
0x80, 0x08, 0x00, 0x80, 0xc0, 0x48, 0x40, 0xc0,
0xe0, 0x68, 0x60, 0xe0, 0xa4, 0x2c, 0x24, 0xa4,
0xa0, 0x28, 0x20, 0xa0, 0xe0, 0x68, 0x60, 0xe0,
0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
0xd2, 0x5a, 0x52, 0xd2, 0x96, 0x1e, 0x16, 0x96,
0x92, 0x1a, 0x12, 0x92, 0xd2, 0x5a, 0x52, 0xd2,
0xd0, 0x58, 0x50, 0xd0, 0x94, 0x1c, 0x14, 0x94,
0x90, 0x18, 0x10, 0x90, 0xd0, 0x58, 0x50, 0xd0,
0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
};
u8 c, err = 0;
int i;
for (i = 0; i < 2 * 13; i += 2) {
err |= biphase_tbl[p[i]] | biphase_tbl[p[i + 1]];
c = (biphase_tbl[p[i + 1]] & 0xf) |
((biphase_tbl[p[i]] & 0xf) << 4);
dst[i / 2] = c;
}
return err & 0xf0;
}
void cx25840_vbi_setup(struct i2c_client *client)
{
v4l2_std_id std = cx25840_get_v4lstd(client);
if (std & ~V4L2_STD_NTSC) {
/* datasheet startup, step 8d */
cx25840_write(client, 0x49f, 0x11);
cx25840_write(client, 0x470, 0x84);
cx25840_write(client, 0x471, 0x00);
cx25840_write(client, 0x472, 0x2d);
cx25840_write(client, 0x473, 0x5d);
cx25840_write(client, 0x474, 0x24);
cx25840_write(client, 0x475, 0x40);
cx25840_write(client, 0x476, 0x24);
cx25840_write(client, 0x477, 0x28);
cx25840_write(client, 0x478, 0x1f);
cx25840_write(client, 0x479, 0x02);
if (std & V4L2_STD_SECAM) {
cx25840_write(client, 0x47a, 0x80);
cx25840_write(client, 0x47b, 0x00);
cx25840_write(client, 0x47c, 0x5f);
cx25840_write(client, 0x47d, 0x42);
} else {
cx25840_write(client, 0x47a, 0x90);
cx25840_write(client, 0x47b, 0x20);
cx25840_write(client, 0x47c, 0x63);
cx25840_write(client, 0x47d, 0x82);
}
cx25840_write(client, 0x47e, 0x0a);
cx25840_write(client, 0x47f, 0x01);
} else {
/* datasheet startup, step 8d */
cx25840_write(client, 0x49f, 0x14);
cx25840_write(client, 0x470, 0x7a);
cx25840_write(client, 0x471, 0x00);
cx25840_write(client, 0x472, 0x2d);
cx25840_write(client, 0x473, 0x5b);
cx25840_write(client, 0x474, 0x1a);
cx25840_write(client, 0x475, 0x70);
cx25840_write(client, 0x476, 0x1e);
cx25840_write(client, 0x477, 0x1e);
cx25840_write(client, 0x478, 0x1f);
cx25840_write(client, 0x479, 0x02);
cx25840_write(client, 0x47a, 0x50);
cx25840_write(client, 0x47b, 0x66);
cx25840_write(client, 0x47c, 0x1f);
cx25840_write(client, 0x47d, 0x7c);
cx25840_write(client, 0x47e, 0x08);
cx25840_write(client, 0x47f, 0x00);
}
}
int cx25840_vbi(struct i2c_client *client, unsigned int cmd, void *arg)
{
struct v4l2_format *fmt;
struct v4l2_sliced_vbi_format *svbi;
switch (cmd) {
case VIDIOC_G_FMT:
{
static u16 lcr2vbi[] = {
0, V4L2_SLICED_TELETEXT_B, 0, /* 1 */
0, V4L2_SLICED_WSS_625, 0, /* 4 */
V4L2_SLICED_CAPTION_525, /* 6 */
0, 0, V4L2_SLICED_VPS, 0, 0, /* 9 */
0, 0, 0, 0
};
int i;
fmt = arg;
if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
return -EINVAL;
svbi = &fmt->fmt.sliced;
memset(svbi, 0, sizeof(*svbi));
/* we're done if raw VBI is active */
if ((cx25840_read(client, 0x404) & 0x10) == 0)
break;
for (i = 7; i <= 23; i++) {
u8 v = cx25840_read(client, 0x424 + i - 7);
svbi->service_lines[0][i] = lcr2vbi[v >> 4];
svbi->service_lines[1][i] = lcr2vbi[v & 0xf];
svbi->service_set |=
svbi->service_lines[0][i] | svbi->service_lines[1][i];
}
break;
}
case VIDIOC_S_FMT:
{
int is_pal = !(cx25840_get_v4lstd(client) & V4L2_STD_NTSC);
int vbi_offset = is_pal ? 1 : 0;
int i, x;
u8 lcr[24];
fmt = arg;
if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
return -EINVAL;
svbi = &fmt->fmt.sliced;
if (svbi->service_set == 0) {
/* raw VBI */
memset(svbi, 0, sizeof(*svbi));
/* Setup VBI */
cx25840_vbi_setup(client);
/* VBI Offset */
cx25840_write(client, 0x47f, vbi_offset);
cx25840_write(client, 0x404, 0x2e);
break;
}
for (x = 0; x <= 23; x++)
lcr[x] = 0x00;
/* Setup VBI */
cx25840_vbi_setup(client);
/* Sliced VBI */
cx25840_write(client, 0x404, 0x36); /* Ancillery data */
cx25840_write(client, 0x406, 0x13);
cx25840_write(client, 0x47f, vbi_offset);
if (is_pal) {
for (i = 0; i <= 6; i++)
svbi->service_lines[0][i] =
svbi->service_lines[1][i] = 0;
} else {
for (i = 0; i <= 9; i++)
svbi->service_lines[0][i] =
svbi->service_lines[1][i] = 0;
for (i = 22; i <= 23; i++)
svbi->service_lines[0][i] =
svbi->service_lines[1][i] = 0;
}
for (i = 7; i <= 23; i++) {
for (x = 0; x <= 1; x++) {
switch (svbi->service_lines[1-x][i]) {
case V4L2_SLICED_TELETEXT_B:
lcr[i] |= 1 << (4 * x);
break;
case V4L2_SLICED_WSS_625:
lcr[i] |= 4 << (4 * x);
break;
case V4L2_SLICED_CAPTION_525:
lcr[i] |= 6 << (4 * x);
break;
case V4L2_SLICED_VPS:
lcr[i] |= 9 << (4 * x);
break;
}
}
}
for (x = 1, i = 0x424; i <= 0x434; i++, x++) {
cx25840_write(client, i, lcr[6 + x]);
}
cx25840_write(client, 0x43c, 0x16);
if (is_pal) {
cx25840_write(client, 0x474, 0x2a);
} else {
cx25840_write(client, 0x474, 0x1a + 6);
}
break;
}
case VIDIOC_INT_DECODE_VBI_LINE:
{
struct v4l2_decode_vbi_line *vbi = arg;
u8 *p = vbi->p;
int id1, id2, l, err = 0;
if (p[0] || p[1] != 0xff || p[2] != 0xff ||
(p[3] != 0x55 && p[3] != 0x91)) {
vbi->line = vbi->type = 0;
break;
}
p += 4;
id1 = p[-1];
id2 = p[0] & 0xf;
l = p[2] & 0x3f;
l += 5;
p += 4;
switch (id2) {
case 1:
id2 = V4L2_SLICED_TELETEXT_B;
break;
case 4:
id2 = V4L2_SLICED_WSS_625;
break;
case 6:
id2 = V4L2_SLICED_CAPTION_525;
err = !odd_parity(p[0]) || !odd_parity(p[1]);
break;
case 9:
id2 = V4L2_SLICED_VPS;
if (decode_vps(p, p) != 0) {
err = 1;
}
break;
default:
id2 = 0;
err = 1;
break;
}
vbi->type = err ? 0 : id2;
vbi->line = err ? 0 : l;
vbi->is_second_field = err ? 0 : (id1 == 0x55);
vbi->p = p;
break;
}
}
return 0;
}

View File

@ -0,0 +1,85 @@
/* cx25840 API header
*
* Copyright (C) 2003-2004 Chris Kennedy
*
* This program 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.
*
* This program 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 program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef _CX25840_H_
#define _CX25840_H_
#include <linux/videodev2.h>
#include <linux/i2c.h>
extern int cx25840_debug;
#define cx25840_dbg(fmt, arg...) do { if (cx25840_debug) \
printk(KERN_INFO "%s debug %d-%04x: " fmt, client->driver->name, \
i2c_adapter_id(client->adapter), client->addr , ## arg); } while (0)
#define cx25840_err(fmt, arg...) do { \
printk(KERN_ERR "%s %d-%04x: " fmt, client->driver->name, \
i2c_adapter_id(client->adapter), client->addr , ## arg); } while (0)
#define cx25840_info(fmt, arg...) do { \
printk(KERN_INFO "%s %d-%04x: " fmt, client->driver->name, \
i2c_adapter_id(client->adapter), client->addr , ## arg); } while (0)
#define CX25840_CID_CARDTYPE (V4L2_CID_PRIVATE_BASE+0)
enum cx25840_cardtype {
CARDTYPE_PVR150,
CARDTYPE_PG600
};
enum cx25840_input {
CX25840_TUNER,
CX25840_COMPOSITE0,
CX25840_COMPOSITE1,
CX25840_SVIDEO0,
CX25840_SVIDEO1
};
struct cx25840_state {
enum cx25840_cardtype cardtype;
enum cx25840_input input;
int audio_input;
enum v4l2_audio_clock_freq audclk_freq;
};
/* ----------------------------------------------------------------------- */
/* cx25850-core.c */
int cx25840_write(struct i2c_client *client, u16 addr, u8 value);
int cx25840_write4(struct i2c_client *client, u16 addr, u32 value);
u8 cx25840_read(struct i2c_client *client, u16 addr);
u32 cx25840_read4(struct i2c_client *client, u16 addr);
int cx25840_and_or(struct i2c_client *client, u16 addr, u8 mask, u8 value);
v4l2_std_id cx25840_get_v4lstd(struct i2c_client *client);
/* ----------------------------------------------------------------------- */
/* cx25850-firmware.c */
int cx25840_loadfw(struct i2c_client *client);
/* ----------------------------------------------------------------------- */
/* cx25850-audio.c */
int cx25840_audio(struct i2c_client *client, unsigned int cmd, void *arg);
/* ----------------------------------------------------------------------- */
/* cx25850-vbi.c */
void cx25840_vbi_setup(struct i2c_client *client);
int cx25840_vbi(struct i2c_client *client, unsigned int cmd, void *arg);
#endif