3518EV200上接了tvp5150am1芯片驱动_问答

自己参照其他驱动写的驱动如下：
/**
* @file tvp5150a.c
*
* @brief TVP5150 Driver.
*
* Copyright (C) 2009, ShenZhen HONGDY Ltd. All Rights Reserved
*
* Descirption:
* This is the source file for TVP-5150 driver.
*
*/

//#include
#include

#include
#include
#include
#include
#include
#include
#include
#include

#include
#include
//#include
//#include
#include
#include
//#include
#include
#include
#include
#include

#include
#include
//#include
#include
#include
#include
#include
#include

#include
#include
#include

#include
#include
#include
#include
#include

#include
#include

#include "tvp5150.h"

/* GPIO3_3 */
//#define SCL          (1 << 3)

/* GPIO3_4 */
//#define SDA          (1 << 4)

/*#define SC_PERCTRL1 IO_ADDRESS(0x101e0020)
#define GPIO_3_BASE 0x20170000

#define GPIO_3_DIR IO_ADDRESS(GPIO_3_BASE + 0x400)

#define GPIO_I2C_SDA_REG IO_ADDRESS(GPIO_3_BASE + 0x44)
#define GPIO_I2C_SCL_REG IO_ADDRESS(GPIO_3_BASE + 0x40)
#define GPIO_I2C_SCLSDA_REG IO_ADDRESS(GPIO_3_BASE + 0x60)

#define HW_REG(reg) *((volatile unsigned int *)(reg))
#define DELAY(us)    mytime_delay_us(us)
*/
//tvp5150 i2c addr
#define TVP5150A_I2C_ADDR 0xBA

static struct i2c_client * tvp_client;
static struct i2c_board_info tvp_i2c_info =
{
I2C_BOARD_INFO("tvp5150am1",TVP5150A_I2C_ADDR),
};

unsigned char _hi_i2c_read_byte(unsigned char devaddress, unsigned char address)
{
unsigned char ret_data = 0xFF;
int ret;
struct i2c_client* client = tvp_client;
unsigned char buf[2];

buf[0] = address;
ret = i2c_master_recv(client, buf, 1);
if (ret >= 0)
{
      ret_data = buf[0];
}
return ret_data;
}

int _hi_i2c_write_byte(unsigned char devaddress, unsigned char address, unsigned char data)
{
int ret;
unsigned char buf[2];
struct i2c_client* client = tvp_client;

buf[0] = address;
buf[1] = data;

ret = i2c_master_send(client, buf, 2);
return ret;
}

static int i2c_client_init(void)
{
struct i2c_adapter* i2c_adap;

// use i2c0
i2c_adap = i2c_get_adapter(0);
tvp_client = i2c_new_device(i2c_adap, &tvp_i2c_info);

i2c_put_adapter(i2c_adap);

return 0;
}

static void i2c_client_exit(void)
{
i2c_unregister_device(tvp_client);
}

#define  I2CReadByte _hi_i2c_read_byte
#define  I2CWriteByte  _hi_i2c_write_byte

/*static int write_regs(unsigned char* pdevdata, unsigned long datalen)
{
int i = 0;

while (i < datalen)
{
      I2CWriteByte(TVP5150A_I2C_ADDR, pdevdata, pdevdata[i + 1]);
      i += 2;
}
return 0;
}

///////////////////////////////////////////////////////////////////

static void myi2c_clr(unsigned char whichline)
{
unsigned char regvalue;

if (whichline == SCL)
{
regvalue = HW_REG(GPIO_3_DIR);
regvalue |= SCL;
HW_REG(GPIO_3_DIR) = regvalue;

HW_REG(GPIO_I2C_SCL_REG) = 0;
return;
}
else if(whichline == SDA)
{
regvalue = HW_REG(GPIO_3_DIR);
regvalue |= SDA;
HW_REG(GPIO_3_DIR) = regvalue;

HW_REG(GPIO_I2C_SDA_REG) = 0;
return;
}
else if(whichline == (SDA|SCL))
{
regvalue = HW_REG(GPIO_3_DIR);
regvalue |= (SDA|SCL);
HW_REG(GPIO_3_DIR) = regvalue;

HW_REG(GPIO_I2C_SCLSDA_REG) = 0;
return;
}

printk("Error input.\n");
return;
}

static void myi2c_set(unsigned char whichline)
{
unsigned char regvalue;

if (whichline == SCL)
{
regvalue = HW_REG(GPIO_3_DIR);
regvalue |= SCL;
HW_REG(GPIO_3_DIR) = regvalue;

HW_REG(GPIO_I2C_SCL_REG) = SCL;
return;
}
else if(whichline == SDA)
{
regvalue = HW_REG(GPIO_3_DIR);
regvalue |= SDA;
HW_REG(GPIO_3_DIR) = regvalue;

HW_REG(GPIO_I2C_SDA_REG) = SDA;
return;
}
else if(whichline == (SDA|SCL))
{
regvalue = HW_REG(GPIO_3_DIR);
regvalue |= (SDA|SCL);
HW_REG(GPIO_3_DIR) = regvalue;

HW_REG(GPIO_I2C_SCLSDA_REG) = (SDA|SCL);
return;
}

printk("Error input.\n");
return;
}

void mytime_delay_us(unsigned int usec)
{
int i, j;

for (i=0; i {
for (j=0; j<47; j++)
{
      ;
}
}
}

static unsigned char myi2c_data_read(void)
{
unsigned char regvalue;

regvalue = HW_REG(GPIO_3_DIR);
regvalue &= (~SDA);
HW_REG(GPIO_3_DIR) = regvalue;
DELAY(1);

regvalue = HW_REG(GPIO_I2C_SDA_REG);
if ((regvalue&SDA) != 0)
{
return 1;
}

return 0;
}

static void myi2c_start_bit(void)
{
DELAY(1);
myi2c_set(SDA | SCL);
DELAY(1);
myi2c_clr(SDA);
DELAY(2);
}

static void myi2c_stop_bit(void)
{
// clock the ack
DELAY(1);
myi2c_set(SCL);
DELAY(1);
myi2c_clr(SCL);

// actual stop bit
DELAY(1);
myi2c_clr(SDA);
DELAY(1);
myi2c_set(SCL);
DELAY(1);
myi2c_set(SDA);
DELAY(1);
}

static void myi2c_send_byte(unsigned char c)
{
int i;
local_irq_disable();
for (i=0; i<8; i++)
{
      DELAY(1);
      myi2c_clr(SCL);
      DELAY(1);

      if (c & (1 << (7 - i)))
      {
         myi2c_set(SDA);
      }
      else
      {
         myi2c_clr(SDA);
}

      DELAY(1);
      myi2c_set(SCL);
      DELAY(1);
      myi2c_clr(SCL);
}

DELAY(1);
// myi2c_set(SDA);
local_irq_enable();
}

static unsigned char myi2c_receive_byte(void)
{
int i, j = 0;
unsigned char regvalue;

local_irq_disable();
for (i=0; i<8; i++)
{
      DELAY(1);
      myi2c_clr(SCL);
      DELAY(2);
      myi2c_set(SCL);

      regvalue = HW_REG(GPIO_3_DIR);
      regvalue &= (~SDA);
      HW_REG(GPIO_3_DIR) = regvalue;
      DELAY(1);

      if (myi2c_data_read())
      {
         j += (1 << (7 - i));
}

      DELAY(1);
      myi2c_clr(SCL);
}

local_irq_enable();
DELAY(1);

return j;
}

static int myi2c_receive_ack(void)
{
int nack;
unsigned char regvalue;

DELAY(1);

regvalue = HW_REG(GPIO_3_DIR);
regvalue &= (~SDA);
HW_REG(GPIO_3_DIR) = regvalue;

DELAY(1);
myi2c_clr(SCL);
DELAY(1);
myi2c_set(SCL);
DELAY(1);

nack = myi2c_data_read();

DELAY(1);
myi2c_clr(SCL);
DELAY(1);
  //  i2c_set(SDA);
  //  DELAY(1);

if (nack == 0)
{
      return 1;
}

return 0;
}

static void myi2c_send_ack(void)
{
DELAY(1);
myi2c_clr(SCL);
DELAY(1);
myi2c_set(SDA);
DELAY(1);
myi2c_set(SCL);
DELAY(1);
myi2c_clr(SCL);
DELAY(1);
myi2c_clr(SDA);
DELAY(1);
}

void mygpio_i2c_write(unsigned char devaddress, unsigned char address, unsigned char data)
{
myi2c_start_bit();
myi2c_send_byte((unsigned char)(devaddress));
myi2c_receive_ack();
myi2c_send_byte(address);
myi2c_receive_ack();
myi2c_send_byte(data);
myi2c_receive_ack();
udelay(64);
myi2c_stop_bit();
}

unsigned char mygpio_i2c_read(unsigned char devaddress, unsigned char address)
{
unsigned char rxdata;

myi2c_start_bit();
myi2c_send_byte(devaddress);
myi2c_receive_ack();

myi2c_send_byte(address);
myi2c_receive_ack();

//myi2c_stop_bit();

myi2c_start_bit();
myi2c_send_byte(devaddress + 1);
myi2c_receive_ack();

rxdata = myi2c_receive_byte();
myi2c_send_ack();
udelay(64);

myi2c_stop_bit();

return rxdata;
}

*/

////////////////////////////////////////////////////////////////////////////

static unsigned char tvp5150a_byte_write(unsigned char chip_addr, unsigned char addr, unsigned char data)
{
I2CWriteByte(chip_addr, addr, data);

return 0;
}

static unsigned char tvp5150a_byte_read(unsigned char chip_addr, unsigned char addr)
{
//return gpio_i2c_read(chip_addr, addr);
return I2CReadByte(chip_addr, addr);
}

static int tvp5150a_device_init(void)
{
//unsigned char byValue = 0;
unsigned char byValue1 = 0;

#if 0
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x00, 0x00);
byValue = tvp5150a_byte_read(TVP5150A_I2C_ADDR, 0x03);
byValue |= 0x08;
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x03, byValue);
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x03, 0x09);
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x0d, 0x47);
#else
#if 1
//tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x00, 0x01);
//tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x30, 0x00);
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x03, /*0x6f*/0x09);
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x04, 0xDC);
byValue1 = tvp5150a_byte_read(TVP5150A_I2C_ADDR, 0x04);

if (byValue1 != 0xDC)
{
printk("TVP5150A_I2C_ADDR(0x%x) reg 0x04 value 0x%x should be 0xDC\n", TVP5150A_I2C_ADDR, byValue1);
return -1;
}
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x28, 0x04);

tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x12, 0x02);
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x11, 0x02);

tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x14, 0x02);
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x13, 0x02);

tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x18, 0x10);
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x19, 0x10);
#else
byValue1 = tvp5150a_byte_read(TVP5150A_I2C_ADDR, 0x03);
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x03, 0x09);

//tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x04, 0xD0);
tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x28, 0x06);

byValue = tvp5150a_byte_read(TVP5150A_I2C_ADDR, 0x03);
if (byValue != 0x09)
{
printk("mytvp5150a_init() failue, value 0x%x should be 0x09(value1 0x%x)\n", byValue, byValue1);
return -1;
}
#endif
#endif

return 0;
}

static int tvp5150a_open(struct inode *inode, struct file *filp)
{
// MOD_INC_USE_COUNT;

return 0;
}

static int tvp5150a_release(struct inode *inode, struct file *filp)
{
// MOD_DEC_USE_COUNT;

return 0;
}

static ssize_t tvp5150a_read(struct file *filp, char *buf, size_t size, loff_t *l)
{
printk("tvp5150a: read ioctl not implemented\n");
return -1;
}

static ssize_t tvp5150a_write(struct file *filp, const char *buf, size_t size, loff_t *l)
{
printk("tvp5150a: write ioctl not implemented\n");
return -1;
}

static long tvp5150a_ioctl(/*struct inode *inode,*/ struct file *file, unsigned int cmd, unsigned long arg)
{
unsigned char bright, saturation, contrast, hue;

switch (cmd)
{
case TVP5150A_IOC_CONFIG:
      tvp5150a_device_init();
      break;

case TVP5150A_IOC_I2C_TEST:
      break;

case TVP5150A_IOC_SELVIDEO:
      break;

case TVP5150A_SET_BRIGHT:
      if (arg)
      {
      if (copy_from_user((unsigned char *)&bright, (void *)arg, sizeof(unsigned char)))
      {
        return -EFAULT;
      }
      }

      tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x09, bright);
      break;

case TVP5150A_GET_BRIGHT:
if (arg)
      {
      bright = tvp5150a_byte_read(TVP5150A_I2C_ADDR, 0x09);
         if (copy_to_user((void *)arg, (void *)&bright, sizeof(unsigned char)))
         {
            return -EFAULT;
         }
      }
break;

case TVP5150A_SET_SATURATION:
      if (arg)
      {
      if (copy_from_user((unsigned char *)&saturation, (void *)arg, sizeof(unsigned char)))
      {
            return -EFAULT;
         }
      }

      tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x0A, saturation);
break;

case TVP5150A_GET_SATURATION:
if (arg)
      {
      saturation = tvp5150a_byte_read(TVP5150A_I2C_ADDR, 0x0A);
         if (copy_to_user((void *)arg, (void *)&saturation, sizeof(unsigned char)))
         {
            return -EFAULT;
         }
      }
      break;

case TVP5150A_SET_CONTRAST:
      if (arg)
      {
         if (copy_from_user((unsigned char *)&contrast, (void *)arg, sizeof(unsigned char)))
         {
        return -EFAULT;
      }
      }

      tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x0C, contrast);
      break;

case TVP5150A_GET_CONTRAST:
if (arg)
      {
      contrast = tvp5150a_byte_read(TVP5150A_I2C_ADDR, 0x0C);
         if (copy_to_user((void *)arg, (void *)&contrast, sizeof(unsigned char)))
         {
            return -EFAULT;
         }
      }
      break;

case TVP5150A_SET_HUE:
      if (arg)
      {
         if (copy_from_user((char *)&hue, (void *)arg, sizeof(char)))
         {
        return -EFAULT;
         }
      }

      tvp5150a_byte_write(TVP5150A_I2C_ADDR, 0x0B, hue);
      break;

case TVP5150A_GET_HUE:
if (arg)
      {
      hue = tvp5150a_byte_read(TVP5150A_I2C_ADDR, 0x0B);
         if (copy_to_user((void *)arg, (void *)&hue, sizeof(unsigned char)))
         {
            return -EFAULT;
         }
      }
break;

case TVP5150A_SET_ACTIVE_DOWN:
      break;

case TVP5150A_SET_ACTIVE_TOP:
      break;

case TVP5150A_SET_ACTIVE_LEFT:
      break;

case TVP5150A_SET_ACTIVE_RIGHT:
      break;

case TVP5150A_IOC_READ_CONFIG:
      break;
}

return 0;
}

/*
* The various file operations we support.
*/
static struct file_operations tvp5150a_fops =
{
.owner             = THIS_MODULE,
.open             = tvp5150a_open,
.release          = tvp5150a_release,
.read             = tvp5150a_read,
.write             = tvp5150a_write,
.unlocked_ioctl = tvp5150a_ioctl,
};

static struct miscdevice tvp5150a_dev =
{
.minor = MISC_DYNAMIC_MINOR,
.name = "tvp5150a",
.fops    = &tvp5150a_fops,
};

//DECLARE_KCOM_GPIO_I2C();

static int __init tvp5150a_init(void)
{
int ret = 0;

#if 0
ret = KCOM_GPIO_I2C_INIT();
if(ret)
{
      printk("GPIO I2C module is not load.\n");
      return -1;
}
#endif

i2c_client_init();
//register tvp5150a_dev
ret = misc_register(&tvp5150a_dev);
printk("tvp5150a driver init start ... \n");
if (ret)
{
//KCOM_GPIO_I2C_EXIT();
      printk("\ttvp5150a_ERROR: could not register tvp5150a devices. \n");
      return -1;
}

if(tvp5150a_device_init() < 0)
{
i2c_client_exit();
misc_deregister(&tvp5150a_dev);
printk("tvp5150 driver init fail for device init error!\n");
return -1;
}

printk("tvp5150a driver init successful!\n");

return ret;
}

static void __exit tvp5150a_exit(void)
{
i2c_client_exit();
misc_deregister(&tvp5150a_dev);

//KCOM_GPIO_I2C_EXIT();
}

module_init(tvp5150a_init);
module_exit(tvp5150a_exit);

MODULE_LICENSE("GPL");
海思方面用的采集nvp6124b D1的可采的程序，出现timeout，是驱动问题还是海思与tvp5150对接问题呢？

3518EV200上接了tvp5150am1芯片驱动

Markdown 语法

Markdown 语法