[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / usb / em28xx / em28xx-i2c.c

/*
   em28xx-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices

   Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
		      Markus Rechberger <mrechberger@gmail.com>
		      Mauro Carvalho Chehab <mchehab@infradead.org>
		      Sascha Sommer <saschasommer@freenet.de>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/usb.h>
#include <linux/i2c.h>

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

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

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

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

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

/*
 * em2800_i2c_send_max4()
 * send up to 4 bytes to the i2c device
 */
static int em2800_i2c_send_max4(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
{
	int ret;
	int write_timeout;
	u8 b2[6];
	BUG_ON(len < 1 || len > 4);
	b2[5] = 0x80 + len - 1;
	b2[4] = addr;
	b2[3] = buf[0];
	if (len > 1)
		b2[2] = buf[1];
	if (len > 2)
		b2[1] = buf[2];
	if (len > 3)
		b2[0] = buf[3];

	ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
	if (ret != 2 + len) {
		em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
		return -EIO;
	}
	for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
	     write_timeout -= 5) {
		ret = dev->em28xx_read_reg(dev, 0x05);
		if (ret == 0x80 + len - 1)
			return len;
		msleep(5);
	}
	em28xx_warn("i2c write timed out\n");
	return -EIO;
}

/*
 * em2800_i2c_send_bytes()
 */
static int em2800_i2c_send_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
{
	u8 *bufPtr = buf;
	int ret;
	int wrcount = 0;
	int count;
	int maxLen = 4;
	while (len > 0) {
		count = (len > maxLen) ? maxLen : len;
		ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
		if (ret > 0) {
			len -= count;
			bufPtr += count;
			wrcount += count;
		} else
			return (ret < 0) ? ret : -EFAULT;
	}
	return wrcount;
}

/*
 * em2800_i2c_check_for_device()
 * check if there is a i2c_device at the supplied address
 */
static int em2800_i2c_check_for_device(struct em28xx *dev, u8 addr)
{
	u8 msg;
	int ret;
	int write_timeout;
	msg = addr;
	ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
	if (ret < 0) {
		em28xx_warn("setting i2c device address failed (error=%i)\n",
			    ret);
		return ret;
	}
	msg = 0x84;
	ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
	if (ret < 0) {
		em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
		return ret;
	}
	for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
	     write_timeout -= 5) {
		unsigned reg = dev->em28xx_read_reg(dev, 0x5);

		if (reg == 0x94)
			return -ENODEV;
		else if (reg == 0x84)
			return 0;
		msleep(5);
	}
	return -ENODEV;
}

/*
 * em2800_i2c_recv_bytes()
 * read from the i2c device
 */
static int em2800_i2c_recv_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
{
	int ret;
	/* check for the device and set i2c read address */
	ret = em2800_i2c_check_for_device(dev, addr);
	if (ret) {
		em28xx_warn
		    ("preparing read at i2c address 0x%x failed (error=%i)\n",
		     addr, ret);
		return ret;
	}
	ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
	if (ret < 0) {
		em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
			    addr, ret);
		return ret;
	}
	return ret;
}

/*
 * em28xx_i2c_send_bytes()
 */
static int em28xx_i2c_send_bytes(struct em28xx *dev, u16 addr, u8 *buf,
				 u16 len, int stop)
{
	int wrcount = 0;
	int write_timeout, ret;

	wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);

	/* Seems to be required after a write */
	for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
	     write_timeout -= 5) {
		ret = dev->em28xx_read_reg(dev, 0x05);
		if (!ret)
			break;
		msleep(5);
	}

	return wrcount;
}

/*
 * em28xx_i2c_recv_bytes()
 * read a byte from the i2c device
 */
static int em28xx_i2c_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf, u16 len)
{
	int ret;
	ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
	if (ret < 0) {
		em28xx_warn("reading i2c device failed (error=%i)\n", ret);
		return ret;
	}
	if (dev->em28xx_read_reg(dev, 0x5) != 0)
		return -ENODEV;
	return ret;
}

/*
 * em28xx_i2c_check_for_device()
 * check if there is a i2c_device at the supplied address
 */
static int em28xx_i2c_check_for_device(struct em28xx *dev, u16 addr)
{
	int ret;

	ret = dev->em28xx_read_reg_req(dev, 2, addr);
	if (ret < 0) {
		em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
		return ret;
	}
	if (dev->em28xx_read_reg(dev, 0x5) != 0)
		return -ENODEV;
	return 0;
}

/*
 * em28xx_i2c_xfer()
 * the main i2c transfer function
 */
static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
			   struct i2c_msg msgs[], int num)
{
	struct em28xx *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;
		dprintk2(2, "%s %s addr=%x len=%d:",
			 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
			 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
		if (!msgs[i].len) { /* no len: check only for device presence */
			if (dev->board.is_em2800)
				rc = em2800_i2c_check_for_device(dev, addr);
			else
				rc = em28xx_i2c_check_for_device(dev, addr);
			if (rc < 0) {
				dprintk2(2, " no device\n");
				return rc;
			}

		} else if (msgs[i].flags & I2C_M_RD) {
			/* read bytes */
			if (dev->board.is_em2800)
				rc = em2800_i2c_recv_bytes(dev, addr,
							   msgs[i].buf,
							   msgs[i].len);
			else
				rc = em28xx_i2c_recv_bytes(dev, addr,
							   msgs[i].buf,
							   msgs[i].len);
			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]);
			}
			if (dev->board.is_em2800)
				rc = em2800_i2c_send_bytes(dev, addr,
							   msgs[i].buf,
							   msgs[i].len);
			else
				rc = em28xx_i2c_send_bytes(dev, addr,
							   msgs[i].buf,
							   msgs[i].len,
							   i == num - 1);
		}
		if (rc < 0)
			goto err;
		if (i2c_debug >= 2)
			printk("\n");
	}

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

/* based on linux/sunrpc/svcauth.h and linux/hash.h
 * The original hash function returns a different value, if arch is x86_64
 *  or i386.
 */
static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
{
	unsigned long hash = 0;
	unsigned long l = 0;
	int len = 0;
	unsigned char c;
	do {
		if (len == length) {
			c = (char)len;
			len = -1;
		} else
			c = *buf++;
		l = (l << 8) | c;
		len++;
		if ((len & (32 / 8 - 1)) == 0)
			hash = ((hash^l) * 0x9e370001UL);
	} while (len);

	return (hash >> (32 - bits)) & 0xffffffffUL;
}

static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
{
	unsigned char buf, *p = eedata;
	struct em28xx_eeprom *em_eeprom = (void *)eedata;
	int i, err, size = len, block;

	if (dev->chip_id == CHIP_ID_EM2874 ||
	    dev->chip_id == CHIP_ID_EM28174 ||
	    dev->chip_id == CHIP_ID_EM2884) {
		/* Empia switched to a 16-bit addressable eeprom in newer
		   devices.  While we could certainly write a routine to read
		   the eeprom, there is nothing of use in there that cannot be
		   accessed through registers, and there is the risk that we
		   could corrupt the eeprom (since a 16-bit read call is
		   interpreted as a write call by 8-bit eeproms).
		*/
		return 0;
	}

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

	/* Check if board has eeprom */
	err = i2c_master_recv(&dev->i2c_client, &buf, 0);
	if (err < 0) {
		em28xx_errdev("board has no eeprom\n");
		memset(eedata, 0, len);
		return -ENODEV;
	}

	buf = 0;

	err = i2c_master_send(&dev->i2c_client, &buf, 1);
	if (err != 1) {
		printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
		       dev->name, err);
		return err;
	}
	while (size > 0) {
		if (size > 16)
			block = 16;
		else
			block = size;

		if (block !=
		    (err = i2c_master_recv(&dev->i2c_client, p, block))) {
			printk(KERN_WARNING
			       "%s: i2c eeprom read error (err=%d)\n",
			       dev->name, err);
			return err;
		}
		size -= block;
		p += block;
	}
	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");
	}

	if (em_eeprom->id == 0x9567eb1a)
		dev->hash = em28xx_hash_mem(eedata, len, 32);

	printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
	       dev->name, em_eeprom->id, dev->hash);

	printk(KERN_INFO "%s: EEPROM info:\n", dev->name);

	switch (em_eeprom->chip_conf >> 4 & 0x3) {
	case 0:
		printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
		break;
	case 1:
		printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
				 dev->name);
		break;
	case 2:
		printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n",
				 dev->name);
		break;
	case 3:
		printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n",
				 dev->name);
		break;
	}

	if (em_eeprom->chip_conf & 1 << 3)
		printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);

	if (em_eeprom->chip_conf & 1 << 2)
		printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);

	switch (em_eeprom->chip_conf & 0x3) {
	case 0:
		printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
		break;
	case 1:
		printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
		break;
	case 2:
		printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
		break;
	case 3:
		printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
		break;
	}
	printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
				dev->name,
				em_eeprom->string_idx_table,
				em_eeprom->string1,
				em_eeprom->string2,
				em_eeprom->string3);

	return 0;
}

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

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

static struct i2c_algorithm em28xx_algo = {
	.master_xfer   = em28xx_i2c_xfer,
	.functionality = functionality,
};

static struct i2c_adapter em28xx_adap_template = {
	.owner = THIS_MODULE,
	.name = "em28xx",
	.algo = &em28xx_algo,
};

static struct i2c_client em28xx_client_template = {
	.name = "em28xx internal",
};

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

/*
 * i2c_devs
 * incomplete list of known devices
 */
static char *i2c_devs[128] = {
	[0x4a >> 1] = "saa7113h",
	[0x52 >> 1] = "drxk",
	[0x60 >> 1] = "remote IR sensor",
	[0x8e >> 1] = "remote IR sensor",
	[0x86 >> 1] = "tda9887",
	[0x80 >> 1] = "msp34xx",
	[0x88 >> 1] = "msp34xx",
	[0xa0 >> 1] = "eeprom",
	[0xb0 >> 1] = "tda9874",
	[0xb8 >> 1] = "tvp5150a",
	[0xba >> 1] = "webcam sensor or tvp5150a",
	[0xc0 >> 1] = "tuner (analog)",
	[0xc2 >> 1] = "tuner (analog)",
	[0xc4 >> 1] = "tuner (analog)",
	[0xc6 >> 1] = "tuner (analog)",
};

/*
 * do_i2c_scan()
 * check i2c address range for devices
 */
void em28xx_do_i2c_scan(struct em28xx *dev)
{
	u8 i2c_devicelist[128];
	unsigned char buf;
	int i, rc;

	memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));

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

	dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
					ARRAY_SIZE(i2c_devicelist), 32);
}

/*
 * em28xx_i2c_register()
 * register i2c bus
 */
int em28xx_i2c_register(struct em28xx *dev)
{
	int retval;

	BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
	BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
	dev->i2c_adap = em28xx_adap_template;
	dev->i2c_adap.dev.parent = &dev->udev->dev;
	strcpy(dev->i2c_adap.name, dev->name);
	dev->i2c_adap.algo_data = dev;
	i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);

	retval = i2c_add_adapter(&dev->i2c_adap);
	if (retval < 0) {
		em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
			__func__, retval);
		return retval;
	}

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

	retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
	if ((retval < 0) && (retval != -ENODEV)) {
		em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
			__func__, retval);

		return retval;
	}

	if (i2c_scan)
		em28xx_do_i2c_scan(dev);

	return 0;
}

/*
 * em28xx_i2c_unregister()
 * unregister i2c_bus
 */
int em28xx_i2c_unregister(struct em28xx *dev)
{
	i2c_del_adapter(&dev->i2c_adap);
	return 0;
}
Commit	Line	Data
a6c2ba28	1	/*
f7abcd38	2	em28xx-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
a6c2ba28	3
f7abcd38 MCC	4	Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
f7abcd38 MCC	5	Markus Rechberger <mrechberger@gmail.com>
2e7c6dc3	6	Mauro Carvalho Chehab <mchehab@infradead.org>
f7abcd38	7	Sascha Sommer <saschasommer@freenet.de>
a6c2ba28 AM	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; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
	21	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	22	*/
	23
	24	#include <linux/module.h>
	25	#include <linux/kernel.h>
	26	#include <linux/usb.h>
	27	#include <linux/i2c.h>
a6c2ba28	28
f7abcd38	29	#include "em28xx.h"
6c362c8e	30	#include "tuner-xc2028.h"
5e453dc7	31	#include <media/v4l2-common.h>
d5e52653	32	#include <media/tuner.h>
a6c2ba28 AM	33
	34	/* ----------------------------------------------------------- */
	35
ff699e6b	36	static unsigned int i2c_scan;
a6c2ba28 AM	37	module_param(i2c_scan, int, 0444);
	38	MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
	39
ff699e6b	40	static unsigned int i2c_debug;
a6c2ba28 AM	41	module_param(i2c_debug, int, 0644);
	42	MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
	43
6ea54d93 DSL	44	#define dprintk2(lvl, fmt, args...) \
	45	do { \
	46	if (i2c_debug >= lvl) { \
	47	printk(KERN_DEBUG "%s at %s: " fmt, \
	48	dev->name, __func__ , ##args); \
	49	} \
	50	} while (0)
a6c2ba28 AM	51
a6c2ba28 AM	52	/*
596d92d5 MCC	53	* em2800_i2c_send_max4()
	54	* send up to 4 bytes to the i2c device
	55	*/
a6bad040	56	static int em2800_i2c_send_max4(struct em28xx dev, u8 addr, u8 buf, u16 len)
596d92d5 MCC	57	{
	58	int ret;
	59	int write_timeout;
a6bad040	60	u8 b2[6];
596d92d5 MCC	61	BUG_ON(len < 1 \|\| len > 4);
	62	b2[5] = 0x80 + len - 1;
	63	b2[4] = addr;
	64	b2[3] = buf[0];
	65	if (len > 1)
	66	b2[2] = buf[1];
	67	if (len > 2)
	68	b2[1] = buf[2];
	69	if (len > 3)
	70	b2[0] = buf[3];
	71
3acf2809	72	ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
596d92d5	73	if (ret != 2 + len) {
beb7dd86	74	em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
596d92d5 MCC	75	return -EIO;
	76	}
	77	for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
	78	write_timeout -= 5) {
3acf2809	79	ret = dev->em28xx_read_reg(dev, 0x05);
596d92d5 MCC	80	if (ret == 0x80 + len - 1)
596d92d5 MCC	81	return len;
e8e41da4	82	msleep(5);
596d92d5	83	}
3acf2809	84	em28xx_warn("i2c write timed out\n");
596d92d5 MCC	85	return -EIO;
	86	}
	87
	88	/*
	89	* em2800_i2c_send_bytes()
	90	*/
a6bad040	91	static int em2800_i2c_send_bytes(struct em28xx dev, u8 addr, u8 buf, u16 len)
596d92d5	92	{
a6bad040	93	u8 *bufPtr = buf;
596d92d5 MCC	94	int ret;
	95	int wrcount = 0;
	96	int count;
	97	int maxLen = 4;
596d92d5 MCC	98	while (len > 0) {
	99	count = (len > maxLen) ? maxLen : len;
	100	ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
	101	if (ret > 0) {
	102	len -= count;
	103	bufPtr += count;
	104	wrcount += count;
	105	} else
	106	return (ret < 0) ? ret : -EFAULT;
	107	}
	108	return wrcount;
	109	}
	110
	111	/*
	112	* em2800_i2c_check_for_device()
	113	* check if there is a i2c_device at the supplied address
	114	*/
a6bad040	115	static int em2800_i2c_check_for_device(struct em28xx *dev, u8 addr)
596d92d5	116	{
a6bad040	117	u8 msg;
596d92d5 MCC	118	int ret;
	119	int write_timeout;
	120	msg = addr;
3acf2809	121	ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
596d92d5	122	if (ret < 0) {
3acf2809	123	em28xx_warn("setting i2c device address failed (error=%i)\n",
596d92d5 MCC	124	ret);
	125	return ret;
	126	}
	127	msg = 0x84;
3acf2809	128	ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
596d92d5	129	if (ret < 0) {
3acf2809	130	em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
596d92d5 MCC	131	return ret;
	132	}
	133	for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
	134	write_timeout -= 5) {
d45b9b8a HV	135	unsigned reg = dev->em28xx_read_reg(dev, 0x5);
	136
	137	if (reg == 0x94)
596d92d5	138	return -ENODEV;
d45b9b8a	139	else if (reg == 0x84)
596d92d5	140	return 0;
e8e41da4	141	msleep(5);
596d92d5 MCC	142	}
	143	return -ENODEV;
	144	}
	145
	146	/*
	147	* em2800_i2c_recv_bytes()
	148	* read from the i2c device
	149	*/
a6bad040	150	static int em2800_i2c_recv_bytes(struct em28xx dev, u8 addr, u8 buf, u16 len)
596d92d5 MCC	151	{
	152	int ret;
	153	/* check for the device and set i2c read address */
	154	ret = em2800_i2c_check_for_device(dev, addr);
	155	if (ret) {
3acf2809	156	em28xx_warn
596d92d5 MCC	157	("preparing read at i2c address 0x%x failed (error=%i)\n",
	158	addr, ret);
	159	return ret;
	160	}
3acf2809	161	ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
596d92d5	162	if (ret < 0) {
3acf2809	163	em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
596d92d5 MCC	164	addr, ret);
	165	return ret;
	166	}
	167	return ret;
	168	}
	169
	170	/*
3acf2809	171	* em28xx_i2c_send_bytes()
a6c2ba28	172	*/
a6bad040 FS	173	static int em28xx_i2c_send_bytes(struct em28xx dev, u16 addr, u8 buf,
a6bad040 FS	174	u16 len, int stop)
a6c2ba28 AM	175	{
a6c2ba28 AM	176	int wrcount = 0;
bbc70e64	177	int write_timeout, ret;
a6c2ba28	178
3acf2809	179	wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
a6c2ba28	180
bbc70e64 MCC	181	/* Seems to be required after a write */
	182	for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
	183	write_timeout -= 5) {
	184	ret = dev->em28xx_read_reg(dev, 0x05);
	185	if (!ret)
	186	break;
	187	msleep(5);
	188	}
	189
a6c2ba28 AM	190	return wrcount;
	191	}
	192
	193	/*
3acf2809	194	* em28xx_i2c_recv_bytes()
a6c2ba28 AM	195	* read a byte from the i2c device
a6c2ba28 AM	196	*/
a6bad040	197	static int em28xx_i2c_recv_bytes(struct em28xx dev, u16 addr, u8 buf, u16 len)
a6c2ba28 AM	198	{
a6c2ba28 AM	199	int ret;
3acf2809	200	ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
a6c2ba28	201	if (ret < 0) {
3acf2809	202	em28xx_warn("reading i2c device failed (error=%i)\n", ret);
a6c2ba28 AM	203	return ret;
a6c2ba28 AM	204	}
3acf2809	205	if (dev->em28xx_read_reg(dev, 0x5) != 0)
a6c2ba28 AM	206	return -ENODEV;
	207	return ret;
	208	}
	209
	210	/*
3acf2809	211	* em28xx_i2c_check_for_device()
a6c2ba28 AM	212	* check if there is a i2c_device at the supplied address
a6c2ba28 AM	213	*/
a6bad040	214	static int em28xx_i2c_check_for_device(struct em28xx *dev, u16 addr)
a6c2ba28	215	{
a6c2ba28	216	int ret;
a6c2ba28	217
3acf2809	218	ret = dev->em28xx_read_reg_req(dev, 2, addr);
a6c2ba28	219	if (ret < 0) {
3acf2809	220	em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
a6c2ba28 AM	221	return ret;
a6c2ba28 AM	222	}
3acf2809	223	if (dev->em28xx_read_reg(dev, 0x5) != 0)
a6c2ba28 AM	224	return -ENODEV;
	225	return 0;
	226	}
	227
	228	/*
3acf2809	229	* em28xx_i2c_xfer()
a6c2ba28 AM	230	* the main i2c transfer function
a6c2ba28 AM	231	*/
3acf2809	232	static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
a6c2ba28 AM	233	struct i2c_msg msgs[], int num)
a6c2ba28 AM	234	{
3acf2809	235	struct em28xx *dev = i2c_adap->algo_data;
a6c2ba28 AM	236	int addr, rc, i, byte;
	237
	238	if (num <= 0)
	239	return 0;
	240	for (i = 0; i < num; i++) {
	241	addr = msgs[i].addr << 1;
6ea54d93	242	dprintk2(2, "%s %s addr=%x len=%d:",
a6c2ba28 AM	243	(msgs[i].flags & I2C_M_RD) ? "read" : "write",
a6c2ba28 AM	244	i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
6ea54d93	245	if (!msgs[i].len) { /* no len: check only for device presence */
505b6d0b	246	if (dev->board.is_em2800)
596d92d5 MCC	247	rc = em2800_i2c_check_for_device(dev, addr);
596d92d5 MCC	248	else
3acf2809	249	rc = em28xx_i2c_check_for_device(dev, addr);
a6c2ba28	250	if (rc < 0) {
6ea54d93	251	dprintk2(2, " no device\n");
a6c2ba28 AM	252	return rc;
	253	}
	254
596d92d5	255	} else if (msgs[i].flags & I2C_M_RD) {
a6c2ba28	256	/* read bytes */
505b6d0b	257	if (dev->board.is_em2800)
596d92d5 MCC	258	rc = em2800_i2c_recv_bytes(dev, addr,
	259	msgs[i].buf,
	260	msgs[i].len);
	261	else
3acf2809	262	rc = em28xx_i2c_recv_bytes(dev, addr,
596d92d5 MCC	263	msgs[i].buf,
596d92d5 MCC	264	msgs[i].len);
6ea54d93 DSL	265	if (i2c_debug >= 2) {
6ea54d93 DSL	266	for (byte = 0; byte < msgs[i].len; byte++)
a6c2ba28	267	printk(" %02x", msgs[i].buf[byte]);
a6c2ba28 AM	268	}
	269	} else {
	270	/* write bytes */
6ea54d93	271	if (i2c_debug >= 2) {
a6c2ba28 AM	272	for (byte = 0; byte < msgs[i].len; byte++)
	273	printk(" %02x", msgs[i].buf[byte]);
	274	}
505b6d0b	275	if (dev->board.is_em2800)
596d92d5 MCC	276	rc = em2800_i2c_send_bytes(dev, addr,
	277	msgs[i].buf,
	278	msgs[i].len);
	279	else
3acf2809	280	rc = em28xx_i2c_send_bytes(dev, addr,
596d92d5 MCC	281	msgs[i].buf,
	282	msgs[i].len,
	283	i == num - 1);
a6c2ba28	284	}
e8e41da4 MR	285	if (rc < 0)
e8e41da4 MR	286	goto err;
6ea54d93	287	if (i2c_debug >= 2)
a6c2ba28 AM	288	printk("\n");
	289	}
	290
	291	return num;
6ea54d93 DSL	292	err:
6ea54d93 DSL	293	dprintk2(2, " ERROR: %i\n", rc);
a6c2ba28 AM	294	return rc;
	295	}
	296
03910cc3 MCC	297	/* based on linux/sunrpc/svcauth.h and linux/hash.h
	298	* The original hash function returns a different value, if arch is x86_64
	299	* or i386.
	300	*/
	301	static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
	302	{
	303	unsigned long hash = 0;
	304	unsigned long l = 0;
	305	int len = 0;
	306	unsigned char c;
	307	do {
	308	if (len == length) {
	309	c = (char)len;
	310	len = -1;
	311	} else
	312	c = *buf++;
	313	l = (l << 8) \| c;
	314	len++;
	315	if ((len & (32 / 8 - 1)) == 0)
	316	hash = ((hash^l) * 0x9e370001UL);
	317	} while (len);
	318
	319	return (hash >> (32 - bits)) & 0xffffffffUL;
	320	}
	321
3acf2809	322	static int em28xx_i2c_eeprom(struct em28xx dev, unsigned char eedata, int len)
a6c2ba28 AM	323	{
a6c2ba28 AM	324	unsigned char buf, *p = eedata;
3acf2809	325	struct em28xx_eeprom em_eeprom = (void )eedata;
a6c2ba28 AM	326	int i, err, size = len, block;
a6c2ba28 AM	327
fec528b7 MCC	328	if (dev->chip_id == CHIP_ID_EM2874 \|\|
	329	dev->chip_id == CHIP_ID_EM28174 \|\|
	330	dev->chip_id == CHIP_ID_EM2884) {
a527c9f8 DH	331	/* Empia switched to a 16-bit addressable eeprom in newer
	332	devices. While we could certainly write a routine to read
	333	the eeprom, there is nothing of use in there that cannot be
	334	accessed through registers, and there is the risk that we
	335	could corrupt the eeprom (since a 16-bit read call is
	336	interpreted as a write call by 8-bit eeproms).
	337	*/
	338	return 0;
	339	}
	340
a6c2ba28	341	dev->i2c_client.addr = 0xa0 >> 1;
596d92d5 MCC	342
	343	/* Check if board has eeprom */
	344	err = i2c_master_recv(&dev->i2c_client, &buf, 0);
f2a01a00	345	if (err < 0) {
c41109fc MCC	346	em28xx_errdev("board has no eeprom\n");
	347	memset(eedata, 0, len);
	348	return -ENODEV;
f2a01a00	349	}
596d92d5	350
a6c2ba28	351	buf = 0;
6ea54d93 DSL	352
	353	err = i2c_master_send(&dev->i2c_client, &buf, 1);
	354	if (err != 1) {
a6c2ba28 AM	355	printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
a6c2ba28 AM	356	dev->name, err);
f2a01a00	357	return err;
a6c2ba28 AM	358	}
	359	while (size > 0) {
	360	if (size > 16)
	361	block = 16;
	362	else
	363	block = size;
	364
	365	if (block !=
	366	(err = i2c_master_recv(&dev->i2c_client, p, block))) {
	367	printk(KERN_WARNING
	368	"%s: i2c eeprom read error (err=%d)\n",
	369	dev->name, err);
f2a01a00	370	return err;
a6c2ba28 AM	371	}
	372	size -= block;
	373	p += block;
	374	}
	375	for (i = 0; i < len; i++) {
	376	if (0 == (i % 16))
	377	printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
	378	printk(" %02x", eedata[i]);
	379	if (15 == (i % 16))
	380	printk("\n");
	381	}
	382
03910cc3 MCC	383	if (em_eeprom->id == 0x9567eb1a)
	384	dev->hash = em28xx_hash_mem(eedata, len, 32);
	385
1bee0184 MCC	386	printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
	387	dev->name, em_eeprom->id, dev->hash);
	388
	389	printk(KERN_INFO "%s: EEPROM info:\n", dev->name);
a6c2ba28 AM	390
	391	switch (em_eeprom->chip_conf >> 4 & 0x3) {
	392	case 0:
1bee0184	393	printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
a6c2ba28 AM	394	break;
a6c2ba28 AM	395	case 1:
1bee0184 MCC	396	printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
1bee0184 MCC	397	dev->name);
a6c2ba28 AM	398	break;
a6c2ba28 AM	399	case 2:
a1a6ee74 NS	400	printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n",
a1a6ee74 NS	401	dev->name);
a6c2ba28 AM	402	break;
a6c2ba28 AM	403	case 3:
a1a6ee74 NS	404	printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n",
a1a6ee74 NS	405	dev->name);
a6c2ba28 AM	406	break;
	407	}
	408
	409	if (em_eeprom->chip_conf & 1 << 3)
1bee0184	410	printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);
a6c2ba28 AM	411
a6c2ba28 AM	412	if (em_eeprom->chip_conf & 1 << 2)
1bee0184	413	printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);
a6c2ba28 AM	414
	415	switch (em_eeprom->chip_conf & 0x3) {
	416	case 0:
1bee0184	417	printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
a6c2ba28 AM	418	break;
a6c2ba28 AM	419	case 1:
1bee0184	420	printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
a6c2ba28 AM	421	break;
a6c2ba28 AM	422	case 2:
1bee0184	423	printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
a6c2ba28 AM	424	break;
a6c2ba28 AM	425	case 3:
1bee0184	426	printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
a6c2ba28 AM	427	break;
a6c2ba28 AM	428	}
1bee0184 MCC	429	printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
1bee0184 MCC	430	dev->name,
6ea54d93 DSL	431	em_eeprom->string_idx_table,
	432	em_eeprom->string1,
	433	em_eeprom->string2,
	434	em_eeprom->string3);
a6c2ba28 AM	435
	436	return 0;
	437	}
	438
	439	/* ----------------------------------------------------------- */
	440
a6c2ba28 AM	441	/*
	442	* functionality()
	443	*/
	444	static u32 functionality(struct i2c_adapter *adap)
	445	{
	446	return I2C_FUNC_SMBUS_EMUL;
	447	}
	448
3acf2809 MCC	449	static struct i2c_algorithm em28xx_algo = {
3acf2809 MCC	450	.master_xfer = em28xx_i2c_xfer,
a6c2ba28 AM	451	.functionality = functionality,
	452	};
	453
3acf2809	454	static struct i2c_adapter em28xx_adap_template = {
a6c2ba28	455	.owner = THIS_MODULE,
3acf2809	456	.name = "em28xx",
3acf2809	457	.algo = &em28xx_algo,
a6c2ba28 AM	458	};
a6c2ba28 AM	459
3acf2809 MCC	460	static struct i2c_client em28xx_client_template = {
3acf2809 MCC	461	.name = "em28xx internal",
a6c2ba28 AM	462	};
	463
	464	/* ----------------------------------------------------------- */
	465
	466	/*
	467	* i2c_devs
	468	* incomplete list of known devices
	469	*/
	470	static char *i2c_devs[128] = {
	471	[0x4a >> 1] = "saa7113h",
729841ed	472	[0x52 >> 1] = "drxk",
a6c2ba28	473	[0x60 >> 1] = "remote IR sensor",
da45a2a5	474	[0x8e >> 1] = "remote IR sensor",
a6c2ba28 AM	475	[0x86 >> 1] = "tda9887",
	476	[0x80 >> 1] = "msp34xx",
	477	[0x88 >> 1] = "msp34xx",
	478	[0xa0 >> 1] = "eeprom",
2bd1d9eb	479	[0xb0 >> 1] = "tda9874",
a6c2ba28	480	[0xb8 >> 1] = "tvp5150a",
791a08fc	481	[0xba >> 1] = "webcam sensor or tvp5150a",
a6c2ba28 AM	482	[0xc0 >> 1] = "tuner (analog)",
	483	[0xc2 >> 1] = "tuner (analog)",
	484	[0xc4 >> 1] = "tuner (analog)",
	485	[0xc6 >> 1] = "tuner (analog)",
	486	};
	487
	488	/*
	489	* do_i2c_scan()
	490	* check i2c address range for devices
	491	*/
fad7b958	492	void em28xx_do_i2c_scan(struct em28xx *dev)
a6c2ba28	493	{
fad7b958	494	u8 i2c_devicelist[128];
a6c2ba28 AM	495	unsigned char buf;
	496	int i, rc;
	497
fad7b958 SS	498	memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
fad7b958 SS	499
53c4e955	500	for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
fad7b958 SS	501	dev->i2c_client.addr = i;
fad7b958 SS	502	rc = i2c_master_recv(&dev->i2c_client, &buf, 0);
a6c2ba28 AM	503	if (rc < 0)
a6c2ba28 AM	504	continue;
fad7b958 SS	505	i2c_devicelist[i] = i;
	506	printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n",
	507	dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
a6c2ba28	508	}
fad7b958 SS	509
	510	dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
	511	ARRAY_SIZE(i2c_devicelist), 32);
a6c2ba28 AM	512	}
a6c2ba28 AM	513
a6c2ba28	514	/*
3acf2809	515	* em28xx_i2c_register()
a6c2ba28 AM	516	* register i2c bus
a6c2ba28 AM	517	*/
3acf2809	518	int em28xx_i2c_register(struct em28xx *dev)
a6c2ba28	519	{
f2a01a00 DSL	520	int retval;
f2a01a00 DSL	521
3acf2809 MCC	522	BUG_ON(!dev->em28xx_write_regs \|\| !dev->em28xx_read_reg);
	523	BUG_ON(!dev->em28xx_write_regs_req \|\| !dev->em28xx_read_reg_req);
	524	dev->i2c_adap = em28xx_adap_template;
a6c2ba28 AM	525	dev->i2c_adap.dev.parent = &dev->udev->dev;
	526	strcpy(dev->i2c_adap.name, dev->name);
	527	dev->i2c_adap.algo_data = dev;
f2cf250a	528	i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
f2a01a00 DSL	529
	530	retval = i2c_add_adapter(&dev->i2c_adap);
	531	if (retval < 0) {
	532	em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
	533	__func__, retval);
	534	return retval;
	535	}
a6c2ba28	536
3acf2809	537	dev->i2c_client = em28xx_client_template;
a6c2ba28 AM	538	dev->i2c_client.adapter = &dev->i2c_adap;
a6c2ba28 AM	539
f2a01a00	540	retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
c41109fc	541	if ((retval < 0) && (retval != -ENODEV)) {
f2a01a00 DSL	542	em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
f2a01a00 DSL	543	__func__, retval);
c41109fc	544
f2a01a00 DSL	545	return retval;
f2a01a00 DSL	546	}
a6c2ba28 AM	547
a6c2ba28 AM	548	if (i2c_scan)
fad7b958	549	em28xx_do_i2c_scan(dev);
c41109fc	550
a6c2ba28 AM	551	return 0;
	552	}
	553
	554	/*
3acf2809	555	* em28xx_i2c_unregister()
a6c2ba28 AM	556	* unregister i2c_bus
a6c2ba28 AM	557	*/
3acf2809	558	int em28xx_i2c_unregister(struct em28xx *dev)
a6c2ba28 AM	559	{
	560	i2c_del_adapter(&dev->i2c_adap);
	561	return 0;
	562	}