[PATCH] tm6000 fix i2c

public inbox for linux-media@vger.kernel.org
 help / color / mirror / Atom feed

* [PATCH] tm6000 fix i2c
@ 2010-04-23  0:48 Dmitri Belimov
  2010-04-23 12:57 ` Bee Hock Goh
  2010-04-23 15:15 ` Stefan Ringel
  0 siblings, 2 replies; 14+ messages in thread
From: Dmitri Belimov @ 2010-04-23  0:48 UTC (permalink / raw)
  To: linux-media, Mauro Carvalho Chehab

[-- Attachment #1: Type: text/plain, Size: 5286 bytes --]

Hi

Rework I2C for read word from connected devices, now it works well.
Add new functions for read/write blocks.

diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
--- a/linux/drivers/staging/tm6000/tm6000-i2c.c	Mon Apr 05 22:56:43 2010 -0400
+++ b/linux/drivers/staging/tm6000/tm6000-i2c.c	Fri Apr 23 04:23:03 2010 +1000
@@ -24,6 +24,7 @@
 #include <linux/kernel.h>
 #include <linux/usb.h>
 #include <linux/i2c.h>
+#include <linux/delay.h>
 
 #include "compat.h"
 #include "tm6000.h"
@@ -45,11 +46,39 @@
 			printk(KERN_DEBUG "%s at %s: " fmt, \
 			dev->name, __FUNCTION__ , ##args); } while (0)
 
+static void tm6000_i2c_reset(struct tm6000_core *dev)
+{
+	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 0);
+	msleep(15);
+	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 1);
+	msleep(15);
+}
+
 static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
 				__u8 reg, char *buf, int len)
 {
-	return 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);
+	int rc;
+	unsigned int tsleep;
+
+	if (!buf || len < 1 || len > 64)
+		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 */
@@ -59,22 +88,30 @@
 	int rc;
 	u8 b[2];
 
-	if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
+	if (!buf || len < 1 || len > 64)
+		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);
+		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);
+		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;
 }
 
@@ -85,8 +122,106 @@
 static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
 				  __u16 reg, char *buf, int len)
 {
-	return 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);
+	int rc;
+	unsigned char ureg;
+
+	if (!buf || len != 2)
+		return -1;
+
+	/* capture mutex */
+	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);
+
+	if (rc < 0) {
+		/* release mutex */
+		return rc;
+	}
+
+	/* release mutex */
+	return rc;
+}
+
+static int tm6000_i2c_read_sequence(struct tm6000_core *dev, unsigned char addr,
+				  __u16 reg, char *buf, int len)
+{
+	int rc;
+
+	if (!buf || len < 1 || len > 64)
+		return -1;
+
+	/* capture mutex */
+	rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
+		USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
+		reg, 0, buf, len);
+	/* release mutex */
+	return rc;
+}
+
+static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
+				unsigned char addr, __u16 reg, char *buf,
+				int len)
+{
+	int rc;
+	unsigned int tsleep;
+
+	if (!buf || len < 1 || len > 64)
+		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+1, len-1);
+
+	if (rc < 0) {
+		/* release mutex */
+		return rc;
+	}
+
+	/* Calculate delay time, 13800us for 64 bytes */
+	tsleep = ((len * 200) + 1000) / 1000;
+	msleep(tsleep);
+
+	/* release mutex */
+	return rc;
+}
+
+static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned char addr,
+				  __u16 reg, char *buf, int len)
+{
+	int rc;
+	unsigned int tsleep;
+
+	if (!buf || len < 1 || len > 64)
+		return -1;
+
+	/* capture mutex */
+	rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR |
+		USB_RECIP_DEVICE, REQ_30_I2C_WRITE,
+		addr | reg << 8, 0, buf+1, len-1);
+
+	if (rc < 0) {
+		/* release mutex */
+		return rc;
+	}
+
+	/* Calculate delay time, 14800us for 64 bytes */
+	tsleep = ((len * 200) + 1000 + 1000) / 1000;
+	msleep(tsleep);
+
+	/* release mutex */
+	return rc;
 }
 
 static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,

Signed-off-by: Beholder Intl. Ltd. Dmitry Belimov <d.belimov@gmail.com>


With my best regards, Dmitry.

[-- Attachment #2: tm6000_i2c.patch --]
[-- Type: text/x-patch, Size: 5141 bytes --]

diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
--- a/linux/drivers/staging/tm6000/tm6000-i2c.c	Mon Apr 05 22:56:43 2010 -0400
+++ b/linux/drivers/staging/tm6000/tm6000-i2c.c	Fri Apr 23 04:23:03 2010 +1000
@@ -24,6 +24,7 @@
 #include <linux/kernel.h>
 #include <linux/usb.h>
 #include <linux/i2c.h>
+#include <linux/delay.h>
 
 #include "compat.h"
 #include "tm6000.h"
@@ -45,11 +46,39 @@
 			printk(KERN_DEBUG "%s at %s: " fmt, \
 			dev->name, __FUNCTION__ , ##args); } while (0)
 
+static void tm6000_i2c_reset(struct tm6000_core *dev)
+{
+	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 0);
+	msleep(15);
+	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 1);
+	msleep(15);
+}
+
 static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
 				__u8 reg, char *buf, int len)
 {
-	return 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);
+	int rc;
+	unsigned int tsleep;
+
+	if (!buf || len < 1 || len > 64)
+		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 */
@@ -59,22 +88,30 @@
 	int rc;
 	u8 b[2];
 
-	if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
+	if (!buf || len < 1 || len > 64)
+		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);
+		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);
+		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;
 }
 
@@ -85,8 +122,106 @@
 static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
 				  __u16 reg, char *buf, int len)
 {
-	return 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);
+	int rc;
+	unsigned char ureg;
+
+	if (!buf || len != 2)
+		return -1;
+
+	/* capture mutex */
+	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);
+
+	if (rc < 0) {
+		/* release mutex */
+		return rc;
+	}
+
+	/* release mutex */
+	return rc;
+}
+
+static int tm6000_i2c_read_sequence(struct tm6000_core *dev, unsigned char addr,
+				  __u16 reg, char *buf, int len)
+{
+	int rc;
+
+	if (!buf || len < 1 || len > 64)
+		return -1;
+
+	/* capture mutex */
+	rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
+		USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
+		reg, 0, buf, len);
+	/* release mutex */
+	return rc;
+}
+
+static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
+				unsigned char addr, __u16 reg, char *buf,
+				int len)
+{
+	int rc;
+	unsigned int tsleep;
+
+	if (!buf || len < 1 || len > 64)
+		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+1, len-1);
+
+	if (rc < 0) {
+		/* release mutex */
+		return rc;
+	}
+
+	/* Calculate delay time, 13800us for 64 bytes */
+	tsleep = ((len * 200) + 1000) / 1000;
+	msleep(tsleep);
+
+	/* release mutex */
+	return rc;
+}
+
+static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned char addr,
+				  __u16 reg, char *buf, int len)
+{
+	int rc;
+	unsigned int tsleep;
+
+	if (!buf || len < 1 || len > 64)
+		return -1;
+
+	/* capture mutex */
+	rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR |
+		USB_RECIP_DEVICE, REQ_30_I2C_WRITE,
+		addr | reg << 8, 0, buf+1, len-1);
+
+	if (rc < 0) {
+		/* release mutex */
+		return rc;
+	}
+
+	/* Calculate delay time, 14800us for 64 bytes */
+	tsleep = ((len * 200) + 1000 + 1000) / 1000;
+	msleep(tsleep);
+
+	/* release mutex */
+	return rc;
 }
 
 static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,

Signed-off-by: Beholder Intl. Ltd. Dmitry Belimov <d.belimov@gmail.com>

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH] tm6000 fix i2c
  2010-04-23  0:48 [PATCH] tm6000 fix i2c Dmitri Belimov
@ 2010-04-23 12:57 ` Bee Hock Goh
  2010-04-25 23:46   ` Dmitri Belimov
  2010-04-23 15:15 ` Stefan Ringel
  1 sibling, 1 reply; 14+ messages in thread
From: Bee Hock Goh @ 2010-04-23 12:57 UTC (permalink / raw)
  To: Dmitri Belimov; +Cc: linux-media, Mauro Carvalho Chehab

I am still able to watch tv after applying the patch but the return
code is bad and is causing unnecessary reloading of the same
firmwares.

[ 2482.599040] usb 1-1: firmware: requesting tm6000-xc3028.fw
[ 2482.607229] xc2028 2-0061: Loading 77 firmware images from
tm6000-xc3028.fw, type: xc2028 firmware, ver 2.4
[ 2482.788089] xc2028 2-0061: Loading firmware for type=BASE F8MHZ
(3), id 0000000000000000.
[ 2503.620069] (0), id 00000000000000ff:
[ 2503.620078] xc2028 2-0061: Loading firmware for type=(0), id
0000000100000007.
[ 2504.380061] xc2028 2-0061: Loading SCODE for type=MONO SCODE
HAS_IF_5320 (60008000), id 0000000f00000007.
[ 2504.520063] xc2028 2-0061: i2c input error: rc = -32 (should be 2)
[ 2504.536064] xc2028 2-0061: Unable to read tuner registers.
[ 2504.776079] xc2028 2-0061: Loading firmware for type=BASE F8MHZ
(3), id 0000000000000000.
[ 2525.556048] (0), id 00000000000000ff:
[ 2525.556057] xc2028 2-0061: Loading firmware for type=(0), id
0000000100000007.
[ 2526.312058] xc2028 2-0061: Loading SCODE for type=MONO SCODE
HAS_IF_5320 (60008000), id 0000000f00000007.
[ 2526.452061] xc2028 2-0061: i2c input error: rc = -32 (should be 2)
[ 2526.468050] xc2028 2-0061: Unable to read tuner registers.
[ 2527.648076] xc2028 2-0061: Loading firmware for type=BASE F8MHZ
(3), id 0000000000000000.
[ 2548.460067] (0), id 00000000000000ff:
[ 2548.460076] xc2028 2-0061: Loading firmware for type=(0), id
0000000100000007.
[ 2549.216070] xc2028 2-0061: Loading SCODE for type=MONO SCODE
HAS_IF_5320 (60008000), id 0000000f00000007.
[ 2549.356064] xc2028 2-0061: i2c input error: rc = -32 (should be 2)
[ 2549.372065] xc2028 2-0061: Unable to read tuner registers.
[ 2549.612052] xc2028 2-0061: Loading firmware for type=BASE F8MHZ
(3), id 0000000000000000.
[ 2570.609041] (0), id 00000000000000ff:
[ 2570.609049] xc2028 2-0061: Loading firmware for type=(0), id
0000000100000007.
[ 2571.397034] xc2028 2-0061: Loading SCODE for type=MONO SCODE
HAS_IF_5320 (60008000), id 0000000f00000007.
[ 2571.537025] xc2028 2-0061: i2c input error: rc = -32 (should be 2)
[ 2571.553024] xc2028 2-0061: Unable to read tuner registers.
[ 2572.553103] Trident TVMaster TM5600/TM6000/TM6010 USB2 board (Load status: 0)
[ 2572.561090] tm6000: open called (dev=video0)
[ 2573.081022] Original value=96
[ 2573.093037] tm6000: VIDIOC_QUERYCAP
[ 2573.149565] tm6000: open called (dev=video0)



On Fri, Apr 23, 2010 at 8:48 AM, Dmitri Belimov <d.belimov@gmail.com> wrote:
> Hi
>
> Rework I2C for read word from connected devices, now it works well.
> Add new functions for read/write blocks.
>
> diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
> --- a/linux/drivers/staging/tm6000/tm6000-i2c.c Mon Apr 05 22:56:43 2010 -0400
> +++ b/linux/drivers/staging/tm6000/tm6000-i2c.c Fri Apr 23 04:23:03 2010 +1000
> @@ -24,6 +24,7 @@
>  #include <linux/kernel.h>
>  #include <linux/usb.h>
>  #include <linux/i2c.h>
> +#include <linux/delay.h>
>
>  #include "compat.h"
>  #include "tm6000.h"
> @@ -45,11 +46,39 @@
>                        printk(KERN_DEBUG "%s at %s: " fmt, \
>                        dev->name, __FUNCTION__ , ##args); } while (0)
>
> +static void tm6000_i2c_reset(struct tm6000_core *dev)
> +{
> +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 0);
> +       msleep(15);
> +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 1);
> +       msleep(15);
> +}
> +
>  static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
>                                __u8 reg, char *buf, int len)
>  {
> -       return 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);
> +       int rc;
> +       unsigned int tsleep;
> +
> +       if (!buf || len < 1 || len > 64)
> +               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 */
> @@ -59,22 +88,30 @@
>        int rc;
>        u8 b[2];
>
> -       if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
> +       if (!buf || len < 1 || len > 64)
> +               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);
> +               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);
> +               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;
>  }
>
> @@ -85,8 +122,106 @@
>  static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
>                                  __u16 reg, char *buf, int len)
>  {
> -       return 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);
> +       int rc;
> +       unsigned char ureg;
> +
> +       if (!buf || len != 2)
> +               return -1;
> +
> +       /* capture mutex */
> +       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);
> +
> +       if (rc < 0) {
> +               /* release mutex */
> +               return rc;
> +       }
> +
> +       /* release mutex */
> +       return rc;
> +}
> +
> +static int tm6000_i2c_read_sequence(struct tm6000_core *dev, unsigned char addr,
> +                                 __u16 reg, char *buf, int len)
> +{
> +       int rc;
> +
> +       if (!buf || len < 1 || len > 64)
> +               return -1;
> +
> +       /* capture mutex */
> +       rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
> +               USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
> +               reg, 0, buf, len);
> +       /* release mutex */
> +       return rc;
> +}
> +
> +static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
> +                               unsigned char addr, __u16 reg, char *buf,
> +                               int len)
> +{
> +       int rc;
> +       unsigned int tsleep;
> +
> +       if (!buf || len < 1 || len > 64)
> +               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+1, len-1);
> +
> +       if (rc < 0) {
> +               /* release mutex */
> +               return rc;
> +       }
> +
> +       /* Calculate delay time, 13800us for 64 bytes */
> +       tsleep = ((len * 200) + 1000) / 1000;
> +       msleep(tsleep);
> +
> +       /* release mutex */
> +       return rc;
> +}
> +
> +static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned char addr,
> +                                 __u16 reg, char *buf, int len)
> +{
> +       int rc;
> +       unsigned int tsleep;
> +
> +       if (!buf || len < 1 || len > 64)
> +               return -1;
> +
> +       /* capture mutex */
> +       rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR |
> +               USB_RECIP_DEVICE, REQ_30_I2C_WRITE,
> +               addr | reg << 8, 0, buf+1, len-1);
> +
> +       if (rc < 0) {
> +               /* release mutex */
> +               return rc;
> +       }
> +
> +       /* Calculate delay time, 14800us for 64 bytes */
> +       tsleep = ((len * 200) + 1000 + 1000) / 1000;
> +       msleep(tsleep);
> +
> +       /* release mutex */
> +       return rc;
>  }
>
>  static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
>
> Signed-off-by: Beholder Intl. Ltd. Dmitry Belimov <d.belimov@gmail.com>
>
>
> With my best regards, Dmitry.

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH] tm6000 fix i2c
  2010-04-23 12:57 ` Bee Hock Goh
@ 2010-04-25 23:46   ` Dmitri Belimov
  0 siblings, 0 replies; 14+ messages in thread
From: Dmitri Belimov @ 2010-04-25 23:46 UTC (permalink / raw)
  To: Bee Hock Goh; +Cc: linux-media, Mauro Carvalho Chehab

Hi

It's my error. This code good only for tm6010. Now I rework my patch.

With my best regards, Dmitry.

> I am still able to watch tv after applying the patch but the return
> code is bad and is causing unnecessary reloading of the same
> firmwares.
> 
> [ 2482.599040] usb 1-1: firmware: requesting tm6000-xc3028.fw
> [ 2482.607229] xc2028 2-0061: Loading 77 firmware images from
> tm6000-xc3028.fw, type: xc2028 firmware, ver 2.4
> [ 2482.788089] xc2028 2-0061: Loading firmware for type=BASE F8MHZ
> (3), id 0000000000000000.
> [ 2503.620069] (0), id 00000000000000ff:
> [ 2503.620078] xc2028 2-0061: Loading firmware for type=(0), id
> 0000000100000007.
> [ 2504.380061] xc2028 2-0061: Loading SCODE for type=MONO SCODE
> HAS_IF_5320 (60008000), id 0000000f00000007.
> [ 2504.520063] xc2028 2-0061: i2c input error: rc = -32 (should be 2)
> [ 2504.536064] xc2028 2-0061: Unable to read tuner registers.
> [ 2504.776079] xc2028 2-0061: Loading firmware for type=BASE F8MHZ
> (3), id 0000000000000000.
> [ 2525.556048] (0), id 00000000000000ff:
> [ 2525.556057] xc2028 2-0061: Loading firmware for type=(0), id
> 0000000100000007.
> [ 2526.312058] xc2028 2-0061: Loading SCODE for type=MONO SCODE
> HAS_IF_5320 (60008000), id 0000000f00000007.
> [ 2526.452061] xc2028 2-0061: i2c input error: rc = -32 (should be 2)
> [ 2526.468050] xc2028 2-0061: Unable to read tuner registers.
> [ 2527.648076] xc2028 2-0061: Loading firmware for type=BASE F8MHZ
> (3), id 0000000000000000.
> [ 2548.460067] (0), id 00000000000000ff:
> [ 2548.460076] xc2028 2-0061: Loading firmware for type=(0), id
> 0000000100000007.
> [ 2549.216070] xc2028 2-0061: Loading SCODE for type=MONO SCODE
> HAS_IF_5320 (60008000), id 0000000f00000007.
> [ 2549.356064] xc2028 2-0061: i2c input error: rc = -32 (should be 2)
> [ 2549.372065] xc2028 2-0061: Unable to read tuner registers.
> [ 2549.612052] xc2028 2-0061: Loading firmware for type=BASE F8MHZ
> (3), id 0000000000000000.
> [ 2570.609041] (0), id 00000000000000ff:
> [ 2570.609049] xc2028 2-0061: Loading firmware for type=(0), id
> 0000000100000007.
> [ 2571.397034] xc2028 2-0061: Loading SCODE for type=MONO SCODE
> HAS_IF_5320 (60008000), id 0000000f00000007.
> [ 2571.537025] xc2028 2-0061: i2c input error: rc = -32 (should be 2)
> [ 2571.553024] xc2028 2-0061: Unable to read tuner registers.
> [ 2572.553103] Trident TVMaster TM5600/TM6000/TM6010 USB2 board (Load
> status: 0) [ 2572.561090] tm6000: open called (dev=video0)
> [ 2573.081022] Original value=96
> [ 2573.093037] tm6000: VIDIOC_QUERYCAP
> [ 2573.149565] tm6000: open called (dev=video0)
> 
> 
> 
> On Fri, Apr 23, 2010 at 8:48 AM, Dmitri Belimov <d.belimov@gmail.com>
> wrote:
> > Hi
> >
> > Rework I2C for read word from connected devices, now it works well.
> > Add new functions for read/write blocks.
> >
> > diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
> > --- a/linux/drivers/staging/tm6000/tm6000-i2c.c Mon Apr 05 22:56:43
> > 2010 -0400 +++ b/linux/drivers/staging/tm6000/tm6000-i2c.c Fri Apr
> > 23 04:23:03 2010 +1000 @@ -24,6 +24,7 @@
> >  #include <linux/kernel.h>
> >  #include <linux/usb.h>
> >  #include <linux/i2c.h>
> > +#include <linux/delay.h>
> >
> >  #include "compat.h"
> >  #include "tm6000.h"
> > @@ -45,11 +46,39 @@
> >                        printk(KERN_DEBUG "%s at %s: " fmt, \
> >                        dev->name, __FUNCTION__ , ##args); } while
> > (0)
> >
> > +static void tm6000_i2c_reset(struct tm6000_core *dev)
> > +{
> > +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
> > TM6000_GPIO_CLK, 0);
> > +       msleep(15);
> > +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
> > TM6000_GPIO_CLK, 1);
> > +       msleep(15);
> > +}
> > +
> >  static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned
> > char addr, __u8 reg, char *buf, int len)
> >  {
> > -       return 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);
> > +       int rc;
> > +       unsigned int tsleep;
> > +
> > +       if (!buf || len < 1 || len > 64)
> > +               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 */
> > @@ -59,22 +88,30 @@
> >        int rc;
> >        u8 b[2];
> >
> > -       if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 ==
> > addr) && (reg % 2 == 0)) {
> > +       if (!buf || len < 1 || len > 64)
> > +               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);
> > +               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);
> > +               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;
> >  }
> >
> > @@ -85,8 +122,106 @@
> >  static int tm6000_i2c_recv_regs16(struct tm6000_core *dev,
> > unsigned char addr, __u16 reg, char *buf, int len)
> >  {
> > -       return 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);
> > +       int rc;
> > +       unsigned char ureg;
> > +
> > +       if (!buf || len != 2)
> > +               return -1;
> > +
> > +       /* capture mutex */
> > +       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);
> > +
> > +       if (rc < 0) {
> > +               /* release mutex */
> > +               return rc;
> > +       }
> > +
> > +       /* release mutex */
> > +       return rc;
> > +}
> > +
> > +static int tm6000_i2c_read_sequence(struct tm6000_core *dev,
> > unsigned char addr,
> > +                                 __u16 reg, char *buf, int len)
> > +{
> > +       int rc;
> > +
> > +       if (!buf || len < 1 || len > 64)
> > +               return -1;
> > +
> > +       /* capture mutex */
> > +       rc = tm6000_read_write_usb(dev, USB_DIR_IN |
> > USB_TYPE_VENDOR |
> > +               USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
> > +               reg, 0, buf, len);
> > +       /* release mutex */
> > +       return rc;
> > +}
> > +
> > +static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
> > +                               unsigned char addr, __u16 reg, char
> > *buf,
> > +                               int len)
> > +{
> > +       int rc;
> > +       unsigned int tsleep;
> > +
> > +       if (!buf || len < 1 || len > 64)
> > +               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+1, len-1);
> > +
> > +       if (rc < 0) {
> > +               /* release mutex */
> > +               return rc;
> > +       }
> > +
> > +       /* Calculate delay time, 13800us for 64 bytes */
> > +       tsleep = ((len * 200) + 1000) / 1000;
> > +       msleep(tsleep);
> > +
> > +       /* release mutex */
> > +       return rc;
> > +}
> > +
> > +static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned
> > char addr,
> > +                                 __u16 reg, char *buf, int len)
> > +{
> > +       int rc;
> > +       unsigned int tsleep;
> > +
> > +       if (!buf || len < 1 || len > 64)
> > +               return -1;
> > +
> > +       /* capture mutex */
> > +       rc = tm6000_read_write_usb(dev, USB_DIR_OUT |
> > USB_TYPE_VENDOR |
> > +               USB_RECIP_DEVICE, REQ_30_I2C_WRITE,
> > +               addr | reg << 8, 0, buf+1, len-1);
> > +
> > +       if (rc < 0) {
> > +               /* release mutex */
> > +               return rc;
> > +       }
> > +
> > +       /* Calculate delay time, 14800us for 64 bytes */
> > +       tsleep = ((len * 200) + 1000 + 1000) / 1000;
> > +       msleep(tsleep);
> > +
> > +       /* release mutex */
> > +       return rc;
> >  }
> >
> >  static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
> >
> > Signed-off-by: Beholder Intl. Ltd. Dmitry Belimov
> > <d.belimov@gmail.com>
> >
> >
> > With my best regards, Dmitry.

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH] tm6000 fix i2c
  2010-04-23  0:48 [PATCH] tm6000 fix i2c Dmitri Belimov
  2010-04-23 12:57 ` Bee Hock Goh
@ 2010-04-23 15:15 ` Stefan Ringel
  2010-04-25 23:47   ` Dmitri Belimov
  2010-04-26  0:25   ` Dmitri Belimov
  1 sibling, 2 replies; 14+ messages in thread
From: Stefan Ringel @ 2010-04-23 15:15 UTC (permalink / raw)
  To: Dmitri Belimov; +Cc: linux-media, Mauro Carvalho Chehab

Am 23.04.2010 02:48, schrieb Dmitri Belimov:
> Hi
>
> Rework I2C for read word from connected devices, now it works well.
> Add new functions for read/write blocks.
>
> diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
> --- a/linux/drivers/staging/tm6000/tm6000-i2c.c	Mon Apr 05 22:56:43 2010 -0400
> +++ b/linux/drivers/staging/tm6000/tm6000-i2c.c	Fri Apr 23 04:23:03 2010 +1000
> @@ -24,6 +24,7 @@
>  #include <linux/kernel.h>
>  #include <linux/usb.h>
>  #include <linux/i2c.h>
> +#include <linux/delay.h>
>  
>  #include "compat.h"
>  #include "tm6000.h"
> @@ -45,11 +46,39 @@
>  			printk(KERN_DEBUG "%s at %s: " fmt, \
>  			dev->name, __FUNCTION__ , ##args); } while (0)
>  
> +static void tm6000_i2c_reset(struct tm6000_core *dev)
> +{
> +	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 0);
> +	msleep(15);
> +	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 1);
> +	msleep(15);
> +}
> +
>  static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
>  				__u8 reg, char *buf, int len)
>  {
> -	return 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);
> +	int rc;
> +	unsigned int tsleep;
> +
> +	if (!buf || len < 1 || len > 64)
> +		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 */
> @@ -59,22 +88,30 @@
>  	int rc;
>  	u8 b[2];
>  
> -	if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
> +	if (!buf || len < 1 || len > 64)
> +		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);
> +		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);
> +		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;
>  }
>  
> @@ -85,8 +122,106 @@
>  static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
>  				  __u16 reg, char *buf, int len)
>  {
> -	return 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);
> +	int rc;
> +	unsigned char ureg;
> +
> +	if (!buf || len != 2)
> +		return -1;
> +
> +	/* capture mutex */
> +	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);
> +
>   
not all can this request (chip revision 0xf3 and 0xf4 can it)
> +	if (rc < 0) {
> +		/* release mutex */
> +		return rc;
> +	}
> +
> +	/* release mutex */
> +	return rc;
> +}
> +
> +static int tm6000_i2c_read_sequence(struct tm6000_core *dev, unsigned char addr,
> +				  __u16 reg, char *buf, int len)
> +{
> +	int rc;
> +
> +	if (!buf || len < 1 || len > 64)
> +		return -1;
> +
> +	/* capture mutex */
> +	rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
> +		USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
> +		reg, 0, buf, len);
>   
ditto
> +	/* release mutex */
> +	return rc;
> +}
> +
> +static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
> +				unsigned char addr, __u16 reg, char *buf,
> +				int len)
> +{
> +	int rc;
> +	unsigned int tsleep;
> +
> +	if (!buf || len < 1 || len > 64)
> +		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+1, len-1);
> +
> +	if (rc < 0) {
> +		/* release mutex */
> +		return rc;
> +	}
> +
> +	/* Calculate delay time, 13800us for 64 bytes */
> +	tsleep = ((len * 200) + 1000) / 1000;
> +	msleep(tsleep);
> +
> +	/* release mutex */
> +	return rc;
> +}
> +
> +static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned char addr,
> +				  __u16 reg, char *buf, int len)
> +{
> +	int rc;
> +	unsigned int tsleep;
> +
> +	if (!buf || len < 1 || len > 64)
> +		return -1;
> +
> +	/* capture mutex */
> +	rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR |
> +		USB_RECIP_DEVICE, REQ_30_I2C_WRITE,
> +		addr | reg << 8, 0, buf+1, len-1);
> +
> +	if (rc < 0) {
> +		/* release mutex */
> +		return rc;
> +	}
> +
> +	/* Calculate delay time, 14800us for 64 bytes */
> +	tsleep = ((len * 200) + 1000 + 1000) / 1000;
> +	msleep(tsleep);
> +
> +	/* release mutex */
> +	return rc;
>  }
>  
>  static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
>
> Signed-off-by: Beholder Intl. Ltd. Dmitry Belimov <d.belimov@gmail.com>
>
>
> With my best regards, Dmitry.


-- 
Stefan Ringel <stefan.ringel@arcor.de>


^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH] tm6000 fix i2c
  2010-04-23 15:15 ` Stefan Ringel
@ 2010-04-25 23:47   ` Dmitri Belimov
  2010-04-26  0:25   ` Dmitri Belimov
  1 sibling, 0 replies; 14+ messages in thread
From: Dmitri Belimov @ 2010-04-25 23:47 UTC (permalink / raw)
  To: Stefan Ringel; +Cc: linux-media, Mauro Carvalho Chehab

Hi

It's my error. This code good only for tm6010. Now I rework my patch.

With my best regards, Dmitry.

> Am 23.04.2010 02:48, schrieb Dmitri Belimov:
> > Hi
> >
> > Rework I2C for read word from connected devices, now it works well.
> > Add new functions for read/write blocks.
> >
> > diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
> > --- a/linux/drivers/staging/tm6000/tm6000-i2c.c	Mon Apr 05
> > 22:56:43 2010 -0400 +++
> > b/linux/drivers/staging/tm6000/tm6000-i2c.c	Fri Apr 23
> > 04:23:03 2010 +1000 @@ -24,6 +24,7 @@ #include <linux/kernel.h>
> >  #include <linux/usb.h>
> >  #include <linux/i2c.h>
> > +#include <linux/delay.h>
> >  
> >  #include "compat.h"
> >  #include "tm6000.h"
> > @@ -45,11 +46,39 @@
> >  			printk(KERN_DEBUG "%s at %s: " fmt, \
> >  			dev->name, __FUNCTION__ , ##args); } while
> > (0) 
> > +static void tm6000_i2c_reset(struct tm6000_core *dev)
> > +{
> > +	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
> > TM6000_GPIO_CLK, 0);
> > +	msleep(15);
> > +	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
> > TM6000_GPIO_CLK, 1);
> > +	msleep(15);
> > +}
> > +
> >  static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned
> > char addr, __u8 reg, char *buf, int len)
> >  {
> > -	return 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);
> > +	int rc;
> > +	unsigned int tsleep;
> > +
> > +	if (!buf || len < 1 || len > 64)
> > +		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 */
> > @@ -59,22 +88,30 @@
> >  	int rc;
> >  	u8 b[2];
> >  
> > -	if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 ==
> > addr) && (reg % 2 == 0)) {
> > +	if (!buf || len < 1 || len > 64)
> > +		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);
> > +		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);
> > +		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;
> >  }
> >  
> > @@ -85,8 +122,106 @@
> >  static int tm6000_i2c_recv_regs16(struct tm6000_core *dev,
> > unsigned char addr, __u16 reg, char *buf, int len)
> >  {
> > -	return 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);
> > +	int rc;
> > +	unsigned char ureg;
> > +
> > +	if (!buf || len != 2)
> > +		return -1;
> > +
> > +	/* capture mutex */
> > +	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);
> > +
> >   
> not all can this request (chip revision 0xf3 and 0xf4 can it)
> > +	if (rc < 0) {
> > +		/* release mutex */
> > +		return rc;
> > +	}
> > +
> > +	/* release mutex */
> > +	return rc;
> > +}
> > +
> > +static int tm6000_i2c_read_sequence(struct tm6000_core *dev,
> > unsigned char addr,
> > +				  __u16 reg, char *buf, int len)
> > +{
> > +	int rc;
> > +
> > +	if (!buf || len < 1 || len > 64)
> > +		return -1;
> > +
> > +	/* capture mutex */
> > +	rc = tm6000_read_write_usb(dev, USB_DIR_IN |
> > USB_TYPE_VENDOR |
> > +		USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
> > +		reg, 0, buf, len);
> >   
> ditto
> > +	/* release mutex */
> > +	return rc;
> > +}
> > +
> > +static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
> > +				unsigned char addr, __u16 reg,
> > char *buf,
> > +				int len)
> > +{
> > +	int rc;
> > +	unsigned int tsleep;
> > +
> > +	if (!buf || len < 1 || len > 64)
> > +		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+1, len-1);
> > +
> > +	if (rc < 0) {
> > +		/* release mutex */
> > +		return rc;
> > +	}
> > +
> > +	/* Calculate delay time, 13800us for 64 bytes */
> > +	tsleep = ((len * 200) + 1000) / 1000;
> > +	msleep(tsleep);
> > +
> > +	/* release mutex */
> > +	return rc;
> > +}
> > +
> > +static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned
> > char addr,
> > +				  __u16 reg, char *buf, int len)
> > +{
> > +	int rc;
> > +	unsigned int tsleep;
> > +
> > +	if (!buf || len < 1 || len > 64)
> > +		return -1;
> > +
> > +	/* capture mutex */
> > +	rc = tm6000_read_write_usb(dev, USB_DIR_OUT |
> > USB_TYPE_VENDOR |
> > +		USB_RECIP_DEVICE, REQ_30_I2C_WRITE,
> > +		addr | reg << 8, 0, buf+1, len-1);
> > +
> > +	if (rc < 0) {
> > +		/* release mutex */
> > +		return rc;
> > +	}
> > +
> > +	/* Calculate delay time, 14800us for 64 bytes */
> > +	tsleep = ((len * 200) + 1000 + 1000) / 1000;
> > +	msleep(tsleep);
> > +
> > +	/* release mutex */
> > +	return rc;
> >  }
> >  
> >  static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
> >
> > Signed-off-by: Beholder Intl. Ltd. Dmitry Belimov
> > <d.belimov@gmail.com>
> >
> >
> > With my best regards, Dmitry.
> 
> 
> -- 
> Stefan Ringel <stefan.ringel@arcor.de>
> 

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH] tm6000 fix i2c
  2010-04-23 15:15 ` Stefan Ringel
  2010-04-25 23:47   ` Dmitri Belimov
@ 2010-04-26  0:25   ` Dmitri Belimov
  2010-04-26 12:58     ` Bee Hock Goh
  2010-04-26 13:29     ` [PATCH] tm6000 fix i2c Mauro Carvalho Chehab
  1 sibling, 2 replies; 14+ messages in thread
From: Dmitri Belimov @ 2010-04-26  0:25 UTC (permalink / raw)
  To: Stefan Ringel; +Cc: linux-media, Mauro Carvalho Chehab, Bee Hock Goh

[-- Attachment #1: Type: text/plain, Size: 6472 bytes --]

Hi 

Rework last I2C patch.
Set correct limit for I2C packet.
Use different method for the tm5600/tm6000 and tm6010 to read word.

Try this patch.

diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
--- a/linux/drivers/staging/tm6000/tm6000-i2c.c	Mon Apr 05 22:56:43 2010 -0400
+++ b/linux/drivers/staging/tm6000/tm6000-i2c.c	Mon Apr 26 04:15:56 2010 +1000
@@ -24,6 +24,7 @@
 #include <linux/kernel.h>
 #include <linux/usb.h>
 #include <linux/i2c.h>
+#include <linux/delay.h>
 
 #include "compat.h"
 #include "tm6000.h"
@@ -45,11 +46,49 @@
 			printk(KERN_DEBUG "%s at %s: " fmt, \
 			dev->name, __FUNCTION__ , ##args); } while (0)
 
+static void tm6000_i2c_reset(struct tm6000_core *dev)
+{
+	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 0);
+	msleep(15);
+	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 1);
+	msleep(15);
+}
+
 static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
 				__u8 reg, char *buf, int len)
 {
-	return 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);
+	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("Incorrect lenght 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 */
@@ -58,23 +97,41 @@
 {
 	int rc;
 	u8 b[2];
+	unsigned int i2c_packet_limit = 16;
 
-	if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
+	if (dev->dev_type == TM6010)
+		i2c_packet_limit = 64;
+
+	if (!buf)
+		return -1;
+
+	if (len < 1 || len > i2c_packet_limit){
+		printk("Incorrect lenght 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);
+		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);
+		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;
 }
 
@@ -85,8 +142,137 @@
 static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
 				  __u16 reg, char *buf, int len)
 {
-	return 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);
+	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_read_sequence(struct tm6000_core *dev, unsigned char addr,
+				  __u16 reg, char *buf, int len)
+{
+	int rc;
+
+	if (dev->dev_type != TM6010)
+		return -1;
+
+	if (!buf)
+		return -1;
+
+	if (len < 1 || len > 64){
+		printk("Incorrect lenght of i2c packet = %d, limit set to 64\n",
+			len);
+		return -1;
+	}
+
+	/* capture mutex */
+	rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
+		USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
+		reg, 0, buf, len);
+	/* release mutex */
+	return rc;
+}
+
+static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
+				unsigned char addr, __u16 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("Incorrect lenght 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+1, len-1);
+
+	if (rc < 0) {
+		/* release mutex */
+		return rc;
+	}
+
+	/* Calculate delay time, 13800us for 64 bytes */
+	tsleep = ((len * 200) + 1000) / 1000;
+	msleep(tsleep);
+
+	/* release mutex */
+	return rc;
+}
+
+static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned char addr,
+				  __u16 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("Incorrect lenght 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_30_I2C_WRITE,
+		addr | reg << 8, 0, buf+1, len-1);
+
+	if (rc < 0) {
+		/* release mutex */
+		return rc;
+	}
+
+	/* Calculate delay time, 14800us for 64 bytes */
+	tsleep = ((len * 200) + 1000 + 1000) / 1000;
+	msleep(tsleep);
+
+	/* release mutex */
+	return rc;
 }
 
 static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,


With my best regards, Dmitry.

[-- Attachment #2: tm6000_i2c.patch --]
[-- Type: text/x-patch, Size: 6293 bytes --]

diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
--- a/linux/drivers/staging/tm6000/tm6000-i2c.c	Mon Apr 05 22:56:43 2010 -0400
+++ b/linux/drivers/staging/tm6000/tm6000-i2c.c	Mon Apr 26 04:15:56 2010 +1000
@@ -24,6 +24,7 @@
 #include <linux/kernel.h>
 #include <linux/usb.h>
 #include <linux/i2c.h>
+#include <linux/delay.h>
 
 #include "compat.h"
 #include "tm6000.h"
@@ -45,11 +46,49 @@
 			printk(KERN_DEBUG "%s at %s: " fmt, \
 			dev->name, __FUNCTION__ , ##args); } while (0)
 
+static void tm6000_i2c_reset(struct tm6000_core *dev)
+{
+	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 0);
+	msleep(15);
+	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 1);
+	msleep(15);
+}
+
 static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
 				__u8 reg, char *buf, int len)
 {
-	return 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);
+	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("Incorrect lenght 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 */
@@ -58,23 +97,41 @@
 {
 	int rc;
 	u8 b[2];
+	unsigned int i2c_packet_limit = 16;
 
-	if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
+	if (dev->dev_type == TM6010)
+		i2c_packet_limit = 64;
+
+	if (!buf)
+		return -1;
+
+	if (len < 1 || len > i2c_packet_limit){
+		printk("Incorrect lenght 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);
+		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);
+		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;
 }
 
@@ -85,8 +142,137 @@
 static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
 				  __u16 reg, char *buf, int len)
 {
-	return 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);
+	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_read_sequence(struct tm6000_core *dev, unsigned char addr,
+				  __u16 reg, char *buf, int len)
+{
+	int rc;
+
+	if (dev->dev_type != TM6010)
+		return -1;
+
+	if (!buf)
+		return -1;
+
+	if (len < 1 || len > 64){
+		printk("Incorrect lenght of i2c packet = %d, limit set to 64\n",
+			len);
+		return -1;
+	}
+
+	/* capture mutex */
+	rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
+		USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
+		reg, 0, buf, len);
+	/* release mutex */
+	return rc;
+}
+
+static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
+				unsigned char addr, __u16 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("Incorrect lenght 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+1, len-1);
+
+	if (rc < 0) {
+		/* release mutex */
+		return rc;
+	}
+
+	/* Calculate delay time, 13800us for 64 bytes */
+	tsleep = ((len * 200) + 1000) / 1000;
+	msleep(tsleep);
+
+	/* release mutex */
+	return rc;
+}
+
+static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned char addr,
+				  __u16 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("Incorrect lenght 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_30_I2C_WRITE,
+		addr | reg << 8, 0, buf+1, len-1);
+
+	if (rc < 0) {
+		/* release mutex */
+		return rc;
+	}
+
+	/* Calculate delay time, 14800us for 64 bytes */
+	tsleep = ((len * 200) + 1000 + 1000) / 1000;
+	msleep(tsleep);
+
+	/* release mutex */
+	return rc;
 }
 
 static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH] tm6000 fix i2c
  2010-04-26  0:25   ` Dmitri Belimov
@ 2010-04-26 12:58     ` Bee Hock Goh
  2010-04-27  5:15       ` Dmitri Belimov
  2010-04-26 13:29     ` [PATCH] tm6000 fix i2c Mauro Carvalho Chehab
  1 sibling, 1 reply; 14+ messages in thread
From: Bee Hock Goh @ 2010-04-26 12:58 UTC (permalink / raw)
  To: Dmitri Belimov; +Cc: Stefan Ringel, linux-media, Mauro Carvalho Chehab

thanks. This is work fine on my tm5600.

btw, can you use the git tree? There is some codes update from Stefan
there for the tm6000-i2c that is still not sync with hg.

On Mon, Apr 26, 2010 at 8:25 AM, Dmitri Belimov <d.belimov@gmail.com> wrote:
> Hi
>
> Rework last I2C patch.
> Set correct limit for I2C packet.
> Use different method for the tm5600/tm6000 and tm6010 to read word.
>
> Try this patch.
>
> diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
> --- a/linux/drivers/staging/tm6000/tm6000-i2c.c Mon Apr 05 22:56:43 2010 -0400
> +++ b/linux/drivers/staging/tm6000/tm6000-i2c.c Mon Apr 26 04:15:56 2010 +1000
> @@ -24,6 +24,7 @@
>  #include <linux/kernel.h>
>  #include <linux/usb.h>
>  #include <linux/i2c.h>
> +#include <linux/delay.h>
>
>  #include "compat.h"
>  #include "tm6000.h"
> @@ -45,11 +46,49 @@
>                        printk(KERN_DEBUG "%s at %s: " fmt, \
>                        dev->name, __FUNCTION__ , ##args); } while (0)
>
> +static void tm6000_i2c_reset(struct tm6000_core *dev)
> +{
> +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 0);
> +       msleep(15);
> +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 1);
> +       msleep(15);
> +}
> +
>  static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
>                                __u8 reg, char *buf, int len)
>  {
> -       return 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);
> +       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("Incorrect lenght 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 */
> @@ -58,23 +97,41 @@
>  {
>        int rc;
>        u8 b[2];
> +       unsigned int i2c_packet_limit = 16;
>
> -       if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
> +       if (dev->dev_type == TM6010)
> +               i2c_packet_limit = 64;
> +
> +       if (!buf)
> +               return -1;
> +
> +       if (len < 1 || len > i2c_packet_limit){
> +               printk("Incorrect lenght 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);
> +               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);
> +               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;
>  }
>
> @@ -85,8 +142,137 @@
>  static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
>                                  __u16 reg, char *buf, int len)
>  {
> -       return 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);
> +       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_read_sequence(struct tm6000_core *dev, unsigned char addr,
> +                                 __u16 reg, char *buf, int len)
> +{
> +       int rc;
> +
> +       if (dev->dev_type != TM6010)
> +               return -1;
> +
> +       if (!buf)
> +               return -1;
> +
> +       if (len < 1 || len > 64){
> +               printk("Incorrect lenght of i2c packet = %d, limit set to 64\n",
> +                       len);
> +               return -1;
> +       }
> +
> +       /* capture mutex */
> +       rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
> +               USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
> +               reg, 0, buf, len);
> +       /* release mutex */
> +       return rc;
> +}
> +
> +static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
> +                               unsigned char addr, __u16 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("Incorrect lenght 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+1, len-1);
> +
> +       if (rc < 0) {
> +               /* release mutex */
> +               return rc;
> +       }
> +
> +       /* Calculate delay time, 13800us for 64 bytes */
> +       tsleep = ((len * 200) + 1000) / 1000;
> +       msleep(tsleep);
> +
> +       /* release mutex */
> +       return rc;
> +}
> +
> +static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned char addr,
> +                                 __u16 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("Incorrect lenght 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_30_I2C_WRITE,
> +               addr | reg << 8, 0, buf+1, len-1);
> +
> +       if (rc < 0) {
> +               /* release mutex */
> +               return rc;
> +       }
> +
> +       /* Calculate delay time, 14800us for 64 bytes */
> +       tsleep = ((len * 200) + 1000 + 1000) / 1000;
> +       msleep(tsleep);
> +
> +       /* release mutex */
> +       return rc;
>  }
>
>  static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
>
>
> With my best regards, Dmitry.

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH] tm6000 fix i2c
  2010-04-26 12:58     ` Bee Hock Goh
@ 2010-04-27  5:15       ` Dmitri Belimov
  2010-04-27  6:07         ` Bee Hock Goh
  0 siblings, 1 reply; 14+ messages in thread
From: Dmitri Belimov @ 2010-04-27  5:15 UTC (permalink / raw)
  To: Bee Hock Goh; +Cc: Stefan Ringel, linux-media, Mauro Carvalho Chehab

On Mon, 26 Apr 2010 20:58:24 +0800
Bee Hock Goh <beehock@gmail.com> wrote:

> thanks. This is work fine on my tm5600.

Good news.
 
> btw, can you use the git tree? There is some codes update from Stefan
> there for the tm6000-i2c that is still not sync with hg.

no problemm. Give me access and URL.

With my best regards, Dmitry.

> On Mon, Apr 26, 2010 at 8:25 AM, Dmitri Belimov <d.belimov@gmail.com>
> wrote:
> > Hi
> >
> > Rework last I2C patch.
> > Set correct limit for I2C packet.
> > Use different method for the tm5600/tm6000 and tm6010 to read word.
> >
> > Try this patch.
> >
> > diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
> > --- a/linux/drivers/staging/tm6000/tm6000-i2c.c Mon Apr 05 22:56:43
> > 2010 -0400 +++ b/linux/drivers/staging/tm6000/tm6000-i2c.c Mon Apr
> > 26 04:15:56 2010 +1000 @@ -24,6 +24,7 @@
> >  #include <linux/kernel.h>
> >  #include <linux/usb.h>
> >  #include <linux/i2c.h>
> > +#include <linux/delay.h>
> >
> >  #include "compat.h"
> >  #include "tm6000.h"
> > @@ -45,11 +46,49 @@
> >                        printk(KERN_DEBUG "%s at %s: " fmt, \
> >                        dev->name, __FUNCTION__ , ##args); } while
> > (0)
> >
> > +static void tm6000_i2c_reset(struct tm6000_core *dev)
> > +{
> > +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
> > TM6000_GPIO_CLK, 0);
> > +       msleep(15);
> > +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
> > TM6000_GPIO_CLK, 1);
> > +       msleep(15);
> > +}
> > +
> >  static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned
> > char addr, __u8 reg, char *buf, int len)
> >  {
> > -       return 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);
> > +       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("Incorrect lenght 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 */
> > @@ -58,23 +97,41 @@
> >  {
> >        int rc;
> >        u8 b[2];
> > +       unsigned int i2c_packet_limit = 16;
> >
> > -       if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 ==
> > addr) && (reg % 2 == 0)) {
> > +       if (dev->dev_type == TM6010)
> > +               i2c_packet_limit = 64;
> > +
> > +       if (!buf)
> > +               return -1;
> > +
> > +       if (len < 1 || len > i2c_packet_limit){
> > +               printk("Incorrect lenght 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);
> > +               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);
> > +               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;
> >  }
> >
> > @@ -85,8 +142,137 @@
> >  static int tm6000_i2c_recv_regs16(struct tm6000_core *dev,
> > unsigned char addr, __u16 reg, char *buf, int len)
> >  {
> > -       return 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);
> > +       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_read_sequence(struct tm6000_core *dev,
> > unsigned char addr,
> > +                                 __u16 reg, char *buf, int len)
> > +{
> > +       int rc;
> > +
> > +       if (dev->dev_type != TM6010)
> > +               return -1;
> > +
> > +       if (!buf)
> > +               return -1;
> > +
> > +       if (len < 1 || len > 64){
> > +               printk("Incorrect lenght of i2c packet = %d, limit
> > set to 64\n",
> > +                       len);
> > +               return -1;
> > +       }
> > +
> > +       /* capture mutex */
> > +       rc = tm6000_read_write_usb(dev, USB_DIR_IN |
> > USB_TYPE_VENDOR |
> > +               USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
> > +               reg, 0, buf, len);
> > +       /* release mutex */
> > +       return rc;
> > +}
> > +
> > +static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
> > +                               unsigned char addr, __u16 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("Incorrect lenght 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+1, len-1);
> > +
> > +       if (rc < 0) {
> > +               /* release mutex */
> > +               return rc;
> > +       }
> > +
> > +       /* Calculate delay time, 13800us for 64 bytes */
> > +       tsleep = ((len * 200) + 1000) / 1000;
> > +       msleep(tsleep);
> > +
> > +       /* release mutex */
> > +       return rc;
> > +}
> > +
> > +static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned
> > char addr,
> > +                                 __u16 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("Incorrect lenght 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_30_I2C_WRITE,
> > +               addr | reg << 8, 0, buf+1, len-1);
> > +
> > +       if (rc < 0) {
> > +               /* release mutex */
> > +               return rc;
> > +       }
> > +
> > +       /* Calculate delay time, 14800us for 64 bytes */
> > +       tsleep = ((len * 200) + 1000 + 1000) / 1000;
> > +       msleep(tsleep);
> > +
> > +       /* release mutex */
> > +       return rc;
> >  }
> >
> >  static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
> >
> >
> > With my best regards, Dmitry.

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH] tm6000 fix i2c
  2010-04-27  5:15       ` Dmitri Belimov
@ 2010-04-27  6:07         ` Bee Hock Goh
  2010-04-28  1:32           ` Dmitri Belimov
  2010-04-28  5:49           ` tm6000 Dmitri Belimov
  0 siblings, 2 replies; 14+ messages in thread
From: Bee Hock Goh @ 2010-04-27  6:07 UTC (permalink / raw)
  To: Dmitri Belimov; +Cc: Stefan Ringel, linux-media, Mauro Carvalho Chehab

wiki is your best friend. :)

http://www.linuxtv.org/wiki/index.php/Maintaining_Git_trees
http://www.linuxtv.org/wiki/index.php/Using_a_git_driver_development_tree


On Tue, Apr 27, 2010 at 1:15 PM, Dmitri Belimov <d.belimov@gmail.com> wrote:
> On Mon, 26 Apr 2010 20:58:24 +0800
> Bee Hock Goh <beehock@gmail.com> wrote:
>
>> thanks. This is work fine on my tm5600.
>
> Good news.
>
>> btw, can you use the git tree? There is some codes update from Stefan
>> there for the tm6000-i2c that is still not sync with hg.
>
> no problemm. Give me access and URL.
>
> With my best regards, Dmitry.
>
>> On Mon, Apr 26, 2010 at 8:25 AM, Dmitri Belimov <d.belimov@gmail.com>
>> wrote:
>> > Hi
>> >
>> > Rework last I2C patch.
>> > Set correct limit for I2C packet.
>> > Use different method for the tm5600/tm6000 and tm6010 to read word.
>> >
>> > Try this patch.
>> >
>> > diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
>> > --- a/linux/drivers/staging/tm6000/tm6000-i2c.c Mon Apr 05 22:56:43
>> > 2010 -0400 +++ b/linux/drivers/staging/tm6000/tm6000-i2c.c Mon Apr
>> > 26 04:15:56 2010 +1000 @@ -24,6 +24,7 @@
>> >  #include <linux/kernel.h>
>> >  #include <linux/usb.h>
>> >  #include <linux/i2c.h>
>> > +#include <linux/delay.h>
>> >
>> >  #include "compat.h"
>> >  #include "tm6000.h"
>> > @@ -45,11 +46,49 @@
>> >                        printk(KERN_DEBUG "%s at %s: " fmt, \
>> >                        dev->name, __FUNCTION__ , ##args); } while
>> > (0)
>> >
>> > +static void tm6000_i2c_reset(struct tm6000_core *dev)
>> > +{
>> > +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
>> > TM6000_GPIO_CLK, 0);
>> > +       msleep(15);
>> > +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
>> > TM6000_GPIO_CLK, 1);
>> > +       msleep(15);
>> > +}
>> > +
>> >  static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned
>> > char addr, __u8 reg, char *buf, int len)
>> >  {
>> > -       return 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);
>> > +       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("Incorrect lenght 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 */
>> > @@ -58,23 +97,41 @@
>> >  {
>> >        int rc;
>> >        u8 b[2];
>> > +       unsigned int i2c_packet_limit = 16;
>> >
>> > -       if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 ==
>> > addr) && (reg % 2 == 0)) {
>> > +       if (dev->dev_type == TM6010)
>> > +               i2c_packet_limit = 64;
>> > +
>> > +       if (!buf)
>> > +               return -1;
>> > +
>> > +       if (len < 1 || len > i2c_packet_limit){
>> > +               printk("Incorrect lenght 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);
>> > +               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);
>> > +               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;
>> >  }
>> >
>> > @@ -85,8 +142,137 @@
>> >  static int tm6000_i2c_recv_regs16(struct tm6000_core *dev,
>> > unsigned char addr, __u16 reg, char *buf, int len)
>> >  {
>> > -       return 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);
>> > +       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_read_sequence(struct tm6000_core *dev,
>> > unsigned char addr,
>> > +                                 __u16 reg, char *buf, int len)
>> > +{
>> > +       int rc;
>> > +
>> > +       if (dev->dev_type != TM6010)
>> > +               return -1;
>> > +
>> > +       if (!buf)
>> > +               return -1;
>> > +
>> > +       if (len < 1 || len > 64){
>> > +               printk("Incorrect lenght of i2c packet = %d, limit
>> > set to 64\n",
>> > +                       len);
>> > +               return -1;
>> > +       }
>> > +
>> > +       /* capture mutex */
>> > +       rc = tm6000_read_write_usb(dev, USB_DIR_IN |
>> > USB_TYPE_VENDOR |
>> > +               USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
>> > +               reg, 0, buf, len);
>> > +       /* release mutex */
>> > +       return rc;
>> > +}
>> > +
>> > +static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
>> > +                               unsigned char addr, __u16 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("Incorrect lenght 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+1, len-1);
>> > +
>> > +       if (rc < 0) {
>> > +               /* release mutex */
>> > +               return rc;
>> > +       }
>> > +
>> > +       /* Calculate delay time, 13800us for 64 bytes */
>> > +       tsleep = ((len * 200) + 1000) / 1000;
>> > +       msleep(tsleep);
>> > +
>> > +       /* release mutex */
>> > +       return rc;
>> > +}
>> > +
>> > +static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned
>> > char addr,
>> > +                                 __u16 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("Incorrect lenght 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_30_I2C_WRITE,
>> > +               addr | reg << 8, 0, buf+1, len-1);
>> > +
>> > +       if (rc < 0) {
>> > +               /* release mutex */
>> > +               return rc;
>> > +       }
>> > +
>> > +       /* Calculate delay time, 14800us for 64 bytes */
>> > +       tsleep = ((len * 200) + 1000 + 1000) / 1000;
>> > +       msleep(tsleep);
>> > +
>> > +       /* release mutex */
>> > +       return rc;
>> >  }
>> >
>> >  static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
>> >
>> >
>> > With my best regards, Dmitry.
>

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH] tm6000 fix i2c
  2010-04-27  6:07         ` Bee Hock Goh
@ 2010-04-28  1:32           ` Dmitri Belimov
  2010-04-28  5:49           ` tm6000 Dmitri Belimov
  1 sibling, 0 replies; 14+ messages in thread
From: Dmitri Belimov @ 2010-04-28  1:32 UTC (permalink / raw)
  To: Bee Hock Goh; +Cc: Stefan Ringel, linux-media, Mauro Carvalho Chehab

[-- Attachment #1: Type: text/plain, Size: 15790 bytes --]

On Tue, 27 Apr 2010 14:07:00 +0800
Bee Hock Goh <beehock@gmail.com> wrote:

> wiki is your best friend. :)
> 
> http://www.linuxtv.org/wiki/index.php/Maintaining_Git_trees
> http://www.linuxtv.org/wiki/index.php/Using_a_git_driver_development_tree

Ok.

This is new version. Made by git.

diff --git a/drivers/staging/tm6000/tm6000-i2c.c b/drivers/staging/tm6000/tm6000-i2c.c
index 2ab632b..e9b568d 100644
--- a/drivers/staging/tm6000/tm6000-i2c.c
+++ b/drivers/staging/tm6000/tm6000-i2c.c
@@ -47,8 +47,38 @@ MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
 static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
 				__u8 reg, char *buf, int len)
 {
-	return 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);
+	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("Incorrect lenght 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 */
@@ -57,7 +87,21 @@ static int tm6000_i2c_recv_regs(struct tm6000_core *dev, unsigned char addr,
 {
 	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("Incorrect lenght 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
@@ -74,6 +118,7 @@ static int tm6000_i2c_recv_regs(struct tm6000_core *dev, unsigned char addr,
 			REQ_16_SET_GET_I2C_WR1_RDN, addr | reg << 8, 0, buf, len);
 	}
 
+	/* release mutex */
 	return rc;
 }
 
@@ -84,8 +129,37 @@ static int tm6000_i2c_recv_regs(struct tm6000_core *dev, unsigned char addr,
 static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
 				  __u16 reg, char *buf, int len)
 {
-	return 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);
+	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,

Signed-off-by: Beholder Intl. Ltd. Dmitry Belimov <d.belimov@gmail.com>


> 
> On Tue, Apr 27, 2010 at 1:15 PM, Dmitri Belimov <d.belimov@gmail.com>
> wrote:
> > On Mon, 26 Apr 2010 20:58:24 +0800
> > Bee Hock Goh <beehock@gmail.com> wrote:
> >
> >> thanks. This is work fine on my tm5600.
> >
> > Good news.
> >
> >> btw, can you use the git tree? There is some codes update from
> >> Stefan there for the tm6000-i2c that is still not sync with hg.
> >
> > no problemm. Give me access and URL.
> >
> > With my best regards, Dmitry.
> >
> >> On Mon, Apr 26, 2010 at 8:25 AM, Dmitri Belimov
> >> <d.belimov@gmail.com> wrote:
> >> > Hi
> >> >
> >> > Rework last I2C patch.
> >> > Set correct limit for I2C packet.
> >> > Use different method for the tm5600/tm6000 and tm6010 to read
> >> > word.
> >> >
> >> > Try this patch.
> >> >
> >> > diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
> >> > --- a/linux/drivers/staging/tm6000/tm6000-i2c.c Mon Apr 05
> >> > 22:56:43 2010 -0400 +++
> >> > b/linux/drivers/staging/tm6000/tm6000-i2c.c Mon Apr 26 04:15:56
> >> > 2010 +1000 @@ -24,6 +24,7 @@ #include <linux/kernel.h>
> >> >  #include <linux/usb.h>
> >> >  #include <linux/i2c.h>
> >> > +#include <linux/delay.h>
> >> >
> >> >  #include "compat.h"
> >> >  #include "tm6000.h"
> >> > @@ -45,11 +46,49 @@
> >> >                        printk(KERN_DEBUG "%s at %s: " fmt, \
> >> >                        dev->name, __FUNCTION__ , ##args); } while
> >> > (0)
> >> >
> >> > +static void tm6000_i2c_reset(struct tm6000_core *dev)
> >> > +{
> >> > +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
> >> > TM6000_GPIO_CLK, 0);
> >> > +       msleep(15);
> >> > +       tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
> >> > TM6000_GPIO_CLK, 1);
> >> > +       msleep(15);
> >> > +}
> >> > +
> >> >  static int tm6000_i2c_send_regs(struct tm6000_core *dev,
> >> > unsigned char addr, __u8 reg, char *buf, int len)
> >> >  {
> >> > -       return 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);
> >> > +       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("Incorrect lenght 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 */
> >> > @@ -58,23 +97,41 @@
> >> >  {
> >> >        int rc;
> >> >        u8 b[2];
> >> > +       unsigned int i2c_packet_limit = 16;
> >> >
> >> > -       if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 ==
> >> > addr) && (reg % 2 == 0)) {
> >> > +       if (dev->dev_type == TM6010)
> >> > +               i2c_packet_limit = 64;
> >> > +
> >> > +       if (!buf)
> >> > +               return -1;
> >> > +
> >> > +       if (len < 1 || len > i2c_packet_limit){
> >> > +               printk("Incorrect lenght 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);
> >> > +               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);
> >> > +               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;
> >> >  }
> >> >
> >> > @@ -85,8 +142,137 @@
> >> >  static int tm6000_i2c_recv_regs16(struct tm6000_core *dev,
> >> > unsigned char addr, __u16 reg, char *buf, int len)
> >> >  {
> >> > -       return 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);
> >> > +       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_read_sequence(struct tm6000_core *dev,
> >> > unsigned char addr,
> >> > +                                 __u16 reg, char *buf, int len)
> >> > +{
> >> > +       int rc;
> >> > +
> >> > +       if (dev->dev_type != TM6010)
> >> > +               return -1;
> >> > +
> >> > +       if (!buf)
> >> > +               return -1;
> >> > +
> >> > +       if (len < 1 || len > 64){
> >> > +               printk("Incorrect lenght of i2c packet = %d,
> >> > limit set to 64\n",
> >> > +                       len);
> >> > +               return -1;
> >> > +       }
> >> > +
> >> > +       /* capture mutex */
> >> > +       rc = tm6000_read_write_usb(dev, USB_DIR_IN |
> >> > USB_TYPE_VENDOR |
> >> > +               USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
> >> > +               reg, 0, buf, len);
> >> > +       /* release mutex */
> >> > +       return rc;
> >> > +}
> >> > +
> >> > +static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
> >> > +                               unsigned char addr, __u16 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("Incorrect lenght 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+1, len-1);
> >> > +
> >> > +       if (rc < 0) {
> >> > +               /* release mutex */
> >> > +               return rc;
> >> > +       }
> >> > +
> >> > +       /* Calculate delay time, 13800us for 64 bytes */
> >> > +       tsleep = ((len * 200) + 1000) / 1000;
> >> > +       msleep(tsleep);
> >> > +
> >> > +       /* release mutex */
> >> > +       return rc;
> >> > +}
> >> > +
> >> > +static int tm6000_i2c_write_uni(struct tm6000_core *dev,
> >> > unsigned char addr,
> >> > +                                 __u16 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("Incorrect lenght 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_30_I2C_WRITE,
> >> > +               addr | reg << 8, 0, buf+1, len-1);
> >> > +
> >> > +       if (rc < 0) {
> >> > +               /* release mutex */
> >> > +               return rc;
> >> > +       }
> >> > +
> >> > +       /* Calculate delay time, 14800us for 64 bytes */
> >> > +       tsleep = ((len * 200) + 1000 + 1000) / 1000;
> >> > +       msleep(tsleep);
> >> > +
> >> > +       /* release mutex */
> >> > +       return rc;
> >> >  }
> >> >
> >> >  static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
> >> >
> >> >
> >> > With my best regards, Dmitry.
> >

With my best regards, Dmitry.

[-- Attachment #2: tm6000_i2c.patch --]
[-- Type: text/x-patch, Size: 3310 bytes --]

diff --git a/drivers/staging/tm6000/tm6000-i2c.c b/drivers/staging/tm6000/tm6000-i2c.c
index 2ab632b..e9b568d 100644
--- a/drivers/staging/tm6000/tm6000-i2c.c
+++ b/drivers/staging/tm6000/tm6000-i2c.c
@@ -47,8 +47,38 @@ MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
 static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
 				__u8 reg, char *buf, int len)
 {
-	return 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);
+	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("Incorrect lenght 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 */
@@ -57,7 +87,21 @@ static int tm6000_i2c_recv_regs(struct tm6000_core *dev, unsigned char addr,
 {
 	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("Incorrect lenght 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
@@ -74,6 +118,7 @@ static int tm6000_i2c_recv_regs(struct tm6000_core *dev, unsigned char addr,
 			REQ_16_SET_GET_I2C_WR1_RDN, addr | reg << 8, 0, buf, len);
 	}
 
+	/* release mutex */
 	return rc;
 }
 
@@ -84,8 +129,37 @@ static int tm6000_i2c_recv_regs(struct tm6000_core *dev, unsigned char addr,
 static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
 				  __u16 reg, char *buf, int len)
 {
-	return 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);
+	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,

Signed-off-by: Beholder Intl. Ltd. Dmitry Belimov <d.belimov@gmail.com>

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* tm6000
  2010-04-27  6:07         ` Bee Hock Goh
  2010-04-28  1:32           ` Dmitri Belimov
@ 2010-04-28  5:49           ` Dmitri Belimov
  2010-04-28  7:32             ` tm6000 Bee Hock Goh
  2010-04-28 12:14             ` tm6000 Mauro Carvalho Chehab
  1 sibling, 2 replies; 14+ messages in thread
From: Dmitri Belimov @ 2010-04-28  5:49 UTC (permalink / raw)
  To: Bee Hock Goh; +Cc: Stefan Ringel, linux-media, Mauro Carvalho Chehab

Hi

Anyone can watch TV with tm6000 module??

I try mplayer. My PC crashed inside copy_streams function after some time.

With my best regards, Dmitry.

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: tm6000
  2010-04-28  5:49           ` tm6000 Dmitri Belimov
@ 2010-04-28  7:32             ` Bee Hock Goh
  2010-04-28 12:14             ` tm6000 Mauro Carvalho Chehab
  1 sibling, 0 replies; 14+ messages in thread
From: Bee Hock Goh @ 2010-04-28  7:32 UTC (permalink / raw)
  To: Dmitri Belimov; +Cc: Stefan Ringel, linux-media, Mauro Carvalho Chehab

its working fine on my tm5600. Run fine for more than 5mins without crashing.

But it does crashed everytime when its playing on the first channel
and I switch channel in mythtv. I am waiting for usb/serial cable to
arrive from ebay to find out why.

I hope to work on the audio part though.

On Wed, Apr 28, 2010 at 1:49 PM, Dmitri Belimov <d.belimov@gmail.com> wrote:
> Hi
>
> Anyone can watch TV with tm6000 module??
>
> I try mplayer. My PC crashed inside copy_streams function after some time.
>
> With my best regards, Dmitry.
>

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: tm6000
  2010-04-28  5:49           ` tm6000 Dmitri Belimov
  2010-04-28  7:32             ` tm6000 Bee Hock Goh
@ 2010-04-28 12:14             ` Mauro Carvalho Chehab
  1 sibling, 0 replies; 14+ messages in thread
From: Mauro Carvalho Chehab @ 2010-04-28 12:14 UTC (permalink / raw)
  To: Dmitri Belimov; +Cc: Bee Hock Goh, Stefan Ringel, linux-media

Dmitri Belimov wrote:
> Hi
> 
> Anyone can watch TV with tm6000 module??
> 
> I try mplayer. My PC crashed inside copy_streams function after some time.
> 
> With my best regards, Dmitry.

It is still causing panic on my tests. Probably, the routine is still writing
something out of the buffer area.

-- 

Cheers,
Mauro

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH] tm6000 fix i2c
  2010-04-26  0:25   ` Dmitri Belimov
  2010-04-26 12:58     ` Bee Hock Goh
@ 2010-04-26 13:29     ` Mauro Carvalho Chehab
  1 sibling, 0 replies; 14+ messages in thread
From: Mauro Carvalho Chehab @ 2010-04-26 13:29 UTC (permalink / raw)
  To: Dmitri Belimov; +Cc: Stefan Ringel, linux-media, Bee Hock Goh

Hi Dmitri,

Dmitri Belimov wrote:
> Hi 
> 
> Rework last I2C patch.
> Set correct limit for I2C packet.
> Use different method for the tm5600/tm6000 and tm6010 to read word.
> 
> Try this patch.
> 
> diff -r 7c0b887911cf linux/drivers/staging/tm6000/tm6000-i2c.c
> --- a/linux/drivers/staging/tm6000/tm6000-i2c.c	Mon Apr 05 22:56:43 2010 -0400
> +++ b/linux/drivers/staging/tm6000/tm6000-i2c.c	Mon Apr 26 04:15:56 2010 +1000
> @@ -24,6 +24,7 @@
>  #include <linux/kernel.h>
>  #include <linux/usb.h>
>  #include <linux/i2c.h>
> +#include <linux/delay.h>

You probably don't need this.

>  
>  #include "compat.h"
>  #include "tm6000.h"
> @@ -45,11 +46,49 @@
>  			printk(KERN_DEBUG "%s at %s: " fmt, \
>  			dev->name, __FUNCTION__ , ##args); } while (0)
>  
> +static void tm6000_i2c_reset(struct tm6000_core *dev)
> +{
> +	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 0);
> +	msleep(15);
> +	tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN, TM6000_GPIO_CLK, 1);
> +	msleep(15);
> +}
> +
>  static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
>  				__u8 reg, char *buf, int len)
>  {
> -	return 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);
> +	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("Incorrect lenght 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 */
> @@ -58,23 +97,41 @@
>  {
>  	int rc;
>  	u8 b[2];
> +	unsigned int i2c_packet_limit = 16;
>  
> -	if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
> +	if (dev->dev_type == TM6010)
> +		i2c_packet_limit = 64;
> +
> +	if (!buf)
> +		return -1;
> +
> +	if (len < 1 || len > i2c_packet_limit){
> +		printk("Incorrect lenght 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);
> +		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);
> +		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;
>  }
>  
> @@ -85,8 +142,137 @@
>  static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
>  				  __u16 reg, char *buf, int len)
>  {
> -	return 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);
> +	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_read_sequence(struct tm6000_core *dev, unsigned char addr,
> +				  __u16 reg, char *buf, int len)
> +{
> +	int rc;
> +
> +	if (dev->dev_type != TM6010)
> +		return -1;
> +
> +	if (!buf)
> +		return -1;
> +
> +	if (len < 1 || len > 64){
> +		printk("Incorrect lenght of i2c packet = %d, limit set to 64\n",
> +			len);
> +		return -1;
> +	}
> +
> +	/* capture mutex */
> +	rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
> +		USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
> +		reg, 0, buf, len);
> +	/* release mutex */
> +	return rc;
> +}
> +
> +static int tm6000_i2c_write_sequence(struct tm6000_core *dev,
> +				unsigned char addr, __u16 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("Incorrect lenght 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+1, len-1);
> +
> +	if (rc < 0) {
> +		/* release mutex */
> +		return rc;
> +	}
> +
> +	/* Calculate delay time, 13800us for 64 bytes */
> +	tsleep = ((len * 200) + 1000) / 1000;
> +	msleep(tsleep);
> +
> +	/* release mutex */
> +	return rc;
> +}
> +
> +static int tm6000_i2c_write_uni(struct tm6000_core *dev, unsigned char addr,
> +				  __u16 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("Incorrect lenght 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_30_I2C_WRITE,
> +		addr | reg << 8, 0, buf+1, len-1);
> +
> +	if (rc < 0) {
> +		/* release mutex */
> +		return rc;
> +	}
> +
> +	/* Calculate delay time, 14800us for 64 bytes */
> +	tsleep = ((len * 200) + 1000 + 1000) / 1000;
> +	msleep(tsleep);
> +
> +	/* release mutex */
> +	return rc;
>  }

There are some troubles here that I noticed on your first patch: you're
adding some new functions that aren't used on the code, generating some
warnings. Please remove them or use.
>  
>  static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
> 
> 
> With my best regards, Dmitry.
> 


-- 

Cheers,
Mauro

^ permalink raw reply	[flat|nested] 14+ messages in thread

end of thread, other threads:[~2010-04-28 12:14 UTC | newest]

Thread overview: 14+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2010-04-23  0:48 [PATCH] tm6000 fix i2c Dmitri Belimov
2010-04-23 12:57 ` Bee Hock Goh
2010-04-25 23:46   ` Dmitri Belimov
2010-04-23 15:15 ` Stefan Ringel
2010-04-25 23:47   ` Dmitri Belimov
2010-04-26  0:25   ` Dmitri Belimov
2010-04-26 12:58     ` Bee Hock Goh
2010-04-27  5:15       ` Dmitri Belimov
2010-04-27  6:07         ` Bee Hock Goh
2010-04-28  1:32           ` Dmitri Belimov
2010-04-28  5:49           ` tm6000 Dmitri Belimov
2010-04-28  7:32             ` tm6000 Bee Hock Goh
2010-04-28 12:14             ` tm6000 Mauro Carvalho Chehab
2010-04-26 13:29     ` [PATCH] tm6000 fix i2c Mauro Carvalho Chehab

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox