[mirror_ubuntu-artful-kernel.git] / drivers / media / i2c / bt819.c

/*
 *  bt819 - BT819A VideoStream Decoder (Rockwell Part)
 *
 * Copyright (C) 1999 Mike Bernson <mike@mlb.org>
 * Copyright (C) 1998 Dave Perks <dperks@ibm.net>
 *
 * Modifications for LML33/DC10plus unified driver
 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
 *
 * Changes by Ronald Bultje <rbultje@ronald.bitfreak.net>
 *    - moved over to linux>=2.4.x i2c protocol (9/9/2002)
 *
 * This code was modify/ported from the saa7111 driver written
 * by Dave Perks.
 *
 * 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.
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/ioctl.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/videodev2.h>
#include <linux/slab.h>
#include <media/v4l2-device.h>
#include <media/v4l2-ctrls.h>
#include <media/i2c/bt819.h>

MODULE_DESCRIPTION("Brooktree-819 video decoder driver");
MODULE_AUTHOR("Mike Bernson & Dave Perks");
MODULE_LICENSE("GPL");

static int debug;
module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "Debug level (0-1)");


/* ----------------------------------------------------------------------- */

struct bt819 {
	struct v4l2_subdev sd;
	struct v4l2_ctrl_handler hdl;
	unsigned char reg[32];

	v4l2_std_id norm;
	int input;
	int enable;
};

static inline struct bt819 *to_bt819(struct v4l2_subdev *sd)
{
	return container_of(sd, struct bt819, sd);
}

static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
{
	return &container_of(ctrl->handler, struct bt819, hdl)->sd;
}

struct timing {
	int hactive;
	int hdelay;
	int vactive;
	int vdelay;
	int hscale;
	int vscale;
};

/* for values, see the bt819 datasheet */
static struct timing timing_data[] = {
	{864 - 24, 20, 625 - 2, 1, 0x0504, 0x0000},
	{858 - 24, 20, 525 - 2, 1, 0x00f8, 0x0000},
};

/* ----------------------------------------------------------------------- */

static inline int bt819_write(struct bt819 *decoder, u8 reg, u8 value)
{
	struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);

	decoder->reg[reg] = value;
	return i2c_smbus_write_byte_data(client, reg, value);
}

static inline int bt819_setbit(struct bt819 *decoder, u8 reg, u8 bit, u8 value)
{
	return bt819_write(decoder, reg,
		(decoder->reg[reg] & ~(1 << bit)) | (value ? (1 << bit) : 0));
}

static int bt819_write_block(struct bt819 *decoder, const u8 *data, unsigned int len)
{
	struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);
	int ret = -1;
	u8 reg;

	/* the bt819 has an autoincrement function, use it if
	 * the adapter understands raw I2C */
	if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		/* do raw I2C, not smbus compatible */
		u8 block_data[32];
		int block_len;

		while (len >= 2) {
			block_len = 0;
			block_data[block_len++] = reg = data[0];
			do {
				block_data[block_len++] =
				    decoder->reg[reg++] = data[1];
				len -= 2;
				data += 2;
			} while (len >= 2 && data[0] == reg && block_len < 32);
			ret = i2c_master_send(client, block_data, block_len);
			if (ret < 0)
				break;
		}
	} else {
		/* do some slow I2C emulation kind of thing */
		while (len >= 2) {
			reg = *data++;
			ret = bt819_write(decoder, reg, *data++);
			if (ret < 0)
				break;
			len -= 2;
		}
	}

	return ret;
}

static inline int bt819_read(struct bt819 *decoder, u8 reg)
{
	struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);

	return i2c_smbus_read_byte_data(client, reg);
}

static int bt819_init(struct v4l2_subdev *sd)
{
	static unsigned char init[] = {
		/*0x1f, 0x00,*/     /* Reset */
		0x01, 0x59,	/* 0x01 input format */
		0x02, 0x00,	/* 0x02 temporal decimation */
		0x03, 0x12,	/* 0x03 Cropping msb */
		0x04, 0x16,	/* 0x04 Vertical Delay, lsb */
		0x05, 0xe0,	/* 0x05 Vertical Active lsb */
		0x06, 0x80,	/* 0x06 Horizontal Delay lsb */
		0x07, 0xd0,	/* 0x07 Horizontal Active lsb */
		0x08, 0x00,	/* 0x08 Horizontal Scaling msb */
		0x09, 0xf8,	/* 0x09 Horizontal Scaling lsb */
		0x0a, 0x00,	/* 0x0a Brightness control */
		0x0b, 0x30,	/* 0x0b Miscellaneous control */
		0x0c, 0xd8,	/* 0x0c Luma Gain lsb */
		0x0d, 0xfe,	/* 0x0d Chroma Gain (U) lsb */
		0x0e, 0xb4,	/* 0x0e Chroma Gain (V) msb */
		0x0f, 0x00,	/* 0x0f Hue control */
		0x12, 0x04,	/* 0x12 Output Format */
		0x13, 0x20,	/* 0x13 Vertial Scaling msb 0x00
					   chroma comb OFF, line drop scaling, interlace scaling
					   BUG? Why does turning the chroma comb on fuck up color?
					   Bug in the bt819 stepping on my board?
					*/
		0x14, 0x00,	/* 0x14 Vertial Scaling lsb */
		0x16, 0x07,	/* 0x16 Video Timing Polarity
					   ACTIVE=active low
					   FIELD: high=odd,
					   vreset=active high,
					   hreset=active high */
		0x18, 0x68,	/* 0x18 AGC Delay */
		0x19, 0x5d,	/* 0x19 Burst Gate Delay */
		0x1a, 0x80,	/* 0x1a ADC Interface */
	};

	struct bt819 *decoder = to_bt819(sd);
	struct timing *timing = &timing_data[(decoder->norm & V4L2_STD_525_60) ? 1 : 0];

	init[0x03 * 2 - 1] =
	    (((timing->vdelay >> 8) & 0x03) << 6) |
	    (((timing->vactive >> 8) & 0x03) << 4) |
	    (((timing->hdelay >> 8) & 0x03) << 2) |
	    ((timing->hactive >> 8) & 0x03);
	init[0x04 * 2 - 1] = timing->vdelay & 0xff;
	init[0x05 * 2 - 1] = timing->vactive & 0xff;
	init[0x06 * 2 - 1] = timing->hdelay & 0xff;
	init[0x07 * 2 - 1] = timing->hactive & 0xff;
	init[0x08 * 2 - 1] = timing->hscale >> 8;
	init[0x09 * 2 - 1] = timing->hscale & 0xff;
	/* 0x15 in array is address 0x19 */
	init[0x15 * 2 - 1] = (decoder->norm & V4L2_STD_625_50) ? 115 : 93;	/* Chroma burst delay */
	/* reset */
	bt819_write(decoder, 0x1f, 0x00);
	mdelay(1);

	/* init */
	return bt819_write_block(decoder, init, sizeof(init));
}

/* ----------------------------------------------------------------------- */

static int bt819_status(struct v4l2_subdev *sd, u32 *pstatus, v4l2_std_id *pstd)
{
	struct bt819 *decoder = to_bt819(sd);
	int status = bt819_read(decoder, 0x00);
	int res = V4L2_IN_ST_NO_SIGNAL;
	v4l2_std_id std = pstd ? *pstd : V4L2_STD_ALL;

	if ((status & 0x80))
		res = 0;
	else
		std = V4L2_STD_UNKNOWN;

	if ((status & 0x10))
		std &= V4L2_STD_PAL;
	else
		std &= V4L2_STD_NTSC;
	if (pstd)
		*pstd = std;
	if (pstatus)
		*pstatus = res;

	v4l2_dbg(1, debug, sd, "get status %x\n", status);
	return 0;
}

static int bt819_querystd(struct v4l2_subdev *sd, v4l2_std_id *std)
{
	return bt819_status(sd, NULL, std);
}

static int bt819_g_input_status(struct v4l2_subdev *sd, u32 *status)
{
	return bt819_status(sd, status, NULL);
}

static int bt819_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
{
	struct bt819 *decoder = to_bt819(sd);
	struct timing *timing = NULL;

	v4l2_dbg(1, debug, sd, "set norm %llx\n", (unsigned long long)std);

	if (sd->v4l2_dev == NULL || sd->v4l2_dev->notify == NULL)
		v4l2_err(sd, "no notify found!\n");

	if (std & V4L2_STD_NTSC) {
		v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
		bt819_setbit(decoder, 0x01, 0, 1);
		bt819_setbit(decoder, 0x01, 1, 0);
		bt819_setbit(decoder, 0x01, 5, 0);
		bt819_write(decoder, 0x18, 0x68);
		bt819_write(decoder, 0x19, 0x5d);
		/* bt819_setbit(decoder, 0x1a,  5, 1); */
		timing = &timing_data[1];
	} else if (std & V4L2_STD_PAL) {
		v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
		bt819_setbit(decoder, 0x01, 0, 1);
		bt819_setbit(decoder, 0x01, 1, 1);
		bt819_setbit(decoder, 0x01, 5, 1);
		bt819_write(decoder, 0x18, 0x7f);
		bt819_write(decoder, 0x19, 0x72);
		/* bt819_setbit(decoder, 0x1a,  5, 0); */
		timing = &timing_data[0];
	} else {
		v4l2_dbg(1, debug, sd, "unsupported norm %llx\n",
				(unsigned long long)std);
		return -EINVAL;
	}
	bt819_write(decoder, 0x03,
			(((timing->vdelay >> 8) & 0x03) << 6) |
			(((timing->vactive >> 8) & 0x03) << 4) |
			(((timing->hdelay >> 8) & 0x03) << 2) |
			((timing->hactive >> 8) & 0x03));
	bt819_write(decoder, 0x04, timing->vdelay & 0xff);
	bt819_write(decoder, 0x05, timing->vactive & 0xff);
	bt819_write(decoder, 0x06, timing->hdelay & 0xff);
	bt819_write(decoder, 0x07, timing->hactive & 0xff);
	bt819_write(decoder, 0x08, (timing->hscale >> 8) & 0xff);
	bt819_write(decoder, 0x09, timing->hscale & 0xff);
	decoder->norm = std;
	v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, NULL);
	return 0;
}

static int bt819_s_routing(struct v4l2_subdev *sd,
			   u32 input, u32 output, u32 config)
{
	struct bt819 *decoder = to_bt819(sd);

	v4l2_dbg(1, debug, sd, "set input %x\n", input);

	if (input > 7)
		return -EINVAL;

	if (sd->v4l2_dev == NULL || sd->v4l2_dev->notify == NULL)
		v4l2_err(sd, "no notify found!\n");

	if (decoder->input != input) {
		v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
		decoder->input = input;
		/* select mode */
		if (decoder->input == 0) {
			bt819_setbit(decoder, 0x0b, 6, 0);
			bt819_setbit(decoder, 0x1a, 1, 1);
		} else {
			bt819_setbit(decoder, 0x0b, 6, 1);
			bt819_setbit(decoder, 0x1a, 1, 0);
		}
		v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, NULL);
	}
	return 0;
}

static int bt819_s_stream(struct v4l2_subdev *sd, int enable)
{
	struct bt819 *decoder = to_bt819(sd);

	v4l2_dbg(1, debug, sd, "enable output %x\n", enable);

	if (decoder->enable != enable) {
		decoder->enable = enable;
		bt819_setbit(decoder, 0x16, 7, !enable);
	}
	return 0;
}

static int bt819_s_ctrl(struct v4l2_ctrl *ctrl)
{
	struct v4l2_subdev *sd = to_sd(ctrl);
	struct bt819 *decoder = to_bt819(sd);
	int temp;

	switch (ctrl->id) {
	case V4L2_CID_BRIGHTNESS:
		bt819_write(decoder, 0x0a, ctrl->val);
		break;

	case V4L2_CID_CONTRAST:
		bt819_write(decoder, 0x0c, ctrl->val & 0xff);
		bt819_setbit(decoder, 0x0b, 2, ((ctrl->val >> 8) & 0x01));
		break;

	case V4L2_CID_SATURATION:
		bt819_write(decoder, 0x0d, (ctrl->val >> 7) & 0xff);
		bt819_setbit(decoder, 0x0b, 1, ((ctrl->val >> 15) & 0x01));

		/* Ratio between U gain and V gain must stay the same as
		   the ratio between the default U and V gain values. */
		temp = (ctrl->val * 180) / 254;
		bt819_write(decoder, 0x0e, (temp >> 7) & 0xff);
		bt819_setbit(decoder, 0x0b, 0, (temp >> 15) & 0x01);
		break;

	case V4L2_CID_HUE:
		bt819_write(decoder, 0x0f, ctrl->val);
		break;

	default:
		return -EINVAL;
	}
	return 0;
}

/* ----------------------------------------------------------------------- */

static const struct v4l2_ctrl_ops bt819_ctrl_ops = {
	.s_ctrl = bt819_s_ctrl,
};

static const struct v4l2_subdev_video_ops bt819_video_ops = {
	.s_std = bt819_s_std,
	.s_routing = bt819_s_routing,
	.s_stream = bt819_s_stream,
	.querystd = bt819_querystd,
	.g_input_status = bt819_g_input_status,
};

static const struct v4l2_subdev_ops bt819_ops = {
	.video = &bt819_video_ops,
};

/* ----------------------------------------------------------------------- */

static int bt819_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	int i, ver;
	struct bt819 *decoder;
	struct v4l2_subdev *sd;
	const char *name;

	/* Check if the adapter supports the needed features */
	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -ENODEV;

	decoder = devm_kzalloc(&client->dev, sizeof(*decoder), GFP_KERNEL);
	if (decoder == NULL)
		return -ENOMEM;
	sd = &decoder->sd;
	v4l2_i2c_subdev_init(sd, client, &bt819_ops);

	ver = bt819_read(decoder, 0x17);
	switch (ver & 0xf0) {
	case 0x70:
		name = "bt819a";
		break;
	case 0x60:
		name = "bt817a";
		break;
	case 0x20:
		name = "bt815a";
		break;
	default:
		v4l2_dbg(1, debug, sd,
			"unknown chip version 0x%02x\n", ver);
		return -ENODEV;
	}

	v4l_info(client, "%s found @ 0x%x (%s)\n", name,
			client->addr << 1, client->adapter->name);

	decoder->norm = V4L2_STD_NTSC;
	decoder->input = 0;
	decoder->enable = 1;

	i = bt819_init(sd);
	if (i < 0)
		v4l2_dbg(1, debug, sd, "init status %d\n", i);

	v4l2_ctrl_handler_init(&decoder->hdl, 4);
	v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
			V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
	v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
			V4L2_CID_CONTRAST, 0, 511, 1, 0xd8);
	v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
			V4L2_CID_SATURATION, 0, 511, 1, 0xfe);
	v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
			V4L2_CID_HUE, -128, 127, 1, 0);
	sd->ctrl_handler = &decoder->hdl;
	if (decoder->hdl.error) {
		int err = decoder->hdl.error;

		v4l2_ctrl_handler_free(&decoder->hdl);
		return err;
	}
	v4l2_ctrl_handler_setup(&decoder->hdl);
	return 0;
}

static int bt819_remove(struct i2c_client *client)
{
	struct v4l2_subdev *sd = i2c_get_clientdata(client);
	struct bt819 *decoder = to_bt819(sd);

	v4l2_device_unregister_subdev(sd);
	v4l2_ctrl_handler_free(&decoder->hdl);
	return 0;
}

/* ----------------------------------------------------------------------- */

static const struct i2c_device_id bt819_id[] = {
	{ "bt819a", 0 },
	{ "bt817a", 0 },
	{ "bt815a", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, bt819_id);

static struct i2c_driver bt819_driver = {
	.driver = {
		.name	= "bt819",
	},
	.probe		= bt819_probe,
	.remove		= bt819_remove,
	.id_table	= bt819_id,
};

module_i2c_driver(bt819_driver);
Commit	Line	Data
	1	/*
	2	* bt819 - BT819A VideoStream Decoder (Rockwell Part)
	3	*
	4	* Copyright (C) 1999 Mike Bernson <mike@mlb.org>
	5	* Copyright (C) 1998 Dave Perks <dperks@ibm.net>
	6	*
	7	* Modifications for LML33/DC10plus unified driver
	8	* Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
	9	*
	10	* Changes by Ronald Bultje <rbultje@ronald.bitfreak.net>
	11	* - moved over to linux>=2.4.x i2c protocol (9/9/2002)
	12	*
	13	* This code was modify/ported from the saa7111 driver written
	14	* by Dave Perks.
	15	*
	16	* This program is free software; you can redistribute it and/or modify
	17	* it under the terms of the GNU General Public License as published by
	18	* the Free Software Foundation; either version 2 of the License, or
	19	* (at your option) any later version.
	20	*
	21	* This program is distributed in the hope that it will be useful,
	22	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	23	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	24	* GNU General Public License for more details.
	25	*/
	26
	27	#include <linux/module.h>
	28	#include <linux/types.h>
	29	#include <linux/ioctl.h>
	30	#include <linux/delay.h>
	31	#include <linux/i2c.h>
	32	#include <linux/videodev2.h>
	33	#include <linux/slab.h>
	34	#include <media/v4l2-device.h>
	35	#include <media/v4l2-ctrls.h>
	36	#include <media/i2c/bt819.h>
	37
	38	MODULE_DESCRIPTION("Brooktree-819 video decoder driver");
	39	MODULE_AUTHOR("Mike Bernson & Dave Perks");
	40	MODULE_LICENSE("GPL");
	41
	42	static int debug;
	43	module_param(debug, int, 0);
	44	MODULE_PARM_DESC(debug, "Debug level (0-1)");
	45
	46
	47	/* ----------------------------------------------------------------------- */
	48
	49	struct bt819 {
	50	struct v4l2_subdev sd;
	51	struct v4l2_ctrl_handler hdl;
	52	unsigned char reg[32];
	53
	54	v4l2_std_id norm;
	55	int input;
	56	int enable;
	57	};
	58
	59	static inline struct bt819 to_bt819(struct v4l2_subdev sd)
	60	{
	61	return container_of(sd, struct bt819, sd);
	62	}
	63
	64	static inline struct v4l2_subdev to_sd(struct v4l2_ctrl ctrl)
	65	{
	66	return &container_of(ctrl->handler, struct bt819, hdl)->sd;
	67	}
	68
	69	struct timing {
	70	int hactive;
	71	int hdelay;
	72	int vactive;
	73	int vdelay;
	74	int hscale;
	75	int vscale;
	76	};
	77
	78	/* for values, see the bt819 datasheet */
	79	static struct timing timing_data[] = {
	80	{864 - 24, 20, 625 - 2, 1, 0x0504, 0x0000},
	81	{858 - 24, 20, 525 - 2, 1, 0x00f8, 0x0000},
	82	};
	83
	84	/* ----------------------------------------------------------------------- */
	85
	86	static inline int bt819_write(struct bt819 *decoder, u8 reg, u8 value)
	87	{
	88	struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);
	89
	90	decoder->reg[reg] = value;
	91	return i2c_smbus_write_byte_data(client, reg, value);
	92	}
	93
	94	static inline int bt819_setbit(struct bt819 *decoder, u8 reg, u8 bit, u8 value)
	95	{
	96	return bt819_write(decoder, reg,
	97	(decoder->reg[reg] & ~(1 << bit)) \| (value ? (1 << bit) : 0));
	98	}
	99
	100	static int bt819_write_block(struct bt819 decoder, const u8 data, unsigned int len)
	101	{
	102	struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);
	103	int ret = -1;
	104	u8 reg;
	105
	106	/* the bt819 has an autoincrement function, use it if
	107	* the adapter understands raw I2C */
	108	if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
	109	/* do raw I2C, not smbus compatible */
	110	u8 block_data[32];
	111	int block_len;
	112
	113	while (len >= 2) {
	114	block_len = 0;
	115	block_data[block_len++] = reg = data[0];
	116	do {
	117	block_data[block_len++] =
	118	decoder->reg[reg++] = data[1];
	119	len -= 2;
	120	data += 2;
	121	} while (len >= 2 && data[0] == reg && block_len < 32);
	122	ret = i2c_master_send(client, block_data, block_len);
	123	if (ret < 0)
	124	break;
	125	}
	126	} else {
	127	/* do some slow I2C emulation kind of thing */
	128	while (len >= 2) {
	129	reg = *data++;
	130	ret = bt819_write(decoder, reg, *data++);
	131	if (ret < 0)
	132	break;
	133	len -= 2;
	134	}
	135	}
	136
	137	return ret;
	138	}
	139
	140	static inline int bt819_read(struct bt819 *decoder, u8 reg)
	141	{
	142	struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);
	143
	144	return i2c_smbus_read_byte_data(client, reg);
	145	}
	146
	147	static int bt819_init(struct v4l2_subdev *sd)
	148	{
	149	static unsigned char init[] = {
	150	/0x1f, 0x00,/ /* Reset */
	151	0x01, 0x59, /* 0x01 input format */
	152	0x02, 0x00, /* 0x02 temporal decimation */
	153	0x03, 0x12, /* 0x03 Cropping msb */
	154	0x04, 0x16, /* 0x04 Vertical Delay, lsb */
	155	0x05, 0xe0, /* 0x05 Vertical Active lsb */
	156	0x06, 0x80, /* 0x06 Horizontal Delay lsb */
	157	0x07, 0xd0, /* 0x07 Horizontal Active lsb */
	158	0x08, 0x00, /* 0x08 Horizontal Scaling msb */
	159	0x09, 0xf8, /* 0x09 Horizontal Scaling lsb */
	160	0x0a, 0x00, /* 0x0a Brightness control */
	161	0x0b, 0x30, /* 0x0b Miscellaneous control */
	162	0x0c, 0xd8, /* 0x0c Luma Gain lsb */
	163	0x0d, 0xfe, /* 0x0d Chroma Gain (U) lsb */
	164	0x0e, 0xb4, /* 0x0e Chroma Gain (V) msb */
	165	0x0f, 0x00, /* 0x0f Hue control */
	166	0x12, 0x04, /* 0x12 Output Format */
	167	0x13, 0x20, /* 0x13 Vertial Scaling msb 0x00
	168	chroma comb OFF, line drop scaling, interlace scaling
	169	BUG? Why does turning the chroma comb on fuck up color?
	170	Bug in the bt819 stepping on my board?
	171	*/
	172	0x14, 0x00, /* 0x14 Vertial Scaling lsb */
	173	0x16, 0x07, /* 0x16 Video Timing Polarity
	174	ACTIVE=active low
	175	FIELD: high=odd,
	176	vreset=active high,
	177	hreset=active high */
	178	0x18, 0x68, /* 0x18 AGC Delay */
	179	0x19, 0x5d, /* 0x19 Burst Gate Delay */
	180	0x1a, 0x80, /* 0x1a ADC Interface */
	181	};
	182
	183	struct bt819 *decoder = to_bt819(sd);
	184	struct timing *timing = &timing_data[(decoder->norm & V4L2_STD_525_60) ? 1 : 0];
	185
	186	init[0x03 * 2 - 1] =
	187	(((timing->vdelay >> 8) & 0x03) << 6) \|
	188	(((timing->vactive >> 8) & 0x03) << 4) \|
	189	(((timing->hdelay >> 8) & 0x03) << 2) \|
	190	((timing->hactive >> 8) & 0x03);
	191	init[0x04 * 2 - 1] = timing->vdelay & 0xff;
	192	init[0x05 * 2 - 1] = timing->vactive & 0xff;
	193	init[0x06 * 2 - 1] = timing->hdelay & 0xff;
	194	init[0x07 * 2 - 1] = timing->hactive & 0xff;
	195	init[0x08 * 2 - 1] = timing->hscale >> 8;
	196	init[0x09 * 2 - 1] = timing->hscale & 0xff;
	197	/* 0x15 in array is address 0x19 */
	198	init[0x15 * 2 - 1] = (decoder->norm & V4L2_STD_625_50) ? 115 : 93; /* Chroma burst delay */
	199	/* reset */
	200	bt819_write(decoder, 0x1f, 0x00);
	201	mdelay(1);
	202
	203	/* init */
	204	return bt819_write_block(decoder, init, sizeof(init));
	205	}
	206
	207	/* ----------------------------------------------------------------------- */
	208
	209	static int bt819_status(struct v4l2_subdev sd, u32 pstatus, v4l2_std_id *pstd)
	210	{
	211	struct bt819 *decoder = to_bt819(sd);
	212	int status = bt819_read(decoder, 0x00);
	213	int res = V4L2_IN_ST_NO_SIGNAL;
	214	v4l2_std_id std = pstd ? *pstd : V4L2_STD_ALL;
	215
	216	if ((status & 0x80))
	217	res = 0;
	218	else
	219	std = V4L2_STD_UNKNOWN;
	220
	221	if ((status & 0x10))
	222	std &= V4L2_STD_PAL;
	223	else
	224	std &= V4L2_STD_NTSC;
	225	if (pstd)
	226	*pstd = std;
	227	if (pstatus)
	228	*pstatus = res;
	229
	230	v4l2_dbg(1, debug, sd, "get status %x\n", status);
	231	return 0;
	232	}
	233
	234	static int bt819_querystd(struct v4l2_subdev sd, v4l2_std_id std)
	235	{
	236	return bt819_status(sd, NULL, std);
	237	}
	238
	239	static int bt819_g_input_status(struct v4l2_subdev sd, u32 status)
	240	{
	241	return bt819_status(sd, status, NULL);
	242	}
	243
	244	static int bt819_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
	245	{
	246	struct bt819 *decoder = to_bt819(sd);
	247	struct timing *timing = NULL;
	248
	249	v4l2_dbg(1, debug, sd, "set norm %llx\n", (unsigned long long)std);
	250
	251	if (sd->v4l2_dev == NULL \|\| sd->v4l2_dev->notify == NULL)
	252	v4l2_err(sd, "no notify found!\n");
	253
	254	if (std & V4L2_STD_NTSC) {
	255	v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
	256	bt819_setbit(decoder, 0x01, 0, 1);
	257	bt819_setbit(decoder, 0x01, 1, 0);
	258	bt819_setbit(decoder, 0x01, 5, 0);
	259	bt819_write(decoder, 0x18, 0x68);
	260	bt819_write(decoder, 0x19, 0x5d);
	261	/* bt819_setbit(decoder, 0x1a, 5, 1); */
	262	timing = &timing_data[1];
	263	} else if (std & V4L2_STD_PAL) {
	264	v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
	265	bt819_setbit(decoder, 0x01, 0, 1);
	266	bt819_setbit(decoder, 0x01, 1, 1);
	267	bt819_setbit(decoder, 0x01, 5, 1);
	268	bt819_write(decoder, 0x18, 0x7f);
	269	bt819_write(decoder, 0x19, 0x72);
	270	/* bt819_setbit(decoder, 0x1a, 5, 0); */
	271	timing = &timing_data[0];
	272	} else {
	273	v4l2_dbg(1, debug, sd, "unsupported norm %llx\n",
	274	(unsigned long long)std);
	275	return -EINVAL;
	276	}
	277	bt819_write(decoder, 0x03,
	278	(((timing->vdelay >> 8) & 0x03) << 6) \|
	279	(((timing->vactive >> 8) & 0x03) << 4) \|
	280	(((timing->hdelay >> 8) & 0x03) << 2) \|
	281	((timing->hactive >> 8) & 0x03));
	282	bt819_write(decoder, 0x04, timing->vdelay & 0xff);
	283	bt819_write(decoder, 0x05, timing->vactive & 0xff);
	284	bt819_write(decoder, 0x06, timing->hdelay & 0xff);
	285	bt819_write(decoder, 0x07, timing->hactive & 0xff);
	286	bt819_write(decoder, 0x08, (timing->hscale >> 8) & 0xff);
	287	bt819_write(decoder, 0x09, timing->hscale & 0xff);
	288	decoder->norm = std;
	289	v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, NULL);
	290	return 0;
	291	}
	292
	293	static int bt819_s_routing(struct v4l2_subdev *sd,
	294	u32 input, u32 output, u32 config)
	295	{
	296	struct bt819 *decoder = to_bt819(sd);
	297
	298	v4l2_dbg(1, debug, sd, "set input %x\n", input);
	299
	300	if (input > 7)
	301	return -EINVAL;
	302
	303	if (sd->v4l2_dev == NULL \|\| sd->v4l2_dev->notify == NULL)
	304	v4l2_err(sd, "no notify found!\n");
	305
	306	if (decoder->input != input) {
	307	v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
	308	decoder->input = input;
	309	/* select mode */
	310	if (decoder->input == 0) {
	311	bt819_setbit(decoder, 0x0b, 6, 0);
	312	bt819_setbit(decoder, 0x1a, 1, 1);
	313	} else {
	314	bt819_setbit(decoder, 0x0b, 6, 1);
	315	bt819_setbit(decoder, 0x1a, 1, 0);
	316	}
	317	v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, NULL);
	318	}
	319	return 0;
	320	}
	321
	322	static int bt819_s_stream(struct v4l2_subdev *sd, int enable)
	323	{
	324	struct bt819 *decoder = to_bt819(sd);
	325
	326	v4l2_dbg(1, debug, sd, "enable output %x\n", enable);
	327
	328	if (decoder->enable != enable) {
	329	decoder->enable = enable;
	330	bt819_setbit(decoder, 0x16, 7, !enable);
	331	}
	332	return 0;
	333	}
	334
	335	static int bt819_s_ctrl(struct v4l2_ctrl *ctrl)
	336	{
	337	struct v4l2_subdev *sd = to_sd(ctrl);
	338	struct bt819 *decoder = to_bt819(sd);
	339	int temp;
	340
	341	switch (ctrl->id) {
	342	case V4L2_CID_BRIGHTNESS:
	343	bt819_write(decoder, 0x0a, ctrl->val);
	344	break;
	345
	346	case V4L2_CID_CONTRAST:
	347	bt819_write(decoder, 0x0c, ctrl->val & 0xff);
	348	bt819_setbit(decoder, 0x0b, 2, ((ctrl->val >> 8) & 0x01));
	349	break;
	350
	351	case V4L2_CID_SATURATION:
	352	bt819_write(decoder, 0x0d, (ctrl->val >> 7) & 0xff);
	353	bt819_setbit(decoder, 0x0b, 1, ((ctrl->val >> 15) & 0x01));
	354
	355	/* Ratio between U gain and V gain must stay the same as
	356	the ratio between the default U and V gain values. */
	357	temp = (ctrl->val * 180) / 254;
	358	bt819_write(decoder, 0x0e, (temp >> 7) & 0xff);
	359	bt819_setbit(decoder, 0x0b, 0, (temp >> 15) & 0x01);
	360	break;
	361
	362	case V4L2_CID_HUE:
	363	bt819_write(decoder, 0x0f, ctrl->val);
	364	break;
	365
	366	default:
	367	return -EINVAL;
	368	}
	369	return 0;
	370	}
	371
	372	/* ----------------------------------------------------------------------- */
	373
	374	static const struct v4l2_ctrl_ops bt819_ctrl_ops = {
	375	.s_ctrl = bt819_s_ctrl,
	376	};
	377
	378	static const struct v4l2_subdev_video_ops bt819_video_ops = {
	379	.s_std = bt819_s_std,
	380	.s_routing = bt819_s_routing,
	381	.s_stream = bt819_s_stream,
	382	.querystd = bt819_querystd,
	383	.g_input_status = bt819_g_input_status,
	384	};
	385
	386	static const struct v4l2_subdev_ops bt819_ops = {
	387	.video = &bt819_video_ops,
	388	};
	389
	390	/* ----------------------------------------------------------------------- */
	391
	392	static int bt819_probe(struct i2c_client *client,
	393	const struct i2c_device_id *id)
	394	{
	395	int i, ver;
	396	struct bt819 *decoder;
	397	struct v4l2_subdev *sd;
	398	const char *name;
	399
	400	/* Check if the adapter supports the needed features */
	401	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
	402	return -ENODEV;
	403
	404	decoder = devm_kzalloc(&client->dev, sizeof(*decoder), GFP_KERNEL);
	405	if (decoder == NULL)
	406	return -ENOMEM;
	407	sd = &decoder->sd;
	408	v4l2_i2c_subdev_init(sd, client, &bt819_ops);
	409
	410	ver = bt819_read(decoder, 0x17);
	411	switch (ver & 0xf0) {
	412	case 0x70:
	413	name = "bt819a";
	414	break;
	415	case 0x60:
	416	name = "bt817a";
	417	break;
	418	case 0x20:
	419	name = "bt815a";
	420	break;
	421	default:
	422	v4l2_dbg(1, debug, sd,
	423	"unknown chip version 0x%02x\n", ver);
	424	return -ENODEV;
	425	}
	426
	427	v4l_info(client, "%s found @ 0x%x (%s)\n", name,
	428	client->addr << 1, client->adapter->name);
	429
	430	decoder->norm = V4L2_STD_NTSC;
	431	decoder->input = 0;
	432	decoder->enable = 1;
	433
	434	i = bt819_init(sd);
	435	if (i < 0)
	436	v4l2_dbg(1, debug, sd, "init status %d\n", i);
	437
	438	v4l2_ctrl_handler_init(&decoder->hdl, 4);
	439	v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
	440	V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
	441	v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
	442	V4L2_CID_CONTRAST, 0, 511, 1, 0xd8);
	443	v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
	444	V4L2_CID_SATURATION, 0, 511, 1, 0xfe);
	445	v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
	446	V4L2_CID_HUE, -128, 127, 1, 0);
	447	sd->ctrl_handler = &decoder->hdl;
	448	if (decoder->hdl.error) {
	449	int err = decoder->hdl.error;
	450
	451	v4l2_ctrl_handler_free(&decoder->hdl);
	452	return err;
	453	}
	454	v4l2_ctrl_handler_setup(&decoder->hdl);
	455	return 0;
	456	}
	457
	458	static int bt819_remove(struct i2c_client *client)
	459	{
	460	struct v4l2_subdev *sd = i2c_get_clientdata(client);
	461	struct bt819 *decoder = to_bt819(sd);
	462
	463	v4l2_device_unregister_subdev(sd);
	464	v4l2_ctrl_handler_free(&decoder->hdl);
	465	return 0;
	466	}
	467
	468	/* ----------------------------------------------------------------------- */
	469
	470	static const struct i2c_device_id bt819_id[] = {
	471	{ "bt819a", 0 },
	472	{ "bt817a", 0 },
	473	{ "bt815a", 0 },
	474	{ }
	475	};
	476	MODULE_DEVICE_TABLE(i2c, bt819_id);
	477
	478	static struct i2c_driver bt819_driver = {
	479	.driver = {
	480	.name = "bt819",
	481	},
	482	.probe = bt819_probe,
	483	.remove = bt819_remove,
	484	.id_table = bt819_id,
	485	};
	486
	487	module_i2c_driver(bt819_driver);