[net-next-2.6.git] / drivers / media / video / bt8xx / bttv-i2c.c

/*

    bttv-i2c.c  --  all the i2c code is here

    bttv - Bt848 frame grabber driver

    Copyright (C) 1996,97,98 Ralph  Metzler (rjkm@thp.uni-koeln.de)
			   & Marcus Metzler (mocm@thp.uni-koeln.de)
    (c) 1999-2003 Gerd Knorr <kraxel@bytesex.org>

    (c) 2005 Mauro Carvalho Chehab <mchehab@infradead.org>
	- Multituner support and i2c address binding

    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., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include <linux/module.h>
#include <linux/init.h>
#include <linux/delay.h>

#include "bttvp.h"
#include <media/v4l2-common.h>
#include <linux/jiffies.h>
#include <asm/io.h>

static int i2c_debug;
static int i2c_hw;
static int i2c_scan;
module_param(i2c_debug, int, 0644);
MODULE_PARM_DESC(i2c_debug, "configure i2c debug level");
module_param(i2c_hw,    int, 0444);
MODULE_PARM_DESC(i2c_hw,"force use of hardware i2c support, "
			"instead of software bitbang");
module_param(i2c_scan,  int, 0444);
MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");

static unsigned int i2c_udelay = 5;
module_param(i2c_udelay, int, 0444);
MODULE_PARM_DESC(i2c_udelay,"soft i2c delay at insmod time, in usecs "
		"(should be 5 or higher). Lower value means higher bus speed.");

/* ----------------------------------------------------------------------- */
/* I2C functions - bitbanging adapter (software i2c)                       */

static void bttv_bit_setscl(void *data, int state)
{
	struct bttv *btv = (struct bttv*)data;

	if (state)
		btv->i2c_state |= 0x02;
	else
		btv->i2c_state &= ~0x02;
	btwrite(btv->i2c_state, BT848_I2C);
	btread(BT848_I2C);
}

static void bttv_bit_setsda(void *data, int state)
{
	struct bttv *btv = (struct bttv*)data;

	if (state)
		btv->i2c_state |= 0x01;
	else
		btv->i2c_state &= ~0x01;
	btwrite(btv->i2c_state, BT848_I2C);
	btread(BT848_I2C);
}

static int bttv_bit_getscl(void *data)
{
	struct bttv *btv = (struct bttv*)data;
	int state;

	state = btread(BT848_I2C) & 0x02 ? 1 : 0;
	return state;
}

static int bttv_bit_getsda(void *data)
{
	struct bttv *btv = (struct bttv*)data;
	int state;

	state = btread(BT848_I2C) & 0x01;
	return state;
}

static struct i2c_algo_bit_data __devinitdata bttv_i2c_algo_bit_template = {
	.setsda  = bttv_bit_setsda,
	.setscl  = bttv_bit_setscl,
	.getsda  = bttv_bit_getsda,
	.getscl  = bttv_bit_getscl,
	.udelay  = 16,
	.timeout = 200,
};

/* ----------------------------------------------------------------------- */
/* I2C functions - hardware i2c                                            */

static u32 functionality(struct i2c_adapter *adap)
{
	return I2C_FUNC_SMBUS_EMUL;
}

static int
bttv_i2c_wait_done(struct bttv *btv)
{
	int rc = 0;

	/* timeout */
	if (wait_event_interruptible_timeout(btv->i2c_queue,
		btv->i2c_done, msecs_to_jiffies(85)) == -ERESTARTSYS)

	rc = -EIO;

	if (btv->i2c_done & BT848_INT_RACK)
		rc = 1;
	btv->i2c_done = 0;
	return rc;
}

#define I2C_HW (BT878_I2C_MODE  | BT848_I2C_SYNC |\
		BT848_I2C_SCL | BT848_I2C_SDA)

static int
bttv_i2c_sendbytes(struct bttv *btv, const struct i2c_msg *msg, int last)
{
	u32 xmit;
	int retval,cnt;

	/* sanity checks */
	if (0 == msg->len)
		return -EINVAL;

	/* start, address + first byte */
	xmit = (msg->addr << 25) | (msg->buf[0] << 16) | I2C_HW;
	if (msg->len > 1 || !last)
		xmit |= BT878_I2C_NOSTOP;
	btwrite(xmit, BT848_I2C);
	retval = bttv_i2c_wait_done(btv);
	if (retval < 0)
		goto err;
	if (retval == 0)
		goto eio;
	if (i2c_debug) {
		printk(" <W %02x %02x", msg->addr << 1, msg->buf[0]);
		if (!(xmit & BT878_I2C_NOSTOP))
			printk(" >\n");
	}

	for (cnt = 1; cnt < msg->len; cnt++ ) {
		/* following bytes */
		xmit = (msg->buf[cnt] << 24) | I2C_HW | BT878_I2C_NOSTART;
		if (cnt < msg->len-1 || !last)
			xmit |= BT878_I2C_NOSTOP;
		btwrite(xmit, BT848_I2C);
		retval = bttv_i2c_wait_done(btv);
		if (retval < 0)
			goto err;
		if (retval == 0)
			goto eio;
		if (i2c_debug) {
			printk(" %02x", msg->buf[cnt]);
			if (!(xmit & BT878_I2C_NOSTOP))
				printk(" >\n");
		}
	}
	return msg->len;

 eio:
	retval = -EIO;
 err:
	if (i2c_debug)
		printk(" ERR: %d\n",retval);
	return retval;
}

static int
bttv_i2c_readbytes(struct bttv *btv, const struct i2c_msg *msg, int last)
{
	u32 xmit;
	u32 cnt;
	int retval;

	for(cnt = 0; cnt < msg->len; cnt++) {
		xmit = (msg->addr << 25) | (1 << 24) | I2C_HW;
		if (cnt < msg->len-1)
			xmit |= BT848_I2C_W3B;
		if (cnt < msg->len-1 || !last)
			xmit |= BT878_I2C_NOSTOP;
		if (cnt)
			xmit |= BT878_I2C_NOSTART;
		btwrite(xmit, BT848_I2C);
		retval = bttv_i2c_wait_done(btv);
		if (retval < 0)
			goto err;
		if (retval == 0)
			goto eio;
		msg->buf[cnt] = ((u32)btread(BT848_I2C) >> 8) & 0xff;
		if (i2c_debug) {
			if (!(xmit & BT878_I2C_NOSTART))
				printk(" <R %02x", (msg->addr << 1) +1);
			printk(" =%02x", msg->buf[cnt]);
			if (!(xmit & BT878_I2C_NOSTOP))
				printk(" >\n");
		}
	}
	return msg->len;

 eio:
	retval = -EIO;
 err:
	if (i2c_debug)
		printk(" ERR: %d\n",retval);
	return retval;
}

static int bttv_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
{
	struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
	struct bttv *btv = to_bttv(v4l2_dev);
	int retval = 0;
	int i;

	if (i2c_debug)
		printk("bt-i2c:");
	btwrite(BT848_INT_I2CDONE|BT848_INT_RACK, BT848_INT_STAT);
	for (i = 0 ; i < num; i++) {
		if (msgs[i].flags & I2C_M_RD) {
			/* read */
			retval = bttv_i2c_readbytes(btv, &msgs[i], i+1 == num);
			if (retval < 0)
				goto err;
		} else {
			/* write */
			retval = bttv_i2c_sendbytes(btv, &msgs[i], i+1 == num);
			if (retval < 0)
				goto err;
		}
	}
	return num;

 err:
	return retval;
}

static const struct i2c_algorithm bttv_algo = {
	.master_xfer   = bttv_i2c_xfer,
	.functionality = functionality,
};

/* ----------------------------------------------------------------------- */
/* I2C functions - common stuff                                            */

/* read I2C */
int bttv_I2CRead(struct bttv *btv, unsigned char addr, char *probe_for)
{
	unsigned char buffer = 0;

	if (0 != btv->i2c_rc)
		return -1;
	if (bttv_verbose && NULL != probe_for)
		printk(KERN_INFO "bttv%d: i2c: checking for %s @ 0x%02x... ",
		       btv->c.nr,probe_for,addr);
	btv->i2c_client.addr = addr >> 1;
	if (1 != i2c_master_recv(&btv->i2c_client, &buffer, 1)) {
		if (NULL != probe_for) {
			if (bttv_verbose)
				printk("not found\n");
		} else
			printk(KERN_WARNING "bttv%d: i2c read 0x%x: error\n",
			       btv->c.nr,addr);
		return -1;
	}
	if (bttv_verbose && NULL != probe_for)
		printk("found\n");
	return buffer;
}

/* write I2C */
int bttv_I2CWrite(struct bttv *btv, unsigned char addr, unsigned char b1,
		    unsigned char b2, int both)
{
	unsigned char buffer[2];
	int bytes = both ? 2 : 1;

	if (0 != btv->i2c_rc)
		return -1;
	btv->i2c_client.addr = addr >> 1;
	buffer[0] = b1;
	buffer[1] = b2;
	if (bytes != i2c_master_send(&btv->i2c_client, buffer, bytes))
		return -1;
	return 0;
}

/* read EEPROM content */
void __devinit bttv_readee(struct bttv *btv, unsigned char *eedata, int addr)
{
	memset(eedata, 0, 256);
	if (0 != btv->i2c_rc)
		return;
	btv->i2c_client.addr = addr >> 1;
	tveeprom_read(&btv->i2c_client, eedata, 256);
}

static char *i2c_devs[128] = {
	[ 0x1c >> 1 ] = "lgdt330x",
	[ 0x30 >> 1 ] = "IR (hauppauge)",
	[ 0x80 >> 1 ] = "msp34xx",
	[ 0x86 >> 1 ] = "tda9887",
	[ 0xa0 >> 1 ] = "eeprom",
	[ 0xc0 >> 1 ] = "tuner (analog)",
	[ 0xc2 >> 1 ] = "tuner (analog)",
};

static void do_i2c_scan(char *name, struct i2c_client *c)
{
	unsigned char buf;
	int i,rc;

	for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
		c->addr = i;
		rc = i2c_master_recv(c,&buf,0);
		if (rc < 0)
			continue;
		printk("%s: i2c scan: found device @ 0x%x  [%s]\n",
		       name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
	}
}

/* init + register i2c algo-bit adapter */
int __devinit init_bttv_i2c(struct bttv *btv)
{
	strlcpy(btv->i2c_client.name, "bttv internal", I2C_NAME_SIZE);

	if (i2c_hw)
		btv->use_i2c_hw = 1;
	if (btv->use_i2c_hw) {
		/* bt878 */
		strlcpy(btv->c.i2c_adap.name, "bt878",
			sizeof(btv->c.i2c_adap.name));
		btv->c.i2c_adap.algo = &bttv_algo;
	} else {
		/* bt848 */
	/* Prevents usage of invalid delay values */
		if (i2c_udelay<5)
			i2c_udelay=5;

		strlcpy(btv->c.i2c_adap.name, "bttv",
			sizeof(btv->c.i2c_adap.name));
		memcpy(&btv->i2c_algo, &bttv_i2c_algo_bit_template,
		       sizeof(bttv_i2c_algo_bit_template));
		btv->i2c_algo.udelay = i2c_udelay;
		btv->i2c_algo.data = btv;
		btv->c.i2c_adap.algo_data = &btv->i2c_algo;
	}
	btv->c.i2c_adap.owner = THIS_MODULE;

	btv->c.i2c_adap.dev.parent = &btv->c.pci->dev;
	snprintf(btv->c.i2c_adap.name, sizeof(btv->c.i2c_adap.name),
		 "bt%d #%d [%s]", btv->id, btv->c.nr,
		 btv->use_i2c_hw ? "hw" : "sw");

	i2c_set_adapdata(&btv->c.i2c_adap, &btv->c.v4l2_dev);
	btv->i2c_client.adapter = &btv->c.i2c_adap;


	if (btv->use_i2c_hw) {
		btv->i2c_rc = i2c_add_adapter(&btv->c.i2c_adap);
	} else {
		bttv_bit_setscl(btv,1);
		bttv_bit_setsda(btv,1);
		btv->i2c_rc = i2c_bit_add_bus(&btv->c.i2c_adap);
	}
	if (0 == btv->i2c_rc && i2c_scan)
		do_i2c_scan(btv->c.v4l2_dev.name, &btv->i2c_client);

	return btv->i2c_rc;
}

/* Instantiate the I2C IR receiver device, if present */
void __devinit init_bttv_i2c_ir(struct bttv *btv)
{
	if (0 == btv->i2c_rc) {
		struct i2c_board_info info;
		/* The external IR receiver is at i2c address 0x34 (0x35 for
		   reads).  Future Hauppauge cards will have an internal
		   receiver at 0x30 (0x31 for reads).  In theory, both can be
		   fitted, and Hauppauge suggest an external overrides an
		   internal.

		   That's why we probe 0x1a (~0x34) first. CB
		*/
		const unsigned short addr_list[] = {
			0x1a, 0x18, 0x4b, 0x64, 0x30, 0x71,
			I2C_CLIENT_END
		};

		memset(&info, 0, sizeof(struct i2c_board_info));
		strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
		i2c_new_probed_device(&btv->c.i2c_adap, &info, addr_list);
	}
}

int __devexit fini_bttv_i2c(struct bttv *btv)
{
	if (0 != btv->i2c_rc)
		return 0;

	return i2c_del_adapter(&btv->c.i2c_adap);
}

/*
 * Local variables:
 * c-basic-offset: 8
 * End:
 */
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2
	3	bttv-i2c.c -- all the i2c code is here
	4
	5	bttv - Bt848 frame grabber driver
	6
	7	Copyright (C) 1996,97,98 Ralph Metzler (rjkm@thp.uni-koeln.de)
4ac97914	8	& Marcus Metzler (mocm@thp.uni-koeln.de)
1da177e4 LT	9	(c) 1999-2003 Gerd Knorr <kraxel@bytesex.org>
1da177e4 LT	10
141276b5 MCC	11	(c) 2005 Mauro Carvalho Chehab <mchehab@infradead.org>
	12	- Multituner support and i2c address binding
	13
1da177e4 LT	14	This program is free software; you can redistribute it and/or modify
	15	it under the terms of the GNU General Public License as published by
	16	the Free Software Foundation; either version 2 of the License, or
	17	(at your option) any later version.
	18
	19	This program is distributed in the hope that it will be useful,
	20	but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	GNU General Public License for more details.
	23
	24	You should have received a copy of the GNU General Public License
	25	along with this program; if not, write to the Free Software
	26	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	27
	28	*/
	29
	30	#include <linux/module.h>
1da177e4 LT	31	#include <linux/init.h>
1da177e4 LT	32	#include <linux/delay.h>
1da177e4 LT	33
1da177e4 LT	34	#include "bttvp.h"
5e453dc7	35	#include <media/v4l2-common.h>
b5b8ab8d MCC	36	#include <linux/jiffies.h>
b5b8ab8d MCC	37	#include <asm/io.h>
1da177e4	38
a5ed425c MCC	39	static int i2c_debug;
	40	static int i2c_hw;
	41	static int i2c_scan;
1da177e4	42	module_param(i2c_debug, int, 0644);
0a25f3b2	43	MODULE_PARM_DESC(i2c_debug, "configure i2c debug level");
1da177e4	44	module_param(i2c_hw, int, 0444);
141276b5 MCC	45	MODULE_PARM_DESC(i2c_hw,"force use of hardware i2c support, "
141276b5 MCC	46	"instead of software bitbang");
1da177e4 LT	47	module_param(i2c_scan, int, 0444);
	48	MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");
	49
141276b5 MCC	50	static unsigned int i2c_udelay = 5;
	51	module_param(i2c_udelay, int, 0444);
	52	MODULE_PARM_DESC(i2c_udelay,"soft i2c delay at insmod time, in usecs "
	53	"(should be 5 or higher). Lower value means higher bus speed.");
	54
1da177e4 LT	55	/* ----------------------------------------------------------------------- */
	56	/* I2C functions - bitbanging adapter (software i2c) */
	57
	58	static void bttv_bit_setscl(void *data, int state)
	59	{
	60	struct bttv btv = (struct bttv)data;
	61
	62	if (state)
	63	btv->i2c_state \|= 0x02;
	64	else
	65	btv->i2c_state &= ~0x02;
	66	btwrite(btv->i2c_state, BT848_I2C);
	67	btread(BT848_I2C);
	68	}
	69
	70	static void bttv_bit_setsda(void *data, int state)
	71	{
	72	struct bttv btv = (struct bttv)data;
	73
	74	if (state)
	75	btv->i2c_state \|= 0x01;
	76	else
	77	btv->i2c_state &= ~0x01;
	78	btwrite(btv->i2c_state, BT848_I2C);
	79	btread(BT848_I2C);
	80	}
	81
	82	static int bttv_bit_getscl(void *data)
	83	{
	84	struct bttv btv = (struct bttv)data;
	85	int state;
	86
	87	state = btread(BT848_I2C) & 0x02 ? 1 : 0;
	88	return state;
	89	}
	90
	91	static int bttv_bit_getsda(void *data)
	92	{
	93	struct bttv btv = (struct bttv)data;
	94	int state;
	95
	96	state = btread(BT848_I2C) & 0x01;
	97	return state;
	98	}
	99
df9b5d4c	100	static struct i2c_algo_bit_data __devinitdata bttv_i2c_algo_bit_template = {
1da177e4 LT	101	.setsda = bttv_bit_setsda,
	102	.setscl = bttv_bit_setscl,
	103	.getsda = bttv_bit_getsda,
	104	.getscl = bttv_bit_getscl,
	105	.udelay = 16,
1da177e4 LT	106	.timeout = 200,
	107	};
	108
1da177e4 LT	109	/* ----------------------------------------------------------------------- */
	110	/* I2C functions - hardware i2c */
	111
1da177e4 LT	112	static u32 functionality(struct i2c_adapter *adap)
	113	{
	114	return I2C_FUNC_SMBUS_EMUL;
	115	}
	116
	117	static int
	118	bttv_i2c_wait_done(struct bttv *btv)
	119	{
1da177e4 LT	120	int rc = 0;
1da177e4 LT	121
fc9d53af MA	122	/* timeout */
	123	if (wait_event_interruptible_timeout(btv->i2c_queue,
	124	btv->i2c_done, msecs_to_jiffies(85)) == -ERESTARTSYS)
	125
	126	rc = -EIO;
1da177e4	127
1da177e4 LT	128	if (btv->i2c_done & BT848_INT_RACK)
	129	rc = 1;
	130	btv->i2c_done = 0;
	131	return rc;
	132	}
	133
	134	#define I2C_HW (BT878_I2C_MODE \| BT848_I2C_SYNC \|\
	135	BT848_I2C_SCL \| BT848_I2C_SDA)
	136
	137	static int
	138	bttv_i2c_sendbytes(struct bttv btv, const struct i2c_msg msg, int last)
	139	{
	140	u32 xmit;
	141	int retval,cnt;
	142
	143	/* sanity checks */
	144	if (0 == msg->len)
	145	return -EINVAL;
	146
	147	/* start, address + first byte */
	148	xmit = (msg->addr << 25) \| (msg->buf[0] << 16) \| I2C_HW;
	149	if (msg->len > 1 \|\| !last)
	150	xmit \|= BT878_I2C_NOSTOP;
	151	btwrite(xmit, BT848_I2C);
	152	retval = bttv_i2c_wait_done(btv);
	153	if (retval < 0)
	154	goto err;
	155	if (retval == 0)
	156	goto eio;
	157	if (i2c_debug) {
	158	printk(" <W %02x %02x", msg->addr << 1, msg->buf[0]);
	159	if (!(xmit & BT878_I2C_NOSTOP))
	160	printk(" >\n");
	161	}
	162
	163	for (cnt = 1; cnt < msg->len; cnt++ ) {
	164	/* following bytes */
	165	xmit = (msg->buf[cnt] << 24) \| I2C_HW \| BT878_I2C_NOSTART;
	166	if (cnt < msg->len-1 \|\| !last)
	167	xmit \|= BT878_I2C_NOSTOP;
	168	btwrite(xmit, BT848_I2C);
	169	retval = bttv_i2c_wait_done(btv);
	170	if (retval < 0)
	171	goto err;
	172	if (retval == 0)
	173	goto eio;
	174	if (i2c_debug) {
	175	printk(" %02x", msg->buf[cnt]);
	176	if (!(xmit & BT878_I2C_NOSTOP))
	177	printk(" >\n");
	178	}
	179	}
	180	return msg->len;
	181
	182	eio:
	183	retval = -EIO;
	184	err:
	185	if (i2c_debug)
	186	printk(" ERR: %d\n",retval);
	187	return retval;
	188	}
	189
	190	static int
	191	bttv_i2c_readbytes(struct bttv btv, const struct i2c_msg msg, int last)
192	{
193	u32 xmit;
194	u32 cnt;
195	int retval;
196
197	for(cnt = 0; cnt < msg->len; cnt++) {
198	xmit = (msg->addr << 25) \| (1 << 24) \| I2C_HW;
199	if (cnt < msg->len-1)
200	xmit \|= BT848_I2C_W3B;
201	if (cnt < msg->len-1 \|\| !last)
202	xmit \|= BT878_I2C_NOSTOP;
203	if (cnt)
204	xmit \|= BT878_I2C_NOSTART;
205	btwrite(xmit, BT848_I2C);
206	retval = bttv_i2c_wait_done(btv);
207	if (retval < 0)
208	goto err;
209	if (retval == 0)
210	goto eio;
211	msg->buf[cnt] = ((u32)btread(BT848_I2C) >> 8) & 0xff;
212	if (i2c_debug) {
213	if (!(xmit & BT878_I2C_NOSTART))
214	printk(" <R %02x", (msg->addr << 1) +1);
215	printk(" =%02x", msg->buf[cnt]);
216	if (!(xmit & BT878_I2C_NOSTOP))
217	printk(" >\n");
218	}
219	}
220	return msg->len;
221
222	eio:
223	retval = -EIO;
224	err:
225	if (i2c_debug)
226	printk(" ERR: %d\n",retval);
4ac97914	227	return retval;
1da177e4 LT	228	}
	229
	230	static int bttv_i2c_xfer(struct i2c_adapter i2c_adap, struct i2c_msg msgs, int num)
	231	{
74fc7bd9 HV	232	struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
74fc7bd9 HV	233	struct bttv *btv = to_bttv(v4l2_dev);
1da177e4 LT	234	int retval = 0;
	235	int i;
	236
	237	if (i2c_debug)
	238	printk("bt-i2c:");
	239	btwrite(BT848_INT_I2CDONE\|BT848_INT_RACK, BT848_INT_STAT);
	240	for (i = 0 ; i < num; i++) {
	241	if (msgs[i].flags & I2C_M_RD) {
	242	/* read */
	243	retval = bttv_i2c_readbytes(btv, &msgs[i], i+1 == num);
	244	if (retval < 0)
	245	goto err;
	246	} else {
	247	/* write */
	248	retval = bttv_i2c_sendbytes(btv, &msgs[i], i+1 == num);
	249	if (retval < 0)
	250	goto err;
	251	}
	252	}
	253	return num;
	254
	255	err:
	256	return retval;
	257	}
	258
df9b5d4c	259	static const struct i2c_algorithm bttv_algo = {
1da177e4	260	.master_xfer = bttv_i2c_xfer,
1da177e4 LT	261	.functionality = functionality,
	262	};
	263
1da177e4 LT	264	/* ----------------------------------------------------------------------- */
	265	/* I2C functions - common stuff */
	266
1da177e4 LT	267	/* read I2C */
	268	int bttv_I2CRead(struct bttv btv, unsigned char addr, char probe_for)
	269	{
4ac97914	270	unsigned char buffer = 0;
1da177e4 LT	271
	272	if (0 != btv->i2c_rc)
	273	return -1;
	274	if (bttv_verbose && NULL != probe_for)
	275	printk(KERN_INFO "bttv%d: i2c: checking for %s @ 0x%02x... ",
	276	btv->c.nr,probe_for,addr);
4ac97914 MCC	277	btv->i2c_client.addr = addr >> 1;
4ac97914 MCC	278	if (1 != i2c_master_recv(&btv->i2c_client, &buffer, 1)) {
1da177e4 LT	279	if (NULL != probe_for) {
	280	if (bttv_verbose)
	281	printk("not found\n");
	282	} else
	283	printk(KERN_WARNING "bttv%d: i2c read 0x%x: error\n",
	284	btv->c.nr,addr);
4ac97914	285	return -1;
1da177e4 LT	286	}
	287	if (bttv_verbose && NULL != probe_for)
	288	printk("found\n");
4ac97914	289	return buffer;
1da177e4 LT	290	}
	291
	292	/* write I2C */
	293	int bttv_I2CWrite(struct bttv *btv, unsigned char addr, unsigned char b1,
4ac97914	294	unsigned char b2, int both)
1da177e4	295	{
4ac97914 MCC	296	unsigned char buffer[2];
4ac97914 MCC	297	int bytes = both ? 2 : 1;
1da177e4 LT	298
	299	if (0 != btv->i2c_rc)
	300	return -1;
4ac97914 MCC	301	btv->i2c_client.addr = addr >> 1;
	302	buffer[0] = b1;
	303	buffer[1] = b2;
	304	if (bytes != i2c_master_send(&btv->i2c_client, buffer, bytes))
1da177e4	305	return -1;
4ac97914	306	return 0;
1da177e4 LT	307	}
	308
	309	/* read EEPROM content */
	310	void __devinit bttv_readee(struct bttv btv, unsigned char eedata, int addr)
	311	{
5daf05fb GK	312	memset(eedata, 0, 256);
	313	if (0 != btv->i2c_rc)
	314	return;
1da177e4 LT	315	btv->i2c_client.addr = addr >> 1;
	316	tveeprom_read(&btv->i2c_client, eedata, 256);
	317	}
	318
	319	static char *i2c_devs[128] = {
24a70fdc	320	[ 0x1c >> 1 ] = "lgdt330x",
1da177e4 LT	321	[ 0x30 >> 1 ] = "IR (hauppauge)",
	322	[ 0x80 >> 1 ] = "msp34xx",
	323	[ 0x86 >> 1 ] = "tda9887",
	324	[ 0xa0 >> 1 ] = "eeprom",
	325	[ 0xc0 >> 1 ] = "tuner (analog)",
	326	[ 0xc2 >> 1 ] = "tuner (analog)",
	327	};
	328
	329	static void do_i2c_scan(char name, struct i2c_client c)
	330	{
	331	unsigned char buf;
	332	int i,rc;
	333
53c4e955	334	for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
1da177e4 LT	335	c->addr = i;
	336	rc = i2c_master_recv(c,&buf,0);
	337	if (rc < 0)
	338	continue;
	339	printk("%s: i2c scan: found device @ 0x%x [%s]\n",
	340	name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
	341	}
	342	}
	343
	344	/* init + register i2c algo-bit adapter */
	345	int __devinit init_bttv_i2c(struct bttv *btv)
	346	{
df9b5d4c	347	strlcpy(btv->i2c_client.name, "bttv internal", I2C_NAME_SIZE);
1da177e4 LT	348
	349	if (i2c_hw)
	350	btv->use_i2c_hw = 1;
	351	if (btv->use_i2c_hw) {
	352	/* bt878 */
df9b5d4c JD	353	strlcpy(btv->c.i2c_adap.name, "bt878",
df9b5d4c JD	354	sizeof(btv->c.i2c_adap.name));
df9b5d4c	355	btv->c.i2c_adap.algo = &bttv_algo;
1da177e4 LT	356	} else {
1da177e4 LT	357	/* bt848 */
141276b5 MCC	358	/* Prevents usage of invalid delay values */
	359	if (i2c_udelay<5)
	360	i2c_udelay=5;
141276b5	361
df9b5d4c JD	362	strlcpy(btv->c.i2c_adap.name, "bttv",
df9b5d4c JD	363	sizeof(btv->c.i2c_adap.name));
1da177e4 LT	364	memcpy(&btv->i2c_algo, &bttv_i2c_algo_bit_template,
1da177e4 LT	365	sizeof(bttv_i2c_algo_bit_template));
df9b5d4c	366	btv->i2c_algo.udelay = i2c_udelay;
1da177e4 LT	367	btv->i2c_algo.data = btv;
	368	btv->c.i2c_adap.algo_data = &btv->i2c_algo;
	369	}
df9b5d4c	370	btv->c.i2c_adap.owner = THIS_MODULE;
1da177e4 LT	371
	372	btv->c.i2c_adap.dev.parent = &btv->c.pci->dev;
	373	snprintf(btv->c.i2c_adap.name, sizeof(btv->c.i2c_adap.name),
	374	"bt%d #%d [%s]", btv->id, btv->c.nr,
	375	btv->use_i2c_hw ? "hw" : "sw");
	376
74fc7bd9	377	i2c_set_adapdata(&btv->c.i2c_adap, &btv->c.v4l2_dev);
4ac97914	378	btv->i2c_client.adapter = &btv->c.i2c_adap;
1da177e4	379
1da177e4 LT	380
	381	if (btv->use_i2c_hw) {
	382	btv->i2c_rc = i2c_add_adapter(&btv->c.i2c_adap);
	383	} else {
	384	bttv_bit_setscl(btv,1);
	385	bttv_bit_setsda(btv,1);
	386	btv->i2c_rc = i2c_bit_add_bus(&btv->c.i2c_adap);
	387	}
	388	if (0 == btv->i2c_rc && i2c_scan)
74fc7bd9	389	do_i2c_scan(btv->c.v4l2_dev.name, &btv->i2c_client);
c668f32d	390
24344664 JD	391	return btv->i2c_rc;
	392	}
	393
	394	/* Instantiate the I2C IR receiver device, if present */
	395	void __devinit init_bttv_i2c_ir(struct bttv *btv)
	396	{
c668f32d JD	397	if (0 == btv->i2c_rc) {
	398	struct i2c_board_info info;
	399	/* The external IR receiver is at i2c address 0x34 (0x35 for
	400	reads). Future Hauppauge cards will have an internal
	401	receiver at 0x30 (0x31 for reads). In theory, both can be
	402	fitted, and Hauppauge suggest an external overrides an
	403	internal.
	404
	405	That's why we probe 0x1a (~0x34) first. CB
	406	*/
	407	const unsigned short addr_list[] = {
0d94e294	408	0x1a, 0x18, 0x4b, 0x64, 0x30, 0x71,
c668f32d JD	409	I2C_CLIENT_END
	410	};
	411
	412	memset(&info, 0, sizeof(struct i2c_board_info));
	413	strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
	414	i2c_new_probed_device(&btv->c.i2c_adap, &info, addr_list);
	415	}
1da177e4 LT	416	}
	417
	418	int __devexit fini_bttv_i2c(struct bttv *btv)
	419	{
	420	if (0 != btv->i2c_rc)
	421	return 0;
	422
3269711b	423	return i2c_del_adapter(&btv->c.i2c_adap);
1da177e4 LT	424	}
	425
	426	/*
	427	* Local variables:
	428	* c-basic-offset: 8
	429	* End:
	430	*/