[deliverable/linux.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 "saa7134.h"
#include "saa7134-reg.h"

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