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

/*
 * usbvision_i2c.c
 *  i2c algorithm for USB-I2C Bridges
 *
 * Copyright (c) 1999-2007 Joerg Heckenbach <joerg@heckenbach-aw.de>
 *                         Dwaine Garden <dwainegarden@rogers.com>
 *
 * This module is part of usbvision driver project.
 * Updates to driver completed by Dwaine P. Garden
 *
 * 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/kernel.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/uaccess.h>
#include <linux/ioport.h>
#include <linux/errno.h>
#include <linux/usb.h>
#include <linux/i2c.h>
#include "usbvision.h"

#define DBG_I2C		(1 << 0)

static int i2c_debug;

module_param(i2c_debug, int, 0644);			/* debug_i2c_usb mode of the device driver */
MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");

#define PDEBUG(level, fmt, args...) { \
		if (i2c_debug & (level)) \
			printk(KERN_INFO KBUILD_MODNAME ":[%s:%d] " fmt, \
				__func__, __LINE__ , ## args); \
	}

static int usbvision_i2c_write(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
			    short len);
static int usbvision_i2c_read(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
			   short len);

static inline int try_write_address(struct i2c_adapter *i2c_adap,
				    unsigned char addr, int retries)
{
	struct usb_usbvision *usbvision;
	int i, ret = -1;
	char buf[4];

	usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
	buf[0] = 0x00;
	for (i = 0; i <= retries; i++) {
		ret = (usbvision_i2c_write(usbvision, addr, buf, 1));
		if (ret == 1)
			break;	/* success! */
		udelay(5);
		if (i == retries)	/* no success */
			break;
		udelay(10);
	}
	if (i) {
		PDEBUG(DBG_I2C, "Needed %d retries for address %#2x", i, addr);
		PDEBUG(DBG_I2C, "Maybe there's no device at this address");
	}
	return ret;
}

static inline int try_read_address(struct i2c_adapter *i2c_adap,
				   unsigned char addr, int retries)
{
	struct usb_usbvision *usbvision;
	int i, ret = -1;
	char buf[4];

	usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
	for (i = 0; i <= retries; i++) {
		ret = (usbvision_i2c_read(usbvision, addr, buf, 1));
		if (ret == 1)
			break;	/* success! */
		udelay(5);
		if (i == retries)	/* no success */
			break;
		udelay(10);
	}
	if (i) {
		PDEBUG(DBG_I2C, "Needed %d retries for address %#2x", i, addr);
		PDEBUG(DBG_I2C, "Maybe there's no device at this address");
	}
	return ret;
}

static inline int usb_find_address(struct i2c_adapter *i2c_adap,
				   struct i2c_msg *msg, int retries,
				   unsigned char *add)
{
	unsigned short flags = msg->flags;

	unsigned char addr;
	int ret;

	addr = (msg->addr << 1);
	if (flags & I2C_M_RD)
		addr |= 1;

	add[0] = addr;
	if (flags & I2C_M_RD)
		ret = try_read_address(i2c_adap, addr, retries);
	else
		ret = try_write_address(i2c_adap, addr, retries);

	if (ret != 1)
		return -EREMOTEIO;

	return 0;
}

static int
usbvision_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
{
	struct i2c_msg *pmsg;
	struct usb_usbvision *usbvision;
	int i, ret;
	unsigned char addr = 0;

	usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);

	for (i = 0; i < num; i++) {
		pmsg = &msgs[i];
		ret = usb_find_address(i2c_adap, pmsg, i2c_adap->retries, &addr);
		if (ret != 0) {
			PDEBUG(DBG_I2C, "got NAK from device, message #%d", i);
			return (ret < 0) ? ret : -EREMOTEIO;
		}

		if (pmsg->flags & I2C_M_RD) {
			/* read bytes into buffer */
			ret = (usbvision_i2c_read(usbvision, addr, pmsg->buf, pmsg->len));
			if (ret < pmsg->len)
				return (ret < 0) ? ret : -EREMOTEIO;
		} else {
			/* write bytes from buffer */
			ret = (usbvision_i2c_write(usbvision, addr, pmsg->buf, pmsg->len));
			if (ret < pmsg->len)
				return (ret < 0) ? ret : -EREMOTEIO;
		}
	}
	return num;
}

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

/* -----exported algorithm data: -------------------------------------	*/

static struct i2c_algorithm usbvision_algo = {
	.master_xfer   = usbvision_i2c_xfer,
	.smbus_xfer    = NULL,
	.functionality = functionality,
};


/* ----------------------------------------------------------------------- */
/* usbvision specific I2C functions                                        */
/* ----------------------------------------------------------------------- */
static struct i2c_adapter i2c_adap_template;

int usbvision_i2c_register(struct usb_usbvision *usbvision)
{
	static unsigned short saa711x_addrs[] = {
		0x4a >> 1, 0x48 >> 1,	/* SAA7111, SAA7111A and SAA7113 */
		0x42 >> 1, 0x40 >> 1,	/* SAA7114, SAA7115 and SAA7118 */
		I2C_CLIENT_END };

	if (usbvision->registered_i2c)
		return 0;

	usbvision->i2c_adap = i2c_adap_template;

	sprintf(usbvision->i2c_adap.name, "%s-%d-%s", i2c_adap_template.name,
		usbvision->dev->bus->busnum, usbvision->dev->devpath);
	PDEBUG(DBG_I2C, "Adaptername: %s", usbvision->i2c_adap.name);
	usbvision->i2c_adap.dev.parent = &usbvision->dev->dev;

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

	if (usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_IIC_LRNACK) < 0) {
		printk(KERN_ERR "usbvision_i2c_register: can't write reg\n");
		return -EBUSY;
	}

	PDEBUG(DBG_I2C, "I2C   debugging is enabled [i2c]");
	PDEBUG(DBG_I2C, "ALGO   debugging is enabled [i2c]");

	/* register new adapter to i2c module... */

	usbvision->i2c_adap.algo = &usbvision_algo;

	usbvision->i2c_adap.timeout = 100;	/* default values, should       */
	usbvision->i2c_adap.retries = 3;	/* be replaced by defines       */

	i2c_add_adapter(&usbvision->i2c_adap);

	PDEBUG(DBG_I2C, "i2c bus for %s registered", usbvision->i2c_adap.name);

	/* Request the load of the i2c modules we need */
	switch (usbvision_device_data[usbvision->dev_model].codec) {
	case CODEC_SAA7113:
	case CODEC_SAA7111:
		/* Without this delay the detection of the saa711x is
		   hit-and-miss. */
		mdelay(10);
		v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
				&usbvision->i2c_adap,
				"saa7115_auto", 0, saa711x_addrs);
		break;
	}
	if (usbvision_device_data[usbvision->dev_model].tuner == 1) {
		struct v4l2_subdev *sd;
		enum v4l2_i2c_tuner_type type;
		struct tuner_setup tun_setup;

		sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
				&usbvision->i2c_adap,
				"tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
		/* depending on whether we found a demod or not, select
		   the tuner type. */
		type = sd ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;

		sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
				&usbvision->i2c_adap,
				"tuner", 0, v4l2_i2c_tuner_addrs(type));

		if (sd == NULL)
			return -ENODEV;
		if (usbvision->tuner_type != -1) {
			tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
			tun_setup.type = usbvision->tuner_type;
			tun_setup.addr = v4l2_i2c_subdev_addr(sd);
			call_all(usbvision, tuner, s_type_addr, &tun_setup);
		}
	}
	usbvision->registered_i2c = 1;

	return 0;
}

int usbvision_i2c_unregister(struct usb_usbvision *usbvision)
{
	if (!usbvision->registered_i2c)
		return 0;

	i2c_del_adapter(&(usbvision->i2c_adap));
	usbvision->registered_i2c = 0;

	PDEBUG(DBG_I2C, "i2c bus for %s unregistered", usbvision->i2c_adap.name);

	return 0;
}

static int
usbvision_i2c_read_max4(struct usb_usbvision *usbvision, unsigned char addr,
		     char *buf, short len)
{
	int rc, retries;

	for (retries = 5;;) {
		rc = usbvision_write_reg(usbvision, USBVISION_SER_ADRS, addr);
		if (rc < 0)
			return rc;

		/* Initiate byte read cycle                    */
		/* USBVISION_SER_CONT <- d0-d2 n. of bytes to r/w */
		/*                    d3 0=Wr 1=Rd             */
		rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
				      (len & 0x07) | 0x18);
		if (rc < 0)
			return rc;

		/* Test for Busy and ACK */
		do {
			/* USBVISION_SER_CONT -> d4 == 0 busy */
			rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
		} while (rc > 0 && ((rc & 0x10) != 0));	/* Retry while busy */
		if (rc < 0)
			return rc;

		/* USBVISION_SER_CONT -> d5 == 1 Not ack */
		if ((rc & 0x20) == 0)	/* Ack? */
			break;

		/* I2C abort */
		rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);
		if (rc < 0)
			return rc;

		if (--retries < 0)
			return -1;
	}

	switch (len) {
	case 4:
		buf[3] = usbvision_read_reg(usbvision, USBVISION_SER_DAT4);
	case 3:
		buf[2] = usbvision_read_reg(usbvision, USBVISION_SER_DAT3);
	case 2:
		buf[1] = usbvision_read_reg(usbvision, USBVISION_SER_DAT2);
	case 1:
		buf[0] = usbvision_read_reg(usbvision, USBVISION_SER_DAT1);
		break;
	default:
		printk(KERN_ERR
		       "usbvision_i2c_read_max4: buffer length > 4\n");
	}

	if (i2c_debug & DBG_I2C) {
		int idx;

		for (idx = 0; idx < len; idx++)
			PDEBUG(DBG_I2C, "read %x from address %x", (unsigned char)buf[idx], addr);
	}
	return len;
}


static int usbvision_i2c_write_max4(struct usb_usbvision *usbvision,
				 unsigned char addr, const char *buf,
				 short len)
{
	int rc, retries;
	int i;
	unsigned char *value = usbvision->ctrl_urb_buffer;
	unsigned char ser_cont;

	ser_cont = (len & 0x07) | 0x10;

	value[0] = addr;
	value[1] = ser_cont;
	for (i = 0; i < len; i++)
		value[i + 2] = buf[i];

	for (retries = 5;;) {
		rc = usb_control_msg(usbvision->dev,
				     usb_sndctrlpipe(usbvision->dev, 1),
				     USBVISION_OP_CODE,
				     USB_DIR_OUT | USB_TYPE_VENDOR |
				     USB_RECIP_ENDPOINT, 0,
				     (__u16) USBVISION_SER_ADRS, value,
				     len + 2, HZ);

		if (rc < 0)
			return rc;

		rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
				      (len & 0x07) | 0x10);
		if (rc < 0)
			return rc;

		/* Test for Busy and ACK */
		do {
			rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
		} while (rc > 0 && ((rc & 0x10) != 0));	/* Retry while busy */
		if (rc < 0)
			return rc;

		if ((rc & 0x20) == 0)	/* Ack? */
			break;

		/* I2C abort */
		usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);

		if (--retries < 0)
			return -1;

	}

	if (i2c_debug & DBG_I2C) {
		int idx;

		for (idx = 0; idx < len; idx++)
			PDEBUG(DBG_I2C, "wrote %x at address %x", (unsigned char)buf[idx], addr);
	}
	return len;
}

static int usbvision_i2c_write(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
			    short len)
{
	char *buf_ptr = buf;
	int retval;
	int wrcount = 0;
	int count;
	int max_len = 4;

	while (len > 0) {
		count = (len > max_len) ? max_len : len;
		retval = usbvision_i2c_write_max4(usbvision, addr, buf_ptr, count);
		if (retval > 0) {
			len -= count;
			buf_ptr += count;
			wrcount += count;
		} else
			return (retval < 0) ? retval : -EFAULT;
	}
	return wrcount;
}

static int usbvision_i2c_read(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
			   short len)
{
	char temp[4];
	int retval, i;
	int rdcount = 0;
	int count;

	while (len > 0) {
		count = (len > 3) ? 4 : len;
		retval = usbvision_i2c_read_max4(usbvision, addr, temp, count);
		if (retval > 0) {
			for (i = 0; i < len; i++)
				buf[rdcount + i] = temp[i];
			len -= count;
			rdcount += count;
		} else
			return (retval < 0) ? retval : -EFAULT;
	}
	return rdcount;
}

static struct i2c_adapter i2c_adap_template = {
	.owner = THIS_MODULE,
	.name              = "usbvision",
};
Commit	Line	Data
f2242ee5	1	/*
1ff16c20	2	* usbvision_i2c.c
781aa1d1 MCC	3	* i2c algorithm for USB-I2C Bridges
781aa1d1 MCC	4	*
1ff16c20	5	* Copyright (c) 1999-2007 Joerg Heckenbach <joerg@heckenbach-aw.de>
781aa1d1 MCC	6	* Dwaine Garden <dwainegarden@rogers.com>
	7	*
	8	* This module is part of usbvision driver project.
	9	* Updates to driver completed by Dwaine P. Garden
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to the Free Software
	23	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	24	*/
	25
	26
	27	#include <linux/kernel.h>
	28	#include <linux/module.h>
	29	#include <linux/delay.h>
781aa1d1	30	#include <linux/init.h>
6d6a48e5	31	#include <linux/uaccess.h>
781aa1d1 MCC	32	#include <linux/ioport.h>
781aa1d1 MCC	33	#include <linux/errno.h>
781aa1d1 MCC	34	#include <linux/usb.h>
781aa1d1 MCC	35	#include <linux/i2c.h>
483dfdb6	36	#include "usbvision.h"
781aa1d1	37
6d6a48e5	38	#define DBG_I2C (1 << 0)
781aa1d1	39
ff699e6b	40	static int i2c_debug;
483dfdb6	41
6d6a48e5	42	module_param(i2c_debug, int, 0644); /* debug_i2c_usb mode of the device driver */
483dfdb6	43	MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
781aa1d1	44
df18c319 TM	45	#define PDEBUG(level, fmt, args...) { \
df18c319 TM	46	if (i2c_debug & (level)) \
a482f327 GKH	47	printk(KERN_INFO KBUILD_MODNAME ":[%s:%d] " fmt, \
a482f327 GKH	48	__func__, __LINE__ , ## args); \
df18c319	49	}
781aa1d1	50
1ff16c20	51	static int usbvision_i2c_write(struct usb_usbvision usbvision, unsigned char addr, char buf,
2a7e9a26	52	short len);
1ff16c20	53	static int usbvision_i2c_read(struct usb_usbvision usbvision, unsigned char addr, char buf,
2a7e9a26 MCC	54	short len);
2a7e9a26 MCC	55
781aa1d1 MCC	56	static inline int try_write_address(struct i2c_adapter *i2c_adap,
	57	unsigned char addr, int retries)
	58	{
1ff16c20	59	struct usb_usbvision *usbvision;
781aa1d1 MCC	60	int i, ret = -1;
	61	char buf[4];
	62
bf8b20e1	63	usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
781aa1d1 MCC	64	buf[0] = 0x00;
781aa1d1 MCC	65	for (i = 0; i <= retries; i++) {
1ff16c20	66	ret = (usbvision_i2c_write(usbvision, addr, buf, 1));
781aa1d1 MCC	67	if (ret == 1)
781aa1d1 MCC	68	break; /* success! */
c6268461	69	udelay(5);
781aa1d1 MCC	70	if (i == retries) /* no success */
781aa1d1 MCC	71	break;
c6268461	72	udelay(10);
781aa1d1	73	}
483dfdb6	74	if (i) {
6d6a48e5 HV	75	PDEBUG(DBG_I2C, "Needed %d retries for address %#2x", i, addr);
6d6a48e5 HV	76	PDEBUG(DBG_I2C, "Maybe there's no device at this address");
781aa1d1 MCC	77	}
	78	return ret;
	79	}
	80
	81	static inline int try_read_address(struct i2c_adapter *i2c_adap,
	82	unsigned char addr, int retries)
	83	{
1ff16c20	84	struct usb_usbvision *usbvision;
781aa1d1 MCC	85	int i, ret = -1;
	86	char buf[4];
	87
bf8b20e1	88	usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
781aa1d1	89	for (i = 0; i <= retries; i++) {
1ff16c20	90	ret = (usbvision_i2c_read(usbvision, addr, buf, 1));
781aa1d1 MCC	91	if (ret == 1)
781aa1d1 MCC	92	break; /* success! */
c6268461	93	udelay(5);
781aa1d1 MCC	94	if (i == retries) /* no success */
781aa1d1 MCC	95	break;
c6268461	96	udelay(10);
781aa1d1	97	}
483dfdb6	98	if (i) {
6d6a48e5 HV	99	PDEBUG(DBG_I2C, "Needed %d retries for address %#2x", i, addr);
6d6a48e5 HV	100	PDEBUG(DBG_I2C, "Maybe there's no device at this address");
781aa1d1 MCC	101	}
	102	return ret;
	103	}
	104
	105	static inline int usb_find_address(struct i2c_adapter *i2c_adap,
	106	struct i2c_msg *msg, int retries,
	107	unsigned char *add)
	108	{
	109	unsigned short flags = msg->flags;
f2242ee5	110
781aa1d1 MCC	111	unsigned char addr;
781aa1d1 MCC	112	int ret;
781aa1d1	113
819cd82b JD	114	addr = (msg->addr << 1);
	115	if (flags & I2C_M_RD)
	116	addr \|= 1;
781aa1d1	117
819cd82b JD	118	add[0] = addr;
	119	if (flags & I2C_M_RD)
	120	ret = try_read_address(i2c_adap, addr, retries);
	121	else
	122	ret = try_write_address(i2c_adap, addr, retries);
	123
	124	if (ret != 1)
	125	return -EREMOTEIO;
781aa1d1	126
781aa1d1 MCC	127	return 0;
	128	}
	129
	130	static int
1ff16c20	131	usbvision_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
781aa1d1 MCC	132	{
781aa1d1 MCC	133	struct i2c_msg *pmsg;
1ff16c20	134	struct usb_usbvision *usbvision;
781aa1d1	135	int i, ret;
cf8e193a	136	unsigned char addr = 0;
781aa1d1	137
bf8b20e1 TM	138	usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
bf8b20e1 TM	139
781aa1d1 MCC	140	for (i = 0; i < num; i++) {
	141	pmsg = &msgs[i];
	142	ret = usb_find_address(i2c_adap, pmsg, i2c_adap->retries, &addr);
	143	if (ret != 0) {
6d6a48e5	144	PDEBUG(DBG_I2C, "got NAK from device, message #%d", i);
781aa1d1 MCC	145	return (ret < 0) ? ret : -EREMOTEIO;
	146	}
	147
	148	if (pmsg->flags & I2C_M_RD) {
	149	/* read bytes into buffer */
1ff16c20	150	ret = (usbvision_i2c_read(usbvision, addr, pmsg->buf, pmsg->len));
6d6a48e5	151	if (ret < pmsg->len)
781aa1d1	152	return (ret < 0) ? ret : -EREMOTEIO;
781aa1d1 MCC	153	} else {
781aa1d1 MCC	154	/* write bytes from buffer */
1ff16c20	155	ret = (usbvision_i2c_write(usbvision, addr, pmsg->buf, pmsg->len));
6d6a48e5	156	if (ret < pmsg->len)
781aa1d1	157	return (ret < 0) ? ret : -EREMOTEIO;
781aa1d1 MCC	158	}
	159	}
	160	return num;
	161	}
	162
1ff16c20	163	static u32 functionality(struct i2c_adapter *adap)
781aa1d1	164	{
819cd82b	165	return I2C_FUNC_I2C \| I2C_FUNC_SMBUS_EMUL;
781aa1d1 MCC	166	}
781aa1d1 MCC	167
781aa1d1 MCC	168	/* -----exported algorithm data: ------------------------------------- */
781aa1d1 MCC	169
1ff16c20 TM	170	static struct i2c_algorithm usbvision_algo = {
1ff16c20 TM	171	.master_xfer = usbvision_i2c_xfer,
781aa1d1	172	.smbus_xfer = NULL,
1ff16c20	173	.functionality = functionality,
781aa1d1 MCC	174	};
	175
	176
483dfdb6 TM	177	/* ----------------------------------------------------------------------- */
	178	/* usbvision specific I2C functions */
	179	/* ----------------------------------------------------------------------- */
	180	static struct i2c_adapter i2c_adap_template;
483dfdb6	181
1ff16c20	182	int usbvision_i2c_register(struct usb_usbvision *usbvision)
483dfdb6	183	{
1df79537 HV	184	static unsigned short saa711x_addrs[] = {
	185	0x4a >> 1, 0x48 >> 1, /* SAA7111, SAA7111A and SAA7113 */
	186	0x42 >> 1, 0x40 >> 1, /* SAA7114, SAA7115 and SAA7118 */
	187	I2C_CLIENT_END };
	188
8403472f HV	189	if (usbvision->registered_i2c)
	190	return 0;
	191
8fe392b8	192	usbvision->i2c_adap = i2c_adap_template;
483dfdb6	193
0fda5d44 LP	194	sprintf(usbvision->i2c_adap.name, "%s-%d-%s", i2c_adap_template.name,
0fda5d44 LP	195	usbvision->dev->bus->busnum, usbvision->dev->devpath);
6d6a48e5	196	PDEBUG(DBG_I2C, "Adaptername: %s", usbvision->i2c_adap.name);
bf8b20e1 TM	197	usbvision->i2c_adap.dev.parent = &usbvision->dev->dev;
bf8b20e1 TM	198
1df79537	199	i2c_set_adapdata(&usbvision->i2c_adap, &usbvision->v4l2_dev);
483dfdb6 TM	200
483dfdb6 TM	201	if (usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_IIC_LRNACK) < 0) {
240d57bb	202	printk(KERN_ERR "usbvision_i2c_register: can't write reg\n");
483dfdb6 TM	203	return -EBUSY;
	204	}
	205
1df79537 HV	206	PDEBUG(DBG_I2C, "I2C debugging is enabled [i2c]");
	207	PDEBUG(DBG_I2C, "ALGO debugging is enabled [i2c]");
	208
	209	/* register new adapter to i2c module... */
	210
	211	usbvision->i2c_adap.algo = &usbvision_algo;
	212
	213	usbvision->i2c_adap.timeout = 100; /* default values, should */
	214	usbvision->i2c_adap.retries = 3; /* be replaced by defines */
	215
	216	i2c_add_adapter(&usbvision->i2c_adap);
	217
	218	PDEBUG(DBG_I2C, "i2c bus for %s registered", usbvision->i2c_adap.name);
	219
483dfdb6	220	/* Request the load of the i2c modules we need */
5490a7cb	221	switch (usbvision_device_data[usbvision->dev_model].codec) {
483dfdb6	222	case CODEC_SAA7113:
483dfdb6	223	case CODEC_SAA7111:
4d6c871a HV	224	/* Without this delay the detection of the saa711x is
	225	hit-and-miss. */
	226	mdelay(10);
53dacb15	227	v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
9a1f8b34	228	&usbvision->i2c_adap,
53dacb15	229	"saa7115_auto", 0, saa711x_addrs);
483dfdb6 TM	230	break;
483dfdb6 TM	231	}
5490a7cb	232	if (usbvision_device_data[usbvision->dev_model].tuner == 1) {
1df79537 HV	233	struct v4l2_subdev *sd;
	234	enum v4l2_i2c_tuner_type type;
	235	struct tuner_setup tun_setup;
	236
53dacb15	237	sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
9a1f8b34	238	&usbvision->i2c_adap,
53dacb15	239	"tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
1df79537 HV	240	/* depending on whether we found a demod or not, select
	241	the tuner type. */
	242	type = sd ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
	243
53dacb15	244	sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
9a1f8b34	245	&usbvision->i2c_adap,
53dacb15	246	"tuner", 0, v4l2_i2c_tuner_addrs(type));
1df79537	247
8403472f HV	248	if (sd == NULL)
8403472f HV	249	return -ENODEV;
1df79537 HV	250	if (usbvision->tuner_type != -1) {
	251	tun_setup.mode_mask = T_ANALOG_TV \| T_RADIO;
	252	tun_setup.type = usbvision->tuner_type;
	253	tun_setup.addr = v4l2_i2c_subdev_addr(sd);
	254	call_all(usbvision, tuner, s_type_addr, &tun_setup);
	255	}
781aa1d1	256	}
8403472f	257	usbvision->registered_i2c = 1;
781aa1d1	258
1df79537	259	return 0;
1ff16c20 TM	260	}
	261
	262	int usbvision_i2c_unregister(struct usb_usbvision *usbvision)
	263	{
8403472f HV	264	if (!usbvision->registered_i2c)
8403472f HV	265	return 0;
1ff16c20 TM	266
1ff16c20 TM	267	i2c_del_adapter(&(usbvision->i2c_adap));
8403472f	268	usbvision->registered_i2c = 0;
1ff16c20	269
6d6a48e5	270	PDEBUG(DBG_I2C, "i2c bus for %s unregistered", usbvision->i2c_adap.name);
1ff16c20 TM	271
1ff16c20 TM	272	return 0;
483dfdb6 TM	273	}
483dfdb6 TM	274
483dfdb6 TM	275	static int
	276	usbvision_i2c_read_max4(struct usb_usbvision *usbvision, unsigned char addr,
	277	char *buf, short len)
	278	{
	279	int rc, retries;
	280
	281	for (retries = 5;;) {
	282	rc = usbvision_write_reg(usbvision, USBVISION_SER_ADRS, addr);
	283	if (rc < 0)
	284	return rc;
	285
	286	/* Initiate byte read cycle */
	287	/* USBVISION_SER_CONT <- d0-d2 n. of bytes to r/w */
	288	/* d3 0=Wr 1=Rd */
	289	rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
	290	(len & 0x07) \| 0x18);
	291	if (rc < 0)
	292	return rc;
	293
	294	/* Test for Busy and ACK */
	295	do {
	296	/* USBVISION_SER_CONT -> d4 == 0 busy */
	297	rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
	298	} while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */
	299	if (rc < 0)
	300	return rc;
	301
	302	/* USBVISION_SER_CONT -> d5 == 1 Not ack */
	303	if ((rc & 0x20) == 0) /* Ack? */
	304	break;
	305
	306	/* I2C abort */
	307	rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);
	308	if (rc < 0)
	309	return rc;
	310
	311	if (--retries < 0)
	312	return -1;
	313	}
	314
	315	switch (len) {
	316	case 4:
	317	buf[3] = usbvision_read_reg(usbvision, USBVISION_SER_DAT4);
	318	case 3:
	319	buf[2] = usbvision_read_reg(usbvision, USBVISION_SER_DAT3);
	320	case 2:
	321	buf[1] = usbvision_read_reg(usbvision, USBVISION_SER_DAT2);
	322	case 1:
	323	buf[0] = usbvision_read_reg(usbvision, USBVISION_SER_DAT1);
	324	break;
	325	default:
	326	printk(KERN_ERR
	327	"usbvision_i2c_read_max4: buffer length > 4\n");
	328	}
	329
	330	if (i2c_debug & DBG_I2C) {
	331	int idx;
6d6a48e5 HV	332
	333	for (idx = 0; idx < len; idx++)
	334	PDEBUG(DBG_I2C, "read %x from address %x", (unsigned char)buf[idx], addr);
483dfdb6 TM	335	}
	336	return len;
	337	}
	338
	339
	340	static int usbvision_i2c_write_max4(struct usb_usbvision *usbvision,
	341	unsigned char addr, const char *buf,
	342	short len)
	343	{
	344	int rc, retries;
	345	int i;
8926e845	346	unsigned char *value = usbvision->ctrl_urb_buffer;
483dfdb6 TM	347	unsigned char ser_cont;
	348
	349	ser_cont = (len & 0x07) \| 0x10;
	350
	351	value[0] = addr;
	352	value[1] = ser_cont;
	353	for (i = 0; i < len; i++)
	354	value[i + 2] = buf[i];
	355
	356	for (retries = 5;;) {
	357	rc = usb_control_msg(usbvision->dev,
	358	usb_sndctrlpipe(usbvision->dev, 1),
	359	USBVISION_OP_CODE,
	360	USB_DIR_OUT \| USB_TYPE_VENDOR \|
	361	USB_RECIP_ENDPOINT, 0,
	362	(__u16) USBVISION_SER_ADRS, value,
	363	len + 2, HZ);
	364
	365	if (rc < 0)
	366	return rc;
	367
	368	rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
	369	(len & 0x07) \| 0x10);
	370	if (rc < 0)
	371	return rc;
	372
	373	/* Test for Busy and ACK */
	374	do {
	375	rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
	376	} while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */
	377	if (rc < 0)
	378	return rc;
	379
	380	if ((rc & 0x20) == 0) /* Ack? */
	381	break;
	382
	383	/* I2C abort */
	384	usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);
	385
	386	if (--retries < 0)
	387	return -1;
	388
	389	}
	390
	391	if (i2c_debug & DBG_I2C) {
	392	int idx;
6d6a48e5 HV	393
	394	for (idx = 0; idx < len; idx++)
	395	PDEBUG(DBG_I2C, "wrote %x at address %x", (unsigned char)buf[idx], addr);
483dfdb6 TM	396	}
	397	return len;
	398	}
	399
1ff16c20	400	static int usbvision_i2c_write(struct usb_usbvision usbvision, unsigned char addr, char buf,
483dfdb6 TM	401	short len)
483dfdb6 TM	402	{
5490a7cb	403	char *buf_ptr = buf;
483dfdb6 TM	404	int retval;
	405	int wrcount = 0;
	406	int count;
5490a7cb	407	int max_len = 4;
483dfdb6 TM	408
483dfdb6 TM	409	while (len > 0) {
5490a7cb HV	410	count = (len > max_len) ? max_len : len;
5490a7cb HV	411	retval = usbvision_i2c_write_max4(usbvision, addr, buf_ptr, count);
483dfdb6 TM	412	if (retval > 0) {
483dfdb6 TM	413	len -= count;
5490a7cb	414	buf_ptr += count;
483dfdb6 TM	415	wrcount += count;
	416	} else
	417	return (retval < 0) ? retval : -EFAULT;
	418	}
	419	return wrcount;
	420	}
	421
1ff16c20	422	static int usbvision_i2c_read(struct usb_usbvision usbvision, unsigned char addr, char buf,
483dfdb6 TM	423	short len)
	424	{
	425	char temp[4];
	426	int retval, i;
	427	int rdcount = 0;
	428	int count;
483dfdb6 TM	429
	430	while (len > 0) {
	431	count = (len > 3) ? 4 : len;
	432	retval = usbvision_i2c_read_max4(usbvision, addr, temp, count);
	433	if (retval > 0) {
	434	for (i = 0; i < len; i++)
	435	buf[rdcount + i] = temp[i];
	436	len -= count;
	437	rdcount += count;
	438	} else
	439	return (retval < 0) ? retval : -EFAULT;
	440	}
	441	return rdcount;
	442	}
	443
483dfdb6 TM	444	static struct i2c_adapter i2c_adap_template = {
	445	.owner = THIS_MODULE,
	446	.name = "usbvision",
483dfdb6	447	};