[linux-2.6-block.git] / drivers / media / pci / saa7134 / saa7134-i2c.c

/*
 *
 * device driver for philips saa7134 based TV cards
 * i2c interface support
 *
 * (c) 2001,02 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
 *
 *  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/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>

#include "saa7134-reg.h"
#include "saa7134.h"
#include <media/v4l2-common.h>

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

static unsigned int i2c_debug;
module_param(i2c_debug, int, 0644);
MODULE_PARM_DESC(i2c_debug,"enable debug messages [i2c]");

static unsigned int i2c_scan;
module_param(i2c_scan, int, 0444);
MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");

#define d1printk if (1 == i2c_debug) printk
#define d2printk if (2 == i2c_debug) printk

#define I2C_WAIT_DELAY  32
#define I2C_WAIT_RETRY  16

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

static char *str_i2c_status[] = {
	"IDLE", "DONE_STOP", "BUSY", "TO_SCL", "TO_ARB", "DONE_WRITE",
	"DONE_READ", "DONE_WRITE_TO", "DONE_READ_TO", "NO_DEVICE",
	"NO_ACKN", "BUS_ERR", "ARB_LOST", "SEQ_ERR", "ST_ERR", "SW_ERR"
};

enum i2c_status {
	IDLE          = 0,  // no I2C command pending
	DONE_STOP     = 1,  // I2C command done and STOP executed
	BUSY          = 2,  // executing I2C command
	TO_SCL        = 3,  // executing I2C command, time out on clock stretching
	TO_ARB        = 4,  // time out on arbitration trial, still trying
	DONE_WRITE    = 5,  // I2C command done and awaiting next write command
	DONE_READ     = 6,  // I2C command done and awaiting next read command
	DONE_WRITE_TO = 7,  // see 5, and time out on status echo
	DONE_READ_TO  = 8,  // see 6, and time out on status echo
	NO_DEVICE     = 9,  // no acknowledge on device slave address
	NO_ACKN       = 10, // no acknowledge after data byte transfer
	BUS_ERR       = 11, // bus error
	ARB_LOST      = 12, // arbitration lost during transfer
	SEQ_ERR       = 13, // erroneous programming sequence
	ST_ERR        = 14, // wrong status echoing
	SW_ERR        = 15  // software error
};

static char *str_i2c_attr[] = {
	"NOP", "STOP", "CONTINUE", "START"
};

enum i2c_attr {
	NOP           = 0,  // no operation on I2C bus
	STOP          = 1,  // stop condition, no associated byte transfer
	CONTINUE      = 2,  // continue with byte transfer
	START         = 3   // start condition with byte transfer
};

static inline enum i2c_status i2c_get_status(struct saa7134_dev *dev)
{
	enum i2c_status status;

	status = saa_readb(SAA7134_I2C_ATTR_STATUS) & 0x0f;
	d2printk(KERN_DEBUG "%s: i2c stat <= %s\n",dev->name,
		 str_i2c_status[status]);
	return status;
}

static inline void i2c_set_status(struct saa7134_dev *dev,
				  enum i2c_status status)
{
	d2printk(KERN_DEBUG "%s: i2c stat => %s\n",dev->name,
		 str_i2c_status[status]);
	saa_andorb(SAA7134_I2C_ATTR_STATUS,0x0f,status);
}

static inline void i2c_set_attr(struct saa7134_dev *dev, enum i2c_attr attr)
{
	d2printk(KERN_DEBUG "%s: i2c attr => %s\n",dev->name,
		 str_i2c_attr[attr]);
	saa_andorb(SAA7134_I2C_ATTR_STATUS,0xc0,attr << 6);
}

static inline int i2c_is_error(enum i2c_status status)
{
	switch (status) {
	case NO_DEVICE:
	case NO_ACKN:
	case BUS_ERR:
	case ARB_LOST:
	case SEQ_ERR:
	case ST_ERR:
		return true;
	default:
		return false;
	}
}

static inline int i2c_is_idle(enum i2c_status status)
{
	switch (status) {
	case IDLE:
	case DONE_STOP:
		return true;
	default:
		return false;
	}
}

static inline int i2c_is_busy(enum i2c_status status)
{
	switch (status) {
	case BUSY:
	case TO_SCL:
	case TO_ARB:
		return true;
	default:
		return false;
	}
}

static int i2c_is_busy_wait(struct saa7134_dev *dev)
{
	enum i2c_status status;
	int count;

	for (count = 0; count < I2C_WAIT_RETRY; count++) {
		status = i2c_get_status(dev);
		if (!i2c_is_busy(status))
			break;
		saa_wait(I2C_WAIT_DELAY);
	}
	if (I2C_WAIT_RETRY == count)
		return false;
	return true;
}

static int i2c_reset(struct saa7134_dev *dev)
{
	enum i2c_status status;
	int count;

	d2printk(KERN_DEBUG "%s: i2c reset\n",dev->name);
	status = i2c_get_status(dev);
	if (!i2c_is_error(status))
		return true;
	i2c_set_status(dev,status);

	for (count = 0; count < I2C_WAIT_RETRY; count++) {
		status = i2c_get_status(dev);
		if (!i2c_is_error(status))
			break;
		udelay(I2C_WAIT_DELAY);
	}
	if (I2C_WAIT_RETRY == count)
		return false;

	if (!i2c_is_idle(status))
		return false;

	i2c_set_attr(dev,NOP);
	return true;
}

static inline int i2c_send_byte(struct saa7134_dev *dev,
				enum i2c_attr attr,
				unsigned char data)
{
	enum i2c_status status;
	__u32 dword;

	/* have to write both attr + data in one 32bit word */
	dword  = saa_readl(SAA7134_I2C_ATTR_STATUS >> 2);
	dword &= 0x0f;
	dword |= (attr << 6);
	dword |= ((__u32)data << 8);
	dword |= 0x00 << 16;  /* 100 kHz */
//	dword |= 0x40 << 16;  /* 400 kHz */
	dword |= 0xf0 << 24;
	saa_writel(SAA7134_I2C_ATTR_STATUS >> 2, dword);
	d2printk(KERN_DEBUG "%s: i2c data => 0x%x\n",dev->name,data);

	if (!i2c_is_busy_wait(dev))
		return -EIO;
	status = i2c_get_status(dev);
	if (i2c_is_error(status))
		return -EIO;
	return 0;
}

static inline int i2c_recv_byte(struct saa7134_dev *dev)
{
	enum i2c_status status;
	unsigned char data;

	i2c_set_attr(dev,CONTINUE);
	if (!i2c_is_busy_wait(dev))
		return -EIO;
	status = i2c_get_status(dev);
	if (i2c_is_error(status))
		return -EIO;
	data = saa_readb(SAA7134_I2C_DATA);
	d2printk(KERN_DEBUG "%s: i2c data <= 0x%x\n",dev->name,data);
	return data;
}

static int saa7134_i2c_xfer(struct i2c_adapter *i2c_adap,
			    struct i2c_msg *msgs, int num)
{
	struct saa7134_dev *dev = i2c_adap->algo_data;
	enum i2c_status status;
	unsigned char data;
	int addr,rc,i,byte;

	status = i2c_get_status(dev);
	if (!i2c_is_idle(status))
		if (!i2c_reset(dev))
			return -EIO;

	d2printk("start xfer\n");
	d1printk(KERN_DEBUG "%s: i2c xfer:",dev->name);
	for (i = 0; i < num; i++) {
		if (!(msgs[i].flags & I2C_M_NOSTART) || 0 == i) {
			/* send address */
			d2printk("send address\n");
			addr  = msgs[i].addr << 1;
			if (msgs[i].flags & I2C_M_RD)
				addr |= 1;
			if (i > 0 && msgs[i].flags &
			    I2C_M_RD && msgs[i].addr != 0x40 &&
			    msgs[i].addr != 0x41 &&
			    msgs[i].addr != 0x19) {
				/* workaround for a saa7134 i2c bug
				 * needed to talk to the mt352 demux
				 * thanks to pinnacle for the hint */
				int quirk = 0xfe;
				d1printk(" [%02x quirk]",quirk);
				i2c_send_byte(dev,START,quirk);
				i2c_recv_byte(dev);
			}
			d1printk(" < %02x", addr);
			rc = i2c_send_byte(dev,START,addr);
			if (rc < 0)
				 goto err;
		}
		if (msgs[i].flags & I2C_M_RD) {
			/* read bytes */
			d2printk("read bytes\n");
			for (byte = 0; byte < msgs[i].len; byte++) {
				d1printk(" =");
				rc = i2c_recv_byte(dev);
				if (rc < 0)
					goto err;
				d1printk("%02x", rc);
				msgs[i].buf[byte] = rc;
			}
			/* discard mysterious extra byte when reading
			   from Samsung S5H1411.  i2c bus gets error
			   if we do not. */
			if (0x19 == msgs[i].addr) {
				d1printk(" ?");
				rc = i2c_recv_byte(dev);
				if (rc < 0)
					goto err;
				d1printk("%02x", rc);
			}
		} else {
			/* write bytes */
			d2printk("write bytes\n");
			for (byte = 0; byte < msgs[i].len; byte++) {
				data = msgs[i].buf[byte];
				d1printk(" %02x", data);
				rc = i2c_send_byte(dev,CONTINUE,data);
				if (rc < 0)
					goto err;
			}
		}
	}
	d2printk("xfer done\n");
	d1printk(" >");
	i2c_set_attr(dev,STOP);
	rc = -EIO;
	if (!i2c_is_busy_wait(dev))
		goto err;
	status = i2c_get_status(dev);
	if (i2c_is_error(status))
		goto err;
	/* ensure that the bus is idle for at least one bit slot */
	msleep(1);

	d1printk("\n");
	return num;
 err:
	if (1 == i2c_debug) {
		status = i2c_get_status(dev);
		printk(" ERROR: %s\n",str_i2c_status[status]);
	}
	return rc;
}

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

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

static struct i2c_algorithm saa7134_algo = {
	.master_xfer   = saa7134_i2c_xfer,
	.functionality = functionality,
};

static struct i2c_adapter saa7134_adap_template = {
	.owner         = THIS_MODULE,
	.name          = "saa7134",
	.algo          = &saa7134_algo,
};

static struct i2c_client saa7134_client_template = {
	.name	= "saa7134 internal",
};

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

static int
saa7134_i2c_eeprom(struct saa7134_dev *dev, unsigned char *eedata, int len)
{
	unsigned char buf;
	int i,err;

	dev->i2c_client.addr = 0xa0 >> 1;
	buf = 0;
	if (1 != (err = i2c_master_send(&dev->i2c_client,&buf,1))) {
		printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
		       dev->name,err);
		return -1;
	}
	if (len != (err = i2c_master_recv(&dev->i2c_client,eedata,len))) {
		printk(KERN_WARNING "%s: i2c eeprom read error (err=%d)\n",
		       dev->name,err);
		return -1;
	}
	for (i = 0; i < len; i++) {
		if (0 == (i % 16))
			printk(KERN_INFO "%s: i2c eeprom %02x:",dev->name,i);
		printk(" %02x",eedata[i]);
		if (15 == (i % 16))
			printk("\n");
	}
	return 0;
}

static char *i2c_devs[128] = {
	[ 0x20      ] = "mpeg encoder (saa6752hs)",
	[ 0xa0 >> 1 ] = "eeprom",
	[ 0xc0 >> 1 ] = "tuner (analog)",
	[ 0x86 >> 1 ] = "tda9887",
	[ 0x5a >> 1 ] = "remote control",
};

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] : "???");
	}
}

int saa7134_i2c_register(struct saa7134_dev *dev)
{
	dev->i2c_adap = saa7134_adap_template;
	dev->i2c_adap.dev.parent = &dev->pci->dev;
	strcpy(dev->i2c_adap.name,dev->name);
	dev->i2c_adap.algo_data = dev;
	i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
	i2c_add_adapter(&dev->i2c_adap);

	dev->i2c_client = saa7134_client_template;
	dev->i2c_client.adapter = &dev->i2c_adap;

	saa7134_i2c_eeprom(dev,dev->eedata,sizeof(dev->eedata));
	if (i2c_scan)
		do_i2c_scan(dev->name,&dev->i2c_client);

	/* Instantiate the IR receiver device, if present */
	saa7134_probe_i2c_ir(dev);
	return 0;
}

int saa7134_i2c_unregister(struct saa7134_dev *dev)
{
	i2c_del_adapter(&dev->i2c_adap);
	return 0;
}
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	*
	3	* device driver for philips saa7134 based TV cards
	4	* i2c interface support
	5	*
	6	* (c) 2001,02 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	21	*/
	22
	23	#include <linux/init.h>
	24	#include <linux/list.h>
	25	#include <linux/module.h>
1da177e4	26	#include <linux/kernel.h>
1da177e4 LT	27	#include <linux/delay.h>
	28
	29	#include "saa7134-reg.h"
	30	#include "saa7134.h"
5e453dc7	31	#include <media/v4l2-common.h>
1da177e4 LT	32
	33	/* ----------------------------------------------------------- */
	34
ff699e6b	35	static unsigned int i2c_debug;
1da177e4 LT	36	module_param(i2c_debug, int, 0644);
	37	MODULE_PARM_DESC(i2c_debug,"enable debug messages [i2c]");
	38
ff699e6b	39	static unsigned int i2c_scan;
1da177e4 LT	40	module_param(i2c_scan, int, 0444);
	41	MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");
	42
	43	#define d1printk if (1 == i2c_debug) printk
	44	#define d2printk if (2 == i2c_debug) printk
	45
	46	#define I2C_WAIT_DELAY 32
	47	#define I2C_WAIT_RETRY 16
	48
	49	/* ----------------------------------------------------------- */
	50
	51	static char *str_i2c_status[] = {
	52	"IDLE", "DONE_STOP", "BUSY", "TO_SCL", "TO_ARB", "DONE_WRITE",
	53	"DONE_READ", "DONE_WRITE_TO", "DONE_READ_TO", "NO_DEVICE",
	54	"NO_ACKN", "BUS_ERR", "ARB_LOST", "SEQ_ERR", "ST_ERR", "SW_ERR"
	55	};
	56
	57	enum i2c_status {
	58	IDLE = 0, // no I2C command pending
	59	DONE_STOP = 1, // I2C command done and STOP executed
	60	BUSY = 2, // executing I2C command
	61	TO_SCL = 3, // executing I2C command, time out on clock stretching
	62	TO_ARB = 4, // time out on arbitration trial, still trying
	63	DONE_WRITE = 5, // I2C command done and awaiting next write command
	64	DONE_READ = 6, // I2C command done and awaiting next read command
	65	DONE_WRITE_TO = 7, // see 5, and time out on status echo
	66	DONE_READ_TO = 8, // see 6, and time out on status echo
	67	NO_DEVICE = 9, // no acknowledge on device slave address
	68	NO_ACKN = 10, // no acknowledge after data byte transfer
	69	BUS_ERR = 11, // bus error
	70	ARB_LOST = 12, // arbitration lost during transfer
	71	SEQ_ERR = 13, // erroneous programming sequence
	72	ST_ERR = 14, // wrong status echoing
	73	SW_ERR = 15 // software error
	74	};
	75
	76	static char *str_i2c_attr[] = {
	77	"NOP", "STOP", "CONTINUE", "START"
	78	};
	79
	80	enum i2c_attr {
	81	NOP = 0, // no operation on I2C bus
	82	STOP = 1, // stop condition, no associated byte transfer
	83	CONTINUE = 2, // continue with byte transfer
	84	START = 3 // start condition with byte transfer
	85	};
	86
	87	static inline enum i2c_status i2c_get_status(struct saa7134_dev *dev)
	88	{
	89	enum i2c_status status;
	90
	91	status = saa_readb(SAA7134_I2C_ATTR_STATUS) & 0x0f;
	92	d2printk(KERN_DEBUG "%s: i2c stat <= %s\n",dev->name,
	93	str_i2c_status[status]);
	94	return status;
	95	}
	96
	97	static inline void i2c_set_status(struct saa7134_dev *dev,
	98	enum i2c_status status)
	99	{
	100	d2printk(KERN_DEBUG "%s: i2c stat => %s\n",dev->name,
	101	str_i2c_status[status]);
	102	saa_andorb(SAA7134_I2C_ATTR_STATUS,0x0f,status);
	103	}
104
105	static inline void i2c_set_attr(struct saa7134_dev *dev, enum i2c_attr attr)
106	{
107	d2printk(KERN_DEBUG "%s: i2c attr => %s\n",dev->name,
108	str_i2c_attr[attr]);
109	saa_andorb(SAA7134_I2C_ATTR_STATUS,0xc0,attr << 6);
110	}
111
112	static inline int i2c_is_error(enum i2c_status status)
113	{
114	switch (status) {
115	case NO_DEVICE:
116	case NO_ACKN:
117	case BUS_ERR:
118	case ARB_LOST:
119	case SEQ_ERR:
120	case ST_ERR:
e8be02a3	121	return true;
1da177e4	122	default:
e8be02a3	123	return false;
1da177e4 LT	124	}
	125	}
	126
	127	static inline int i2c_is_idle(enum i2c_status status)
	128	{
	129	switch (status) {
	130	case IDLE:
	131	case DONE_STOP:
e8be02a3	132	return true;
1da177e4	133	default:
e8be02a3	134	return false;
1da177e4 LT	135	}
	136	}
	137
	138	static inline int i2c_is_busy(enum i2c_status status)
	139	{
	140	switch (status) {
	141	case BUSY:
8fb737b7 DB	142	case TO_SCL:
8fb737b7 DB	143	case TO_ARB:
e8be02a3	144	return true;
1da177e4	145	default:
e8be02a3	146	return false;
1da177e4 LT	147	}
	148	}
	149
	150	static int i2c_is_busy_wait(struct saa7134_dev *dev)
	151	{
	152	enum i2c_status status;
	153	int count;
	154
	155	for (count = 0; count < I2C_WAIT_RETRY; count++) {
	156	status = i2c_get_status(dev);
	157	if (!i2c_is_busy(status))
	158	break;
	159	saa_wait(I2C_WAIT_DELAY);
	160	}
	161	if (I2C_WAIT_RETRY == count)
e8be02a3 RK	162	return false;
e8be02a3 RK	163	return true;
1da177e4 LT	164	}
	165
	166	static int i2c_reset(struct saa7134_dev *dev)
	167	{
	168	enum i2c_status status;
	169	int count;
	170
	171	d2printk(KERN_DEBUG "%s: i2c reset\n",dev->name);
	172	status = i2c_get_status(dev);
	173	if (!i2c_is_error(status))
e8be02a3	174	return true;
1da177e4 LT	175	i2c_set_status(dev,status);
	176
	177	for (count = 0; count < I2C_WAIT_RETRY; count++) {
	178	status = i2c_get_status(dev);
	179	if (!i2c_is_error(status))
	180	break;
	181	udelay(I2C_WAIT_DELAY);
	182	}
	183	if (I2C_WAIT_RETRY == count)
e8be02a3	184	return false;
1da177e4 LT	185
1da177e4 LT	186	if (!i2c_is_idle(status))
e8be02a3	187	return false;
1da177e4 LT	188
1da177e4 LT	189	i2c_set_attr(dev,NOP);
e8be02a3	190	return true;
1da177e4 LT	191	}
	192
	193	static inline int i2c_send_byte(struct saa7134_dev *dev,
	194	enum i2c_attr attr,
	195	unsigned char data)
	196	{
	197	enum i2c_status status;
	198	__u32 dword;
	199
1da177e4 LT	200	/* have to write both attr + data in one 32bit word */
	201	dword = saa_readl(SAA7134_I2C_ATTR_STATUS >> 2);
	202	dword &= 0x0f;
	203	dword \|= (attr << 6);
	204	dword \|= ((__u32)data << 8);
	205	dword \|= 0x00 << 16; /* 100 kHz */
	206	// dword \|= 0x40 << 16; /* 400 kHz */
	207	dword \|= 0xf0 << 24;
	208	saa_writel(SAA7134_I2C_ATTR_STATUS >> 2, dword);
1da177e4 LT	209	d2printk(KERN_DEBUG "%s: i2c data => 0x%x\n",dev->name,data);
	210
	211	if (!i2c_is_busy_wait(dev))
	212	return -EIO;
	213	status = i2c_get_status(dev);
	214	if (i2c_is_error(status))
	215	return -EIO;
	216	return 0;
	217	}
	218
	219	static inline int i2c_recv_byte(struct saa7134_dev *dev)
	220	{
	221	enum i2c_status status;
	222	unsigned char data;
	223
	224	i2c_set_attr(dev,CONTINUE);
	225	if (!i2c_is_busy_wait(dev))
	226	return -EIO;
	227	status = i2c_get_status(dev);
	228	if (i2c_is_error(status))
	229	return -EIO;
	230	data = saa_readb(SAA7134_I2C_DATA);
	231	d2printk(KERN_DEBUG "%s: i2c data <= 0x%x\n",dev->name,data);
	232	return data;
	233	}
	234
	235	static int saa7134_i2c_xfer(struct i2c_adapter *i2c_adap,
	236	struct i2c_msg *msgs, int num)
	237	{
	238	struct saa7134_dev *dev = i2c_adap->algo_data;
	239	enum i2c_status status;
	240	unsigned char data;
	241	int addr,rc,i,byte;
	242
4ac97914	243	status = i2c_get_status(dev);
1da177e4 LT	244	if (!i2c_is_idle(status))
	245	if (!i2c_reset(dev))
	246	return -EIO;
	247
	248	d2printk("start xfer\n");
	249	d1printk(KERN_DEBUG "%s: i2c xfer:",dev->name);
	250	for (i = 0; i < num; i++) {
	251	if (!(msgs[i].flags & I2C_M_NOSTART) \|\| 0 == i) {
	252	/* send address */
	253	d2printk("send address\n");
	254	addr = msgs[i].addr << 1;
	255	if (msgs[i].flags & I2C_M_RD)
	256	addr \|= 1;
25fa2071 KS	257	if (i > 0 && msgs[i].flags &
25fa2071 KS	258	I2C_M_RD && msgs[i].addr != 0x40 &&
34fe2784	259	msgs[i].addr != 0x41 &&
25fa2071	260	msgs[i].addr != 0x19) {
1da177e4 LT	261	/* workaround for a saa7134 i2c bug
	262	* needed to talk to the mt352 demux
	263	* thanks to pinnacle for the hint */
b9dcdb6f	264	int quirk = 0xfe;
1da177e4 LT	265	d1printk(" [%02x quirk]",quirk);
	266	i2c_send_byte(dev,START,quirk);
	267	i2c_recv_byte(dev);
	268	}
	269	d1printk(" < %02x", addr);
	270	rc = i2c_send_byte(dev,START,addr);
	271	if (rc < 0)
	272	goto err;
	273	}
	274	if (msgs[i].flags & I2C_M_RD) {
	275	/* read bytes */
	276	d2printk("read bytes\n");
	277	for (byte = 0; byte < msgs[i].len; byte++) {
	278	d1printk(" =");
	279	rc = i2c_recv_byte(dev);
	280	if (rc < 0)
	281	goto err;
	282	d1printk("%02x", rc);
	283	msgs[i].buf[byte] = rc;
	284	}
25fa2071 KS	285	/* discard mysterious extra byte when reading
	286	from Samsung S5H1411. i2c bus gets error
	287	if we do not. */
	288	if (0x19 == msgs[i].addr) {
	289	d1printk(" ?");
	290	rc = i2c_recv_byte(dev);
	291	if (rc < 0)
	292	goto err;
	293	d1printk("%02x", rc);
	294	}
1da177e4 LT	295	} else {
	296	/* write bytes */
	297	d2printk("write bytes\n");
	298	for (byte = 0; byte < msgs[i].len; byte++) {
	299	data = msgs[i].buf[byte];
	300	d1printk(" %02x", data);
	301	rc = i2c_send_byte(dev,CONTINUE,data);
	302	if (rc < 0)
	303	goto err;
	304	}
	305	}
	306	}
	307	d2printk("xfer done\n");
	308	d1printk(" >");
	309	i2c_set_attr(dev,STOP);
	310	rc = -EIO;
	311	if (!i2c_is_busy_wait(dev))
	312	goto err;
4ac97914	313	status = i2c_get_status(dev);
1da177e4 LT	314	if (i2c_is_error(status))
1da177e4 LT	315	goto err;
fd3113e8 MCC	316	/* ensure that the bus is idle for at least one bit slot */
fd3113e8 MCC	317	msleep(1);
1da177e4 LT	318
	319	d1printk("\n");
	320	return num;
	321	err:
	322	if (1 == i2c_debug) {
	323	status = i2c_get_status(dev);
	324	printk(" ERROR: %s\n",str_i2c_status[status]);
	325	}
	326	return rc;
	327	}
	328
	329	/* ----------------------------------------------------------- */
	330
1da177e4 LT	331	static u32 functionality(struct i2c_adapter *adap)
	332	{
	333	return I2C_FUNC_SMBUS_EMUL;
	334	}
	335
1da177e4	336	static struct i2c_algorithm saa7134_algo = {
1da177e4	337	.master_xfer = saa7134_i2c_xfer,
1da177e4 LT	338	.functionality = functionality,
	339	};
	340
	341	static struct i2c_adapter saa7134_adap_template = {
	342	.owner = THIS_MODULE,
fae91e72	343	.name = "saa7134",
1da177e4	344	.algo = &saa7134_algo,
1da177e4 LT	345	};
	346
	347	static struct i2c_client saa7134_client_template = {
fae91e72	348	.name = "saa7134 internal",
1da177e4 LT	349	};
	350
	351	/* ----------------------------------------------------------- */
	352
	353	static int
	354	saa7134_i2c_eeprom(struct saa7134_dev dev, unsigned char eedata, int len)
	355	{
	356	unsigned char buf;
	357	int i,err;
	358
	359	dev->i2c_client.addr = 0xa0 >> 1;
	360	buf = 0;
	361	if (1 != (err = i2c_master_send(&dev->i2c_client,&buf,1))) {
	362	printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
	363	dev->name,err);
	364	return -1;
	365	}
	366	if (len != (err = i2c_master_recv(&dev->i2c_client,eedata,len))) {
	367	printk(KERN_WARNING "%s: i2c eeprom read error (err=%d)\n",
	368	dev->name,err);
	369	return -1;
	370	}
	371	for (i = 0; i < len; i++) {
	372	if (0 == (i % 16))
	373	printk(KERN_INFO "%s: i2c eeprom %02x:",dev->name,i);
	374	printk(" %02x",eedata[i]);
	375	if (15 == (i % 16))
	376	printk("\n");
	377	}
	378	return 0;
	379	}
	380
	381	static char *i2c_devs[128] = {
	382	[ 0x20 ] = "mpeg encoder (saa6752hs)",
	383	[ 0xa0 >> 1 ] = "eeprom",
	384	[ 0xc0 >> 1 ] = "tuner (analog)",
	385	[ 0x86 >> 1 ] = "tda9887",
e8018c9e	386	[ 0x5a >> 1 ] = "remote control",
1da177e4 LT	387	};
	388
	389	static void do_i2c_scan(char name, struct i2c_client c)
	390	{
	391	unsigned char buf;
	392	int i,rc;
	393
53c4e955	394	for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
1da177e4 LT	395	c->addr = i;
	396	rc = i2c_master_recv(c,&buf,0);
	397	if (rc < 0)
	398	continue;
	399	printk("%s: i2c scan: found device @ 0x%x [%s]\n",
	400	name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
	401	}
	402	}
	403
1da177e4 LT	404	int saa7134_i2c_register(struct saa7134_dev *dev)
	405	{
	406	dev->i2c_adap = saa7134_adap_template;
	407	dev->i2c_adap.dev.parent = &dev->pci->dev;
	408	strcpy(dev->i2c_adap.name,dev->name);
	409	dev->i2c_adap.algo_data = dev;
fac6986c	410	i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
1da177e4 LT	411	i2c_add_adapter(&dev->i2c_adap);
	412
	413	dev->i2c_client = saa7134_client_template;
	414	dev->i2c_client.adapter = &dev->i2c_adap;
	415
	416	saa7134_i2c_eeprom(dev,dev->eedata,sizeof(dev->eedata));
	417	if (i2c_scan)
	418	do_i2c_scan(dev->name,&dev->i2c_client);
c668f32d JD	419
	420	/* Instantiate the IR receiver device, if present */
	421	saa7134_probe_i2c_ir(dev);
1da177e4 LT	422	return 0;
	423	}
	424
	425	int saa7134_i2c_unregister(struct saa7134_dev *dev)
	426	{
	427	i2c_del_adapter(&dev->i2c_adap);
	428	return 0;
	429	}