[net-next-2.6.git] / drivers / staging / tm6000 / tm6000-i2c.c

/*
 *  tm6000-i2c.c - driver for TM5600/TM6000/TM6010 USB video capture devices
 *
 *  Copyright (C) 2006-2007 Mauro Carvalho Chehab <mchehab@infradead.org>
 *
 *  Copyright (C) 2007 Michel Ludwig <michel.ludwig@gmail.com>
 *	- Fix SMBus Read Byte command
 *
 *  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 version 2
 *
 *  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/kernel.h>
#include <linux/usb.h>
#include <linux/i2c.h>

#include "tm6000.h"
#include "tm6000-regs.h"
#include <media/v4l2-common.h>
#include <media/tuner.h>
#include "tuner-xc2028.h"


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

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

#define i2c_dprintk(lvl, fmt, args...) if (i2c_debug >= lvl) do { \
			printk(KERN_DEBUG "%s at %s: " fmt, \
			dev->name, __FUNCTION__ , ##args); } while (0)

static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
				__u8 reg, char *buf, int len)
{
	int rc;
	unsigned int tsleep;
	unsigned int i2c_packet_limit = 16;

	if (dev->dev_type == TM6010)
		i2c_packet_limit = 64;

	if (!buf)
		return -1;

	if (len < 1 || len > i2c_packet_limit) {
		printk(KERN_ERR "Incorrect length of i2c packet = %d, limit set to %d\n",
			len, i2c_packet_limit);
		return -1;
	}

	/* capture mutex */
	rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR |
		USB_RECIP_DEVICE, REQ_16_SET_GET_I2C_WR1_RDN,
		addr | reg << 8, 0, buf, len);

	if (rc < 0) {
		/* release mutex */
		return rc;
	}

	/* Calculate delay time, 14000us for 64 bytes */
	tsleep = ((len * 200) + 200 + 1000) / 1000;
	msleep(tsleep);

	/* release mutex */
	return rc;
}

/* Generic read - doesn't work fine with 16bit registers */
static int tm6000_i2c_recv_regs(struct tm6000_core *dev, unsigned char addr,
				__u8 reg, char *buf, int len)
{
	int rc;
	u8 b[2];
	unsigned int i2c_packet_limit = 16;

	if (dev->dev_type == TM6010)
		i2c_packet_limit = 64;

	if (!buf)
		return -1;

	if (len < 1 || len > i2c_packet_limit) {
		printk(KERN_ERR "Incorrect length of i2c packet = %d, limit set to %d\n",
			len, i2c_packet_limit);
		return -1;
	}

	/* capture mutex */
	if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
		/*
		 * Workaround an I2C bug when reading from zl10353
		 */
		reg -= 1;
		len += 1;

		rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
			REQ_16_SET_GET_I2C_WR1_RDN, addr | reg << 8, 0, b, len);

		*buf = b[1];
	} else {
		rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
			REQ_16_SET_GET_I2C_WR1_RDN, addr | reg << 8, 0, buf, len);
	}

	/* release mutex */
	return rc;
}

/*
 * read from a 16bit register
 * for example xc2028, xc3028 or xc3028L
 */
static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
				  __u16 reg, char *buf, int len)
{
	int rc;
	unsigned char ureg;

	if (!buf || len != 2)
		return -1;

	/* capture mutex */
	if (dev->dev_type == TM6010) {
		ureg = reg & 0xFF;
		rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR |
			USB_RECIP_DEVICE, REQ_16_SET_GET_I2C_WR1_RDN,
			addr | (reg & 0xFF00), 0, &ureg, 1);

		if (rc < 0) {
			/* release mutex */
			return rc;
		}

		msleep(1400 / 1000);
		rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
			USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
			reg, 0, buf, len);
	} else {
		rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
			USB_RECIP_DEVICE, REQ_14_SET_GET_I2C_WR2_RDN,
			addr, reg, buf, len);
	}

	/* release mutex */
	return rc;
}

static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
			   struct i2c_msg msgs[], int num)
{
	struct tm6000_core *dev = i2c_adap->algo_data;
	int addr, rc, i, byte;

	if (num <= 0)
		return 0;
	for (i = 0; i < num; i++) {
		addr = (msgs[i].addr << 1) & 0xff;
		i2c_dprintk(2, "%s %s addr=0x%x len=%d:",
			 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
			 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
		if (msgs[i].flags & I2C_M_RD) {
			/* read request without preceding register selection */
			/*
			 * The TM6000 only supports a read transaction
			 * immediately after a 1 or 2 byte write to select
			 * a register.  We cannot fulfil this request.
			 */
			i2c_dprintk(2, " read without preceding write not"
				       " supported");
			rc = -EOPNOTSUPP;
			goto err;
		} else if (i + 1 < num && msgs[i].len <= 2 &&
			   (msgs[i + 1].flags & I2C_M_RD) &&
			   msgs[i].addr == msgs[i + 1].addr) {
			/* 1 or 2 byte write followed by a read */
			if (i2c_debug >= 2)
				for (byte = 0; byte < msgs[i].len; byte++)
					printk(" %02x", msgs[i].buf[byte]);
			i2c_dprintk(2, "; joined to read %s len=%d:",
				    i == num - 2 ? "stop" : "nonstop",
				    msgs[i + 1].len);

			if (msgs[i].len == 2) {
				rc = tm6000_i2c_recv_regs16(dev, addr,
					msgs[i].buf[0] << 8 | msgs[i].buf[1],
					msgs[i + 1].buf, msgs[i + 1].len);
			} else {
				rc = tm6000_i2c_recv_regs(dev, addr, msgs[i].buf[0],
					msgs[i + 1].buf, msgs[i + 1].len);
			}

			i++;

			if (addr == dev->tuner_addr << 1) {
				tm6000_set_reg(dev, REQ_50_SET_START, 0, 0);
				tm6000_set_reg(dev, REQ_51_SET_STOP, 0, 0);
			}
			if (i2c_debug >= 2)
				for (byte = 0; byte < msgs[i].len; byte++)
					printk(" %02x", msgs[i].buf[byte]);
		} else {
			/* write bytes */
			if (i2c_debug >= 2)
				for (byte = 0; byte < msgs[i].len; byte++)
					printk(" %02x", msgs[i].buf[byte]);
			rc = tm6000_i2c_send_regs(dev, addr, msgs[i].buf[0],
				msgs[i].buf + 1, msgs[i].len - 1);

			if (addr == dev->tuner_addr  << 1) {
				tm6000_set_reg(dev, REQ_50_SET_START, 0, 0);
				tm6000_set_reg(dev, REQ_51_SET_STOP, 0, 0);
			}
		}
		if (i2c_debug >= 2)
			printk("\n");
		if (rc < 0)
			goto err;
	}

	return num;
err:
	i2c_dprintk(2, " ERROR: %i\n", rc);
	return rc;
}

static int tm6000_i2c_eeprom(struct tm6000_core *dev,
			     unsigned char *eedata, int len)
{
	int i, rc;
	unsigned char *p = eedata;
	unsigned char bytes[17];

	dev->i2c_client.addr = 0xa0 >> 1;

	bytes[16] = '\0';
	for (i = 0; i < len; ) {
	*p = i;
	rc = tm6000_i2c_recv_regs(dev, 0xa0, i, p, 1);
		if (rc < 1) {
			if (p == eedata)
				goto noeeprom;
			else {
				printk(KERN_WARNING
				"%s: i2c eeprom read error (err=%d)\n",
				dev->name, rc);
			}
			return -1;
		}
		p++;
		if (0 == (i % 16))
			printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
		printk(" %02x", eedata[i]);
		if ((eedata[i] >= ' ') && (eedata[i] <= 'z'))
			bytes[i%16] = eedata[i];
		else
			bytes[i%16] = '.';

		i++;

		if (0 == (i % 16)) {
			bytes[16] = '\0';
			printk("  %s\n", bytes);
		}
	}
	if (0 != (i%16)) {
		bytes[i%16] = '\0';
		for (i %= 16; i < 16; i++)
			printk("   ");
	}
	printk("  %s\n", bytes);

	return 0;

noeeprom:
	printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
		       dev->name, rc);
	return rc;
}

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

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

#define mass_write(addr, reg, data...)					\
	{ static const u8 _val[] = data;				\
	rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR,	\
	REQ_16_SET_GET_I2C_WR1_RDN, (reg<<8)+addr, 0x00, (u8 *) _val,	\
	ARRAY_SIZE(_val));						\
	if (rc < 0) {							\
		printk(KERN_ERR "Error on line %d: %d\n", __LINE__, rc);	\
		return rc;						\
	}								\
	msleep(10);							\
	}

static struct i2c_algorithm tm6000_algo = {
	.master_xfer   = tm6000_i2c_xfer,
	.functionality = functionality,
};

static struct i2c_adapter tm6000_adap_template = {
	.owner = THIS_MODULE,
	.name = "tm6000",
	.algo = &tm6000_algo,
};

static struct i2c_client tm6000_client_template = {
	.name = "tm6000 internal",
};

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

/*
 * tm6000_i2c_register()
 * register i2c bus
 */
int tm6000_i2c_register(struct tm6000_core *dev)
{
	unsigned char eedata[256];

	dev->i2c_adap = tm6000_adap_template;
	dev->i2c_adap.dev.parent = &dev->udev->dev;
	strcpy(dev->i2c_adap.name, dev->name);
	dev->i2c_adap.algo_data = dev;
	i2c_add_adapter(&dev->i2c_adap);

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

	i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);

	tm6000_i2c_eeprom(dev, eedata, sizeof(eedata));

	return 0;
}

/*
 * tm6000_i2c_unregister()
 * unregister i2c_bus
 */
int tm6000_i2c_unregister(struct tm6000_core *dev)
{
	i2c_del_adapter(&dev->i2c_adap);
	return 0;
}
Commit	Line	Data
9701dc94	1	/*
d0058645 RP	2	* tm6000-i2c.c - driver for TM5600/TM6000/TM6010 USB video capture devices
	3	*
	4	* Copyright (C) 2006-2007 Mauro Carvalho Chehab <mchehab@infradead.org>
	5	*
	6	* Copyright (C) 2007 Michel Ludwig <michel.ludwig@gmail.com>
	7	* - Fix SMBus Read Byte command
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation version 2
	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.
9701dc94 MCC	21	*/
	22
	23	#include <linux/module.h>
	24	#include <linux/kernel.h>
	25	#include <linux/usb.h>
	26	#include <linux/i2c.h>
	27
	28	#include "tm6000.h"
	29	#include "tm6000-regs.h"
	30	#include <media/v4l2-common.h>
	31	#include <media/tuner.h>
	32	#include "tuner-xc2028.h"
	33
	34
9701dc94 MCC	35	/* ----------------------------------------------------------- */
9701dc94 MCC	36
d7fe4a60	37	static unsigned int i2c_debug;
9701dc94 MCC	38	module_param(i2c_debug, int, 0644);
	39	MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
	40
52e0a72a	41	#define i2c_dprintk(lvl, fmt, args...) if (i2c_debug >= lvl) do { \
9701dc94 MCC	42	printk(KERN_DEBUG "%s at %s: " fmt, \
	43	dev->name, __FUNCTION__ , ##args); } while (0)
	44
4e11502d SR	45	static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
	46	__u8 reg, char *buf, int len)
	47	{
20dead8d DB	48	int rc;
	49	unsigned int tsleep;
	50	unsigned int i2c_packet_limit = 16;
	51
	52	if (dev->dev_type == TM6010)
	53	i2c_packet_limit = 64;
	54
	55	if (!buf)
	56	return -1;
	57
	58	if (len < 1 \|\| len > i2c_packet_limit) {
	59	printk(KERN_ERR "Incorrect length of i2c packet = %d, limit set to %d\n",
	60	len, i2c_packet_limit);
	61	return -1;
	62	}
	63
	64	/* capture mutex */
	65	rc = tm6000_read_write_usb(dev, USB_DIR_OUT \| USB_TYPE_VENDOR \|
	66	USB_RECIP_DEVICE, REQ_16_SET_GET_I2C_WR1_RDN,
	67	addr \| reg << 8, 0, buf, len);
	68
	69	if (rc < 0) {
	70	/* release mutex */
	71	return rc;
	72	}
	73
	74	/* Calculate delay time, 14000us for 64 bytes */
	75	tsleep = ((len * 200) + 200 + 1000) / 1000;
	76	msleep(tsleep);
	77
	78	/* release mutex */
	79	return rc;
4e11502d SR	80	}
	81
	82	/* Generic read - doesn't work fine with 16bit registers */
	83	static int tm6000_i2c_recv_regs(struct tm6000_core *dev, unsigned char addr,
	84	__u8 reg, char *buf, int len)
	85	{
	86	int rc;
02512fe3	87	u8 b[2];
20dead8d DB	88	unsigned int i2c_packet_limit = 16;
	89
	90	if (dev->dev_type == TM6010)
	91	i2c_packet_limit = 64;
	92
	93	if (!buf)
	94	return -1;
	95
	96	if (len < 1 \|\| len > i2c_packet_limit) {
	97	printk(KERN_ERR "Incorrect length of i2c packet = %d, limit set to %d\n",
	98	len, i2c_packet_limit);
	99	return -1;
	100	}
4e11502d	101
20dead8d	102	/* capture mutex */
02512fe3 SR	103	if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
	104	/*
	105	* Workaround an I2C bug when reading from zl10353
	106	*/
	107	reg -= 1;
	108	len += 1;
	109
	110	rc = tm6000_read_write_usb(dev, USB_DIR_IN \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	111	REQ_16_SET_GET_I2C_WR1_RDN, addr \| reg << 8, 0, b, len);
	112
	113	*buf = b[1];
	114	} else {
	115	rc = tm6000_read_write_usb(dev, USB_DIR_IN \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
4e11502d	116	REQ_16_SET_GET_I2C_WR1_RDN, addr \| reg << 8, 0, buf, len);
02512fe3	117	}
4e11502d	118
20dead8d	119	/* release mutex */
4e11502d SR	120	return rc;
	121	}
	122
	123	/*
	124	* read from a 16bit register
	125	* for example xc2028, xc3028 or xc3028L
	126	*/
	127	static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
	128	__u16 reg, char *buf, int len)
	129	{
20dead8d DB	130	int rc;
	131	unsigned char ureg;
	132
	133	if (!buf \|\| len != 2)
	134	return -1;
	135
	136	/* capture mutex */
	137	if (dev->dev_type == TM6010) {
	138	ureg = reg & 0xFF;
	139	rc = tm6000_read_write_usb(dev, USB_DIR_OUT \| USB_TYPE_VENDOR \|
	140	USB_RECIP_DEVICE, REQ_16_SET_GET_I2C_WR1_RDN,
	141	addr \| (reg & 0xFF00), 0, &ureg, 1);
	142
	143	if (rc < 0) {
	144	/* release mutex */
	145	return rc;
	146	}
	147
	148	msleep(1400 / 1000);
	149	rc = tm6000_read_write_usb(dev, USB_DIR_IN \| USB_TYPE_VENDOR \|
	150	USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
	151	reg, 0, buf, len);
	152	} else {
	153	rc = tm6000_read_write_usb(dev, USB_DIR_IN \| USB_TYPE_VENDOR \|
	154	USB_RECIP_DEVICE, REQ_14_SET_GET_I2C_WR2_RDN,
	155	addr, reg, buf, len);
	156	}
	157
	158	/* release mutex */
	159	return rc;
4e11502d SR	160	}
4e11502d SR	161
9701dc94 MCC	162	static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
	163	struct i2c_msg msgs[], int num)
	164	{
	165	struct tm6000_core *dev = i2c_adap->algo_data;
	166	int addr, rc, i, byte;
	167
	168	if (num <= 0)
	169	return 0;
	170	for (i = 0; i < num; i++) {
e30b9d6c	171	addr = (msgs[i].addr << 1) & 0xff;
52e0a72a	172	i2c_dprintk(2, "%s %s addr=0x%x len=%d:",
9701dc94 MCC	173	(msgs[i].flags & I2C_M_RD) ? "read" : "write",
9701dc94 MCC	174	i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
427f7fac	175	if (msgs[i].flags & I2C_M_RD) {
e30b9d6c CP	176	/* read request without preceding register selection */
	177	/*
	178	* The TM6000 only supports a read transaction
	179	* immediately after a 1 or 2 byte write to select
	180	* a register. We cannot fulfil this request.
	181	*/
	182	i2c_dprintk(2, " read without preceding write not"
	183	" supported");
	184	rc = -EOPNOTSUPP;
	185	goto err;
	186	} else if (i + 1 < num && msgs[i].len <= 2 &&
	187	(msgs[i + 1].flags & I2C_M_RD) &&
	188	msgs[i].addr == msgs[i + 1].addr) {
	189	/* 1 or 2 byte write followed by a read */
	190	if (i2c_debug >= 2)
	191	for (byte = 0; byte < msgs[i].len; byte++)
9701dc94	192	printk(" %02x", msgs[i].buf[byte]);
e30b9d6c CP	193	i2c_dprintk(2, "; joined to read %s len=%d:",
	194	i == num - 2 ? "stop" : "nonstop",
	195	msgs[i + 1].len);
4e11502d SR	196
	197	if (msgs[i].len == 2) {
	198	rc = tm6000_i2c_recv_regs16(dev, addr,
	199	msgs[i].buf[0] << 8 \| msgs[i].buf[1],
	200	msgs[i + 1].buf, msgs[i + 1].len);
	201	} else {
	202	rc = tm6000_i2c_recv_regs(dev, addr, msgs[i].buf[0],
	203	msgs[i + 1].buf, msgs[i + 1].len);
	204	}
	205
cf9e1509	206	i++;
20cabed4	207
685b1229	208	if (addr == dev->tuner_addr << 1) {
f1434f4e SR	209	tm6000_set_reg(dev, REQ_50_SET_START, 0, 0);
f1434f4e SR	210	tm6000_set_reg(dev, REQ_51_SET_STOP, 0, 0);
20cabed4	211	}
e30b9d6c CP	212	if (i2c_debug >= 2)
e30b9d6c CP	213	for (byte = 0; byte < msgs[i].len; byte++)
cf9e1509	214	printk(" %02x", msgs[i].buf[byte]);
9701dc94 MCC	215	} else {
9701dc94 MCC	216	/* write bytes */
e30b9d6c	217	if (i2c_debug >= 2)
9701dc94 MCC	218	for (byte = 0; byte < msgs[i].len; byte++)
9701dc94 MCC	219	printk(" %02x", msgs[i].buf[byte]);
4e11502d	220	rc = tm6000_i2c_send_regs(dev, addr, msgs[i].buf[0],
e30b9d6c	221	msgs[i].buf + 1, msgs[i].len - 1);
20cabed4	222
685b1229	223	if (addr == dev->tuner_addr << 1) {
f1434f4e SR	224	tm6000_set_reg(dev, REQ_50_SET_START, 0, 0);
f1434f4e SR	225	tm6000_set_reg(dev, REQ_51_SET_STOP, 0, 0);
20cabed4	226	}
9701dc94	227	}
e30b9d6c	228	if (i2c_debug >= 2)
9701dc94 MCC	229	printk("\n");
	230	if (rc < 0)
	231	goto err;
	232	}
	233
	234	return num;
	235	err:
52e0a72a	236	i2c_dprintk(2, " ERROR: %i\n", rc);
9701dc94 MCC	237	return rc;
	238	}
	239
d4e15bcd MCC	240	static int tm6000_i2c_eeprom(struct tm6000_core *dev,
d4e15bcd MCC	241	unsigned char *eedata, int len)
9701dc94 MCC	242	{
	243	int i, rc;
	244	unsigned char *p = eedata;
	245	unsigned char bytes[17];
	246
	247	dev->i2c_client.addr = 0xa0 >> 1;
	248
d4e15bcd MCC	249	bytes[16] = '\0';
	250	for (i = 0; i < len; ) {
	251	*p = i;
4e11502d	252	rc = tm6000_i2c_recv_regs(dev, 0xa0, i, p, 1);
d4e15bcd MCC	253	if (rc < 1) {
	254	if (p == eedata)
	255	goto noeeprom;
	256	else {
9701dc94 MCC	257	printk(KERN_WARNING
	258	"%s: i2c eeprom read error (err=%d)\n",
	259	dev->name, rc);
	260	}
	261	return -1;
	262	}
	263	p++;
	264	if (0 == (i % 16))
	265	printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
	266	printk(" %02x", eedata[i]);
52e0a72a	267	if ((eedata[i] >= ' ') && (eedata[i] <= 'z'))
d4e15bcd	268	bytes[i%16] = eedata[i];
52e0a72a TT	269	else
52e0a72a TT	270	bytes[i%16] = '.';
d4e15bcd MCC	271
	272	i++;
	273
	274	if (0 == (i % 16)) {
	275	bytes[16] = '\0';
9701dc94 MCC	276	printk(" %s\n", bytes);
	277	}
	278	}
d4e15bcd MCC	279	if (0 != (i%16)) {
	280	bytes[i%16] = '\0';
	281	for (i %= 16; i < 16; i++)
	282	printk(" ");
9701dc94	283	}
d4e15bcd MCC	284	printk(" %s\n", bytes);
d4e15bcd MCC	285
9701dc94	286	return 0;
d4e15bcd MCC	287
	288	noeeprom:
	289	printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
	290	dev->name, rc);
	291	return rc;
9701dc94 MCC	292	}
	293
	294	/* ----------------------------------------------------------- */
	295
9701dc94 MCC	296	/*
	297	* functionality()
	298	*/
	299	static u32 functionality(struct i2c_adapter *adap)
	300	{
	301	return I2C_FUNC_SMBUS_EMUL;
	302	}
	303
9701dc94	304	#define mass_write(addr, reg, data...) \
52e0a72a TT	305	{ static const u8 _val[] = data; \
	306	rc = tm6000_read_write_usb(dev, USB_DIR_OUT \| USB_TYPE_VENDOR, \
	307	REQ_16_SET_GET_I2C_WR1_RDN, (reg<<8)+addr, 0x00, (u8 *) _val, \
9701dc94	308	ARRAY_SIZE(_val)); \
52e0a72a TT	309	if (rc < 0) { \
52e0a72a TT	310	printk(KERN_ERR "Error on line %d: %d\n", __LINE__, rc); \
9701dc94 MCC	311	return rc; \
9701dc94 MCC	312	} \
52e0a72a	313	msleep(10); \
9701dc94 MCC	314	}
9701dc94 MCC	315
9701dc94 MCC	316	static struct i2c_algorithm tm6000_algo = {
9701dc94 MCC	317	.master_xfer = tm6000_i2c_xfer,
9701dc94 MCC	318	.functionality = functionality,
	319	};
	320
	321	static struct i2c_adapter tm6000_adap_template = {
9701dc94	322	.owner = THIS_MODULE,
9701dc94	323	.name = "tm6000",
9701dc94	324	.algo = &tm6000_algo,
9701dc94 MCC	325	};
	326
	327	static struct i2c_client tm6000_client_template = {
	328	.name = "tm6000 internal",
	329	};
	330
	331	/* ----------------------------------------------------------- */
	332
9701dc94 MCC	333	/*
	334	* tm6000_i2c_register()
	335	* register i2c bus
	336	*/
	337	int tm6000_i2c_register(struct tm6000_core *dev)
	338	{
d4e15bcd MCC	339	unsigned char eedata[256];
d4e15bcd MCC	340
9701dc94 MCC	341	dev->i2c_adap = tm6000_adap_template;
	342	dev->i2c_adap.dev.parent = &dev->udev->dev;
	343	strcpy(dev->i2c_adap.name, dev->name);
	344	dev->i2c_adap.algo_data = dev;
	345	i2c_add_adapter(&dev->i2c_adap);
	346
	347	dev->i2c_client = tm6000_client_template;
	348	dev->i2c_client.adapter = &dev->i2c_adap;
	349
427f7fac	350	i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
9701dc94	351
d4e15bcd MCC	352	tm6000_i2c_eeprom(dev, eedata, sizeof(eedata));
d4e15bcd MCC	353
9701dc94 MCC	354	return 0;
	355	}
	356
	357	/*
	358	* tm6000_i2c_unregister()
	359	* unregister i2c_bus
	360	*/
	361	int tm6000_i2c_unregister(struct tm6000_core *dev)
	362	{
	363	i2c_del_adapter(&dev->i2c_adap);
	364	return 0;
	365	}