1 files changed, 577 insertions, 0 deletions

diff --git a/drivers/media/video/cx231xx/cx231xx-i2c.c b/drivers/media/video/cx231xx/cx231xx-i2c.c
new file mode 100644
index 00000000000..d75ed6c3c8d
--- /dev/null
+++ b/drivers/media/video/cx231xx/cx231xx-i2c.c
@@ -0,0 +1,577 @@
+/*
+   cx231xx-i2c.c - driver for Conexant Cx23100/101/102 USB video capture devices
+
+   Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
+        Based on em28xx driver
+        Based on Cx23885 driver
+
+   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 <media/v4l2-common.h>
+#include <media/tuner.h>
+
+#include "cx231xx.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 dprintk1(lvl, fmt, args...)			\
+do {							\
+	if (i2c_debug >= lvl) {				\
+	printk(fmt, ##args);				\
+      }							\
+} while (0)
+
+#define dprintk2(lvl, fmt, args...)			\
+do {							\
+	if (i2c_debug >= lvl) {				\
+		printk(KERN_DEBUG "%s at %s: " fmt,	\
+		       dev->name, __func__ , ##args);	\
+      } 						\
+} while (0)
+
+
+/*
+ * cx231xx_i2c_send_bytes()
+ */
+int cx231xx_i2c_send_bytes(struct i2c_adapter *i2c_adap,
+			 const struct i2c_msg *msg)
+{
+	struct cx231xx_i2c *bus = i2c_adap->algo_data;
+	struct cx231xx *dev = bus->dev;
+    struct cx231xx_i2c_xfer_data req_data;
+    int status = 0;
+    u16 size = 0;
+    u8 loop = 0;
+    u8 saddr_len = 1;
+    u8 *buf_ptr = NULL;
+    u16 saddr = 0;
+    u8 need_gpio = 0;
+
+
+    if( (bus->nr ==1) && (msg->addr == 0x61) && (dev->tuner_type == TUNER_XC5000) ) {
+
+        size = msg->len;
+
+        if( size == 2 ) { /* register write sub addr*/
+
+            /* Just writing sub address will cause problem to XC5000
+               So ignore the request */
+            return 0;
+
+        } else if( size == 4 ) { /* register write with sub addr*/
+
+            if(msg->len >= 2 )
+                saddr = msg->buf[0] << 8 | msg->buf[1];
+            else if ( msg->len == 1 )
+                saddr = msg->buf[0];
+
+            switch(saddr) {
+                case 0x0000:    /* start tuner calibration mode */
+                    need_gpio = 1;
+                    dev->xc_fw_load_done = 1; /* FW Loading is done */
+                    break;
+                case 0x000D:    /* Set signal source */
+                case 0x0001:    /* Set TV standard - Video */
+                case 0x0002:    /* Set TV standard - Audio */
+                case 0x0003:    /* Set RF Frequency */
+                    need_gpio = 1;
+                    break;
+                default:
+                    if(dev->xc_fw_load_done)
+                        need_gpio = 1;
+                    break;
+            }
+
+            if(need_gpio ) {
+                dprintk1(1, " GPIO W R I T E : addr 0x%x, len %d, saddr 0x%x\n",
+                    msg->addr, msg->len,  saddr);
+
+                return dev->cx231xx_gpio_i2c_write(dev, msg->addr, msg->buf, msg->len);
+            }
+
+        }
+
+        /* special case for Xc5000 tuner case */
+        saddr_len = 1;
+
+        /* adjust the length to correct length */
+        size -= saddr_len;
+        buf_ptr = (u8*) (msg->buf + 1 );
+
+        do {
+            /* prepare xfer_data struct */
+            req_data.dev_addr = msg->addr;
+            req_data.direction = msg->flags;
+            req_data.saddr_len = saddr_len;
+            req_data.saddr_dat = msg->buf[0];
+            req_data.buf_size =  size > 16 ? 16: size;
+            req_data.p_buffer = (u8*)(buf_ptr + loop * 16);
+
+            bus->i2c_nostop =  (size > 16) ? 1: 0;
+            bus->i2c_reserve = (loop == 0) ? 0: 1;
+
+            /* usb send command */
+            status = dev->cx231xx_send_usb_command(bus, &req_data);
+            loop++;
+
+            if( size >= 16 )
+                size -=  16;
+            else
+                size = 0;
+
+        }while( size > 0 );
+
+        bus->i2c_nostop =  0;
+        bus->i2c_reserve = 0;
+
+    } else { /* regular case */
+
+        /* prepare xfer_data struct */
+        req_data.dev_addr = msg->addr;
+        req_data.direction = msg->flags;
+        req_data.saddr_len = 0;
+        req_data.saddr_dat = 0;
+        req_data.buf_size = msg->len;
+        req_data.p_buffer = msg->buf;
+
+        /* usb send command */
+        status = dev->cx231xx_send_usb_command(bus, &req_data);
+    }
+
+    return status < 0 ? status: 0;
+}
+
+/*
+ * cx231xx_i2c_recv_bytes()
+ * read a byte from the i2c device
+ */
+static int cx231xx_i2c_recv_bytes(struct i2c_adapter *i2c_adap,
+			 const struct i2c_msg *msg)
+{
+    struct cx231xx_i2c *bus = i2c_adap->algo_data;
+	struct cx231xx *dev = bus->dev;
+    struct cx231xx_i2c_xfer_data req_data;
+    int status = 0;
+    u16 saddr = 0;
+    u8 need_gpio = 0;
+
+    if((bus->nr ==1) && (msg->addr == 0x61) && dev->tuner_type == TUNER_XC5000) {
+
+        if(msg->len == 2 )
+            saddr = msg->buf[0] << 8 | msg->buf[1];
+        else if ( msg->len == 1 )
+            saddr = msg->buf[0];
+
+        if( dev->xc_fw_load_done) {
+
+            switch(saddr) {
+                case 0x0009:    /* BUSY check */
+                    dprintk1(1, " GPIO R E A D : Special case BUSY check \n");
+                    /* Try to read BUSY register, just set it to zero */
+                    msg->buf[0] = 0;
+                    if(msg->len == 2 )
+                        msg->buf[1] = 0;
+                    return 0;
+                case 0x0004:    /* read Lock status */
+                    need_gpio = 1;
+                    break;
+
+            }
+
+            if(need_gpio) {
+                /* this is a special case to handle Xceive tuner clock stretch issue
+                   with gpio based I2C interface */
+                dprintk1(1, " GPIO R E A D : addr 0x%x, len %d, saddr 0x%x\n",
+                    msg->addr, msg->len, msg->buf[0] << 8| msg->buf[1]);
+                status = dev->cx231xx_gpio_i2c_write(dev, msg->addr, msg->buf, msg->len);
+                status = dev->cx231xx_gpio_i2c_read(dev, msg->addr, msg->buf, msg->len);
+                return status;
+            }
+        }
+
+         /* prepare xfer_data struct */
+        req_data.dev_addr = msg->addr;
+        req_data.direction = msg->flags;
+        req_data.saddr_len = msg->len;
+        req_data.saddr_dat = msg->buf[0] << 8 | msg->buf[1];
+        req_data.buf_size = msg->len;
+        req_data.p_buffer = msg->buf;
+
+        /* usb send command */
+        status = dev->cx231xx_send_usb_command(bus, &req_data);
+
+    } else {
+
+        /* prepare xfer_data struct */
+        req_data.dev_addr = msg->addr;
+        req_data.direction = msg->flags;
+        req_data.saddr_len = 0;
+        req_data.saddr_dat = 0;
+        req_data.buf_size = msg->len;
+        req_data.p_buffer = msg->buf;
+
+        /* usb send command */
+        status = dev->cx231xx_send_usb_command(bus, &req_data);
+    }
+
+    return status < 0 ? status: 0;
+}
+
+/*
+ * cx231xx_i2c_recv_bytes_with_saddr()
+ * read a byte from the i2c device
+ */
+static int cx231xx_i2c_recv_bytes_with_saddr(struct i2c_adapter *i2c_adap,
+			 const struct i2c_msg *msg1, const struct i2c_msg *msg2)
+{
+    struct cx231xx_i2c *bus = i2c_adap->algo_data;
+	struct cx231xx *dev = bus->dev;
+    struct cx231xx_i2c_xfer_data req_data;
+    int status = 0;
+    u16 saddr = 0;
+    u8 need_gpio = 0;
+
+    if(msg1->len == 2 )
+        saddr = msg1->buf[0] << 8 | msg1->buf[1];
+    else if ( msg1->len == 1 )
+        saddr = msg1->buf[0];
+
+    if ( (bus->nr ==1) && (msg2->addr == 0x61) &&  dev->tuner_type == TUNER_XC5000) {
+
+        if( (msg2->len < 16) ) {
+
+            dprintk1(1, " i2c_read : addr 0x%x, len %d, subaddr 0x%x, leng %d\n",
+                msg2->addr, msg2->len, saddr, msg1->len);
+
+            switch(saddr) {
+                case 0x0008:    /* read FW load status */
+                    need_gpio = 1;
+                    break;
+                case 0x0004:    /* read Lock status */
+                    need_gpio = 1;
+                    break;
+            }
+
+            if(need_gpio ) {
+                status = dev->cx231xx_gpio_i2c_write(dev, msg1->addr, msg1->buf, msg1->len);
+                status = dev->cx231xx_gpio_i2c_read(dev, msg2->addr, msg2->buf, msg2->len);
+                return status;
+            }
+        }
+    }
+
+    /* prepare xfer_data struct */
+    req_data.dev_addr = msg2->addr;
+    req_data.direction = msg2->flags;
+    req_data.saddr_len = msg1->len;
+    req_data.saddr_dat = saddr;
+    req_data.buf_size = msg2->len;
+    req_data.p_buffer = msg2->buf;
+
+    /* usb send command */
+    status = dev->cx231xx_send_usb_command(bus, &req_data);
+
+    return status < 0 ? status: 0;
+}
+
+/*
+ * cx231xx_i2c_check_for_device()
+ * check if there is a i2c_device at the supplied address
+ */
+static int cx231xx_i2c_check_for_device(struct i2c_adapter *i2c_adap,
+			 const struct i2c_msg *msg)
+{
+    struct cx231xx_i2c *bus = i2c_adap->algo_data;
+	struct cx231xx *dev = bus->dev;
+    struct cx231xx_i2c_xfer_data req_data;
+    int status = 0;
+
+    /* prepare xfer_data struct */
+    req_data.dev_addr = msg->addr;
+    req_data.direction = msg->flags;
+    req_data.saddr_len = 0;
+    req_data.saddr_dat = 0;
+    req_data.buf_size = 0;
+    req_data.p_buffer = NULL;
+
+    /* usb send command */
+    status = dev->cx231xx_send_usb_command(bus, &req_data);
+
+    return status < 0 ? status: 0;
+}
+
+/*
+ * cx231xx_i2c_xfer()
+ * the main i2c transfer function
+ */
+static int cx231xx_i2c_xfer(struct i2c_adapter *i2c_adap,
+			   struct i2c_msg msgs[], int num)
+{
+	struct cx231xx_i2c *bus = i2c_adap->algo_data;
+	struct cx231xx *dev = bus->dev;
+	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 */
+			rc = cx231xx_i2c_check_for_device(i2c_adap, &msgs[i]);
+			if (rc < 0) {
+				dprintk2(2, " no device\n");
+				return rc;
+			}
+
+		} else if (msgs[i].flags & I2C_M_RD) {
+			/* read bytes */
+			rc = cx231xx_i2c_recv_bytes(i2c_adap, &msgs[i]);
+			if (i2c_debug >= 2) {
+				for (byte = 0; byte < msgs[i].len; byte++)
+					printk(" %02x", msgs[i].buf[byte]);
+			}
+		} else if (i + 1 < num && (msgs[i + 1].flags & I2C_M_RD) &&
+			   msgs[i].addr == msgs[i + 1].addr  && (msgs[i].len <= 2) && (bus->nr < 2)) {
+			/* read bytes */
+			rc = cx231xx_i2c_recv_bytes_with_saddr(i2c_adap, &msgs[i], &msgs[i+1]);
+			if (i2c_debug >= 2) {
+				for (byte = 0; byte < msgs[i].len; byte++)
+					printk(" %02x", msgs[i].buf[byte]);
+			}
+            i++;
+		} else {
+			/* write bytes */
+			if (i2c_debug >= 2) {
+				for (byte = 0; byte < msgs[i].len; byte++)
+					printk(" %02x", msgs[i].buf[byte]);
+			}
+			rc = cx231xx_i2c_send_bytes(i2c_adap,&msgs[i]);
+		}
+		if (rc < 0)
+			goto err;
+		if (i2c_debug >= 2)
+			printk("\n");
+	}
+
+	return num;
+err:
+	dprintk2(2, " ERROR: %i\n", rc);
+	return rc;
+}
+
+/* ----------------------------------------------------------- */
+
+/*
+ * functionality()
+ */
+static u32 functionality(struct i2c_adapter *adap)
+{
+	return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
+}
+
+/*
+ * attach_inform()
+ * gets called when a device attaches to the i2c bus
+ * does some basic configuration
+ */
+static int attach_inform(struct i2c_client *client)
+{
+    struct cx231xx_i2c *bus = i2c_get_adapdata(client->adapter);
+	struct cx231xx *dev = bus->dev;
+
+	switch (client->addr << 1) {
+	case 0x32:
+		dprintk1(1, "attach_inform: Geminit III detected.\n");
+		break;
+	case 0x02:
+		dprintk1(1, "attach_inform: Acquarius detected.\n");
+		break;
+	case 0xa0:
+		dprintk1(1, "attach_inform: eeprom detected.\n");
+		break;
+	case 0x60:
+        dprintk1(1, "attach_inform: Colibri detected.\n");
+        break;
+	case 0x8e:
+	{
+		struct IR_i2c *ir = i2c_get_clientdata(client);
+		dprintk1(1, "attach_inform: IR detected (%s).\n",
+			ir->phys);
+		cx231xx_set_ir(dev, ir);
+		break;
+	}
+	case 0x80:
+	case 0x88:
+		dprintk1(1, "attach_inform: Hammerhead detected.\n");
+		break;
+
+	default:
+		if (!dev->tuner_addr)
+			dev->tuner_addr = client->addr;
+
+		dprintk1(1, "attach inform: detected I2C address %x\n",
+				client->addr << 1);
+	}
+
+	return 0;
+}
+
+static int detach_inform(struct i2c_client *client)
+{
+	dprintk1(1, "i2c detach [client=%s]\n", client->name);
+	return 0;
+}
+
+
+static struct i2c_algorithm cx231xx_algo = {
+	.master_xfer   = cx231xx_i2c_xfer,
+	.functionality = functionality,
+};
+
+static struct i2c_adapter cx231xx_adap_template = {
+	.owner = THIS_MODULE,
+	.class = I2C_CLASS_TV_ANALOG,
+	.name = "cx231xx",
+	.id = I2C_HW_B_CX231XX,
+	.algo = &cx231xx_algo,
+	.client_register   = attach_inform,
+	.client_unregister = detach_inform,
+};
+
+static struct i2c_client cx231xx_client_template = {
+	.name = "cx231xx internal",
+};
+
+/* ----------------------------------------------------------- */
+
+/*
+ * i2c_devs
+ * incomplete list of known devices
+ */
+static char *i2c_devs[128] = {
+	[0x60 >> 1] = "colibri",
+	[0x88 >> 1] = "hammerhead",
+    [0x8e >> 1] = "CIR",
+	[0x32 >> 1] = "GeminiIII",
+    [0x02 >> 1] = "Aquarius",
+	[0xa0 >> 1] = "eeprom",
+	[0xc0 >> 1] = "tuner/XC3028",
+	[0xc2 >> 1] = "tuner/XC5000",
+};
+
+/*
+ * cx231xx_do_i2c_scan()
+ * check i2c address range for devices
+ */
+void cx231xx_do_i2c_scan(struct cx231xx *dev, struct i2c_client *c)
+{
+	unsigned char buf;
+	int i, rc;
+
+    cx231xx_info(": Checking for I2C devices ..\n");
+	for (i = 0; i < 128; i++) {
+		c->addr = i;
+		rc = i2c_master_recv(c, &buf, 0);
+		if (rc < 0)
+			continue;
+		cx231xx_info("%s: i2c scan: found device @ 0x%x  [%s]\n",
+		       dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
+	}
+    cx231xx_info(": Completed Checking for I2C devices.\n");
+}
+
+/*
+ * cx231xx_i2c_call_clients()
+ * send commands to all attached i2c devices
+ */
+void cx231xx_i2c_call_clients(struct cx231xx_i2c *bus, unsigned int cmd, void *arg)
+{
+	/* struct cx231xx *dev = bus->dev; */
+
+	BUG_ON(NULL == bus->i2c_adap.algo_data);
+	i2c_clients_command(&bus->i2c_adap, cmd, arg);
+}
+
+/*
+ * cx231xx_i2c_register()
+ * register i2c bus
+ */
+int cx231xx_i2c_register(struct cx231xx_i2c *bus)
+{
+    struct cx231xx *dev = bus->dev;
+
+    BUG_ON(!dev->cx231xx_send_usb_command);
+
+    cx231xx_info("%s(bus = %d)\n", __func__, bus->nr);
+
+	memcpy(&bus->i2c_adap, &cx231xx_adap_template,
+	       sizeof(bus->i2c_adap));
+	memcpy(&bus->i2c_algo, &cx231xx_algo,
+	       sizeof(bus->i2c_algo));
+	memcpy(&bus->i2c_client, &cx231xx_client_template,
+	       sizeof(bus->i2c_client));
+
+	bus->i2c_adap.dev.parent = &dev->udev->dev;
+
+	strlcpy(bus->i2c_adap.name, bus->dev->name,
+		sizeof(bus->i2c_adap.name));
+
+	bus->i2c_algo.data = bus;
+	bus->i2c_adap.algo_data = bus;
+	i2c_set_adapdata(&bus->i2c_adap, bus);
+	i2c_add_adapter(&bus->i2c_adap);
+
+	bus->i2c_client.adapter = &bus->i2c_adap;
+
+	if (0 == bus->i2c_rc) {
+		cx231xx_info("%s: i2c bus %d registered\n", dev->name, bus->nr);
+		if (i2c_scan)
+			cx231xx_do_i2c_scan(dev, &bus->i2c_client);
+	} else
+		cx231xx_warn("%s: i2c bus %d register FAILED\n",
+			dev->name, bus->nr);
+
+	return bus->i2c_rc;
+}
+
+/*
+ * cx231xx_i2c_unregister()
+ * unregister i2c_bus
+ */
+int cx231xx_i2c_unregister(struct cx231xx_i2c *bus)
+{
+	i2c_del_adapter(&bus->i2c_adap);
+	return 0;
+}