[PATCH] v4l: (946) adds support for cx25840 video decoder (bd985160) · Commits · e / devices / android_kernel_teracube_2e

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