Commit bd985160 authored by Hans Verkuil's avatar Hans Verkuil Committed by Linus Torvalds
Browse files

[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: default avatarHans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: default avatarChris Kennedy <c@groovy.org>
Signed-off-by: default avatarTyler Trafford <tatrafford@comcast.net>
Thanks-to: Ulf Eklund <ivtv@eklund.to>.
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@brturbo.com.br>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent b2f0648f

drivers/media/video/cx25840/cx25840-audio.c

0 → 100644
+369 −0
Original line number Diff line number Diff line 
/* 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;

}

drivers/media/video/cx25840/cx25840-core.c

0 → 100644
+1024 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/media/video/cx25840/cx25840-firmware.c

0 → 100644
+167 −0
Original line number Diff line number Diff line 
/* 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);

}

drivers/media/video/cx25840/cx25840-vbi.c

0 → 100644
+315 −0
Original line number Diff line number Diff line 
/* 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;

}

drivers/media/video/cx25840/cx25840.h

0 → 100644
+85 −0
Original line number Diff line number Diff line 
/* 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

CRA Git | Maintained and supported by SUSTech CRA and CCSE