Linux驱动子系统之I2C（一）

主要是参考http://blog.csdn.net/cjok376240497/article/details/6972305，对I2C子系统讲解的很透彻的一篇文章，值得一读。

1 硬件特性
1.1 概述
I2C总线是由Philips公司开发的两线式串行总线，这两根线为时钟线(SCL)和双向数据线(SDA)。由于I2C总线仅需要两根线，因此在电路板上占用的空间更少，带来的问题是带宽较窄。I2C在标准模式下传输速率最高100Kb/s，在快速模式下最高可达400kb/s。属于半双工。在嵌入式系统中，I2C应用非常广泛，大多数微控制器中集成了I2C总线，一般用于和RTC，EEPROM，智能电池电路，传感器，LCD以及其他类似设备之间的通信。I2C总线时钟都是由I2C主控器提供。
1.2 I2C总线传输时序

1.3 I2C总线的信号状态
1、  空闲状态：SDA和SCL都是高电平；
2、  开始条件(S)：SCL为高电平时，SDA由高电平向低电平跳变，开始传输数据；
3、  结束条件(P)：SCL为高电平时，SDA由低电平向高电平跳变，结束传输数据；
4、  数据有效：在SCL的高电平期间，SDA保持稳定，数据有效。SDA的改变只能发生在SCL的低电平期间；
5、  ACK信号：数据传输的过程中，接收器件每接收一个字节数据要产生一个ACK信号，向发送器件发出特定的低电平脉冲，表示已经收到数据。
读寄存器的标准流程为：
1.    Master发送I2C addr（7bit）和w操作1（1bit），等待ACK
2.    Slave发送ACK
3.    Master发送reg addr（8bit），等待ACK
4.    Slave发送ACK
5.    Master发起START
6.    Master发送I2C addr（7bit）和r操作1（1bit），等待ACK
7.    Slave发送ACK
8.    Slave发送data（8bit），即寄存器里的值
9.    Master发送ACK
10.  第8步和第9步可以重复多次，即顺序读多个寄存器
10bit地址
10bit的寻址扩展可能寻址的数目.有7bit地址和10bit地址的设备可以连接到相同的I2C总线上,而且7bit寻址和10bit寻址都可以用在所有的总线速度模式下.不过,10bit寻址用的不多.
10bit的从机地址由开始条件(S)或重复开始条件(Sr)后的两个字节组成.第一个字节的前7位是1111 0XX,XX是10bit地址的最高有效位的前两位.第一个字节的第8bit是读写位,决定传输方向.
尽管1111 XXX有8种可能的组合,然后只有1111 0XX这四种可以用于10bit寻址.剩下的1111 1XX这四种是为将来I2C扩展用的.

1.4 从设备地址

从datasheet发现，有三个IO口确定I2C从设备地址后三位，I2C总线从设备使用7位地址，最后一个为读写控制位。下图是TVP5158的原理图，我们可以计算出它的地址，在读取SII9135A的时候，手册上写得是0X60、0X68，这是8位，前7位有效，所以真实的I2C地址为0x30、0x34，第八位代表读写。

1.5 I2C读写方式

下面I2C写操作的步骤：

多字节写的时序

 下面是I2C读操作的步骤：

多字节读的时序

具体可参考datasheet

2  I2C子系统
2.1 LinuxI2C子系统架构
在内核中已经提供I2C子系统，所以在做I2C驱动之前，就必须要熟悉该子系统。

2.2 三大组成部分
1、I2C核心(i2c-core)
I2C核心提供了I2C总线驱动和设备驱动的注册、注销方法，I2C通信方法(algorithm)上层的、与具体适配器无关的代码以及探测设备、检测设备地址的上层代码等。
2、I2C总线驱动(I2Cadapter/Algo driver)
I2C总线驱动是I2C适配器的软件实现，提供I2C适配器与从设备间完成数据通信的能力。
I2C总线驱动由i2c_adapter和i2c_algorithm来描述
3、I2C客户驱动程序(I2Cclient driver)
I2C客户驱动是对I2C从设备的软件实现，一个具体的I2C客户驱动包括两个部分：一部分是i2c_driver，用于将设备挂接于i2c总线；另一部分是设备本身的驱动。
I2C客户驱动程序由i2c_driver和i2c_client来描述
2.3 所有的I2C驱动代码位于drivers/i2c目录下
I2c-core.c    实现I2C核心的功能
I2c-dev.c     通用的从设备驱动
Chips       特定的I2C设备驱动
Busses      I2C适配器的驱动
Algos       实现了一些I2C总线适配器的algorithm
2.4 I2C驱动编写的两种方法
从上面的图我们可以看到两种编写驱动方法，一种是利用系统提供的i2c-dev.c来实现一个i2c适配器的设备文件，然后通过在应用层操作I2C适配器来控制I2C设备；另一种是为I2C从设备独立编写一个设备驱动，不需要i2c-dev.c文件。
2.5 重要的数据结构
每次分析子系统免不了分析它的数据结构，OK我们先来分析一下。
I2c_adapter结构体代表I2C总线控制器

struct i2c_adapter {
   struct module *owner;
   unsigned int class;       /*classes to allow probing for */
    const struct i2c_algorithm*algo; /* 总线上数据传输的算法*/
   void *algo_data;              /* algorithm 数据 */
 
   int timeout;            /* injiffies */
   int retries;             /* 重试次数 */
    struct device dev;      /* the adapter device */
 
   int nr;
   char name[48];                 /* 适配器名字 */
   struct completion dev_released;   /* 用于同步 */
};

I2c_algorithm对应一套通信方法

struct i2c_algorithm {
    int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, intnum);
    int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
               unsigned short flags, charread_write,
               u8 command, int size, unioni2c_smbus_data *data);
    u32 (*functionality) (structi2c_adapter *);
};

Functionality 函数用于返回algorithm所支持的通信协议，比如I2C_FUNC_I2C,I2C_FUNC_10BIT_ADDR等。
smbus_xfer   函数SMBus传输函数指针，SMBus大部分基于I2C总线规范，SMBus不需增加额外引脚。与I2C总线相比，SMBus增加了一些新的功能特性，在访问时序也有一定的差异。
Master_xfer  函数实现总线上数据传输，与具体的适配器有关
Master_xfer  函数实现模板:

static int i2c_adapter_xxx_xfer(structi2c_adapter *adap, struct i2c_msg *msgs, int num)
{
   ......
   for (i = 0; i < num; i++) {
       i2c_adapter_xxx_start();         /*产生起始位*/
       if (msgs[i]->flags & I2C_M_RD) {    /*读取*/
           i2c_adapter_xxx_setaddr((msg->addr << 1) | 1);  /*发送从设备地址*/
           i2c_adapter_xxx_wait_ack();   /*获得从设备的ACK*/
i2c_adapter_xxx_readbytes(msgs[i]->buf,msgs[i]->len);  /*读取len长度的数据到buf中*/
       } else {
           i2c_adapter_xxx_setaddr(msg->addr << 1);
           i2c_adapter_xxx_wait_ack();
           i2c_adapter_xxx_writebytes(msgs[i]->buf, msgs[i]->len);
       }
    }
   i2c_adapter_xxx_stop(); /*产生停止位*/
}

上面调用的函数用于完成适配器的底层硬件操作，与I2C适配器和CPU的具体硬件直接相关，需要由工程师根据芯片的数据手册来实现。在内核源码中，针对不同的I2C适配器都有master_xfer的实现，风格与模板不尽相同，但是可以用该模板作为参考来看源代码，受益匪浅。
I2c_driver代表I2C从设备驱动

struct i2c_driver {
         unsignedint class;
 
         int(*attach_adapter)(struct i2c_adapter *) __deprecated; /*依附i2c适配器函数指针*/
         int(*detach_adapter)(struct i2c_adapter *) __deprecated;/*脱离i2c适配器函数指针*/
 
         int (*probe)(struct i2c_client*, const struct i2c_device_id *);
         int (*remove)(struct i2c_client*);
 
         int(*suspend)(struct i2c_client *, pm_message_t mesg);
         int(*resume)(struct i2c_client *);
         void(*alert)(struct i2c_client *, unsigned int data);
         int(*command)(struct i2c_client *client, unsigned int cmd, void *arg);
 
         struct device_driver driver;
         const struct i2c_device_id*id_table;  /* 该驱动所支持的设备ID表 */
 
         /*Device detection callback for automatic device creation */
         int(*detect)(struct i2c_client *, struct i2c_board_info *);
         constunsigned short *address_list;
         structlist_head clients;
};

在新内核中，attach_adapter和detach_adapter已经被probe和remove取代
Id_table用于i2c_driver和i2c_client的匹配
I2c_client代表I2C从设备

struct i2c_client {
unsigned short flags;                 /*I2C_CLIENT_TEN：使用10位从地址，I2C_CLIENT_PEC：使用SMBus包错误检测*/
         unsignedshort addr;                 /* chipaddress - NOTE: 7bit    */
         charname[I2C_NAME_SIZE];
         struct i2c_adapter *adapter; /* 依附的i2c_adapter   */
         struct i2c_driver *driver;         /* 依附的i2c_driver*/
         structdevice dev;             /* the devicestructure             */
         intirq;                         /* irq issuedby device               */
         structlist_head detected;
};

2.6 核心层提供的接口函数
1、  增加/删除I2C适配器
int i2c_add_adapter(struct i2c_adapter *adapter)->static int i2c_register_adapter(struct i2c_adapter *adap)
int i2c_del_adapter(struct i2c_adapter *adap)

static int i2c_register_adapter(struct i2c_adapter *adap)
{
    int res = 0;

    /* Can't register until after driver model init */
    if (unlikely(WARN_ON(!i2c_bus_type.p))) {
        res = -EAGAIN;
        goto out_list;
    }

    /* Sanity checks */
    if (unlikely(adap->name[0] == '\0')) {
        pr_err("i2c-core: Attempt to register an adapter with "
               "no name!\n");
        return -EINVAL;
    }
    if (unlikely(!adap->algo)) {
        pr_err("i2c-core: Attempt to register adapter '%s' with "
               "no algo!\n", adap->name);
        return -EINVAL;
    }

    rt_mutex_init(&adap->bus_lock);
    mutex_init(&adap->userspace_clients_lock);
    INIT_LIST_HEAD(&adap->userspace_clients);

    /* Set default timeout to 1 second if not already set */
    if (adap->timeout == 0)
        adap->timeout = HZ;

    dev_set_name(&adap->dev, "i2c-%d", adap->nr);
    adap->dev.bus = &i2c_bus_type;
    adap->dev.type = &i2c_adapter_type;
    res = device_register(&adap->dev);
    if (res)
        goto out_list;

    dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);

#ifdef CONFIG_I2C_COMPAT
    res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
                       adap->dev.parent);
    if (res)
        dev_warn(&adap->dev,
             "Failed to create compatibility class link\n");
#endif

    /* create pre-declared device nodes */
    if (adap->nr < __i2c_first_dynamic_bus_num)
        i2c_scan_static_board_info(adap);

    /* Notify drivers */
    mutex_lock(&core_lock);
    bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
    mutex_unlock(&core_lock);

    return 0;

out_list:
    mutex_lock(&core_lock);
    idr_remove(&i2c_adapter_idr, adap->nr);
    mutex_unlock(&core_lock);
    return res;
}

Device_register(&adap->dev)  向I2C总线注册一个adapter设备
i2c_scan_static_board_info(adap)   注册所有已知的i2c_client
2、  增加/删除I2C从设备驱动 
int i2c_add_driver(struct i2c_driver *driver)->int i2c_register_driver(struct module *owner, struct i2c_driver *driver) 
void i2c_del_driver(struct i2c_driver *driver)  

/*
 * An i2c_driver is used with one or more i2c_client (device) nodes to access
 * i2c slave chips, on a bus instance associated with some i2c_adapter.
 */
int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
{
    int res;

    /* Can't register until after driver model init */
    if (unlikely(WARN_ON(!i2c_bus_type.p)))
        return -EAGAIN;

    /* add the driver to the list of i2c drivers in the driver core */
    driver->driver.owner = owner;
    driver->driver.bus = &i2c_bus_type;

    /* When registration returns, the driver core
     * will have called probe() for all matching-but-unbound devices.
     */
    res = driver_register(&driver->driver);
    if (res)
        return res;

    pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);

    INIT_LIST_HEAD(&driver->clients);
    /* Walk the adapters that are already present */
    mutex_lock(&core_lock);
    bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_new_driver);
    mutex_unlock(&core_lock);

    return 0;
}
EXPORT_SYMBOL(i2c_register_driver);

向I2C总线注册一个i2c_driver
3、  i2c传输，发送和接收
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg*msgs, int num) 
int i2c_master_send(const struct i2c_client *client, constchar *buf, int count) 
int i2c_master_recv(const struct i2c_client *client, char*buf, int count) 

/**
 * i2c_transfer - execute a single or combined I2C message
 * @adap: Handle to I2C bus
 * @msgs: One or more messages to execute before STOP is issued to
 *    terminate the operation; each message begins with a START.
 * @num: Number of messages to be executed.
 *
 * Returns negative errno, else the number of messages executed.
 *
 * Note that there is no requirement that each message be sent to
 * the same slave address, although that is the most common model.
 */
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
    unsigned long orig_jiffies;
    int ret, try;

    /* REVISIT the fault reporting model here is weak:
     *
     *  - When we get an error after receiving N bytes from a slave,
     *    there is no way to report "N".
     *
     *  - When we get a NAK after transmitting N bytes to a slave,
     *    there is no way to report "N" ... or to let the master
     *    continue executing the rest of this combined message, if
     *    that's the appropriate response.
     *
     *  - When for example "num" is two and we successfully complete
     *    the first message but get an error part way through the
     *    second, it's unclear whether that should be reported as
     *    one (discarding status on the second message) or errno
     *    (discarding status on the first one).
     */

    if (adap->algo->master_xfer) {
#ifdef DEBUG
        for (ret = 0; ret < num; ret++) {
            dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
                "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
                ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
                (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
        }
#endif

        if (in_atomic() || irqs_disabled()) {
            ret = i2c_trylock_adapter(adap);
            if (!ret)
                /* I2C activity is ongoing. */
                return -EAGAIN;
        } else {
            i2c_lock_adapter(adap);
        }

        /* Retry automatically on arbitration loss */
        orig_jiffies = jiffies;
        for (ret = 0, try = 0; try <= adap->retries; try++) {
            ret = adap->algo->master_xfer(adap, msgs, num);
            if (ret != -EAGAIN)
                break;
            if (time_after(jiffies, orig_jiffies + adap->timeout))
                break;
        }
        i2c_unlock_adapter(adap);

        return ret;
    } else {
        dev_dbg(&adap->dev, "I2C level transfers not supported\n");
        return -EOPNOTSUPP;
    }
}
EXPORT_SYMBOL(i2c_transfer);

最终会调用到适配器实现的master_xfer函数来完成数据传输工作

2.6 I2C子系统初始化

struct bus_type i2c_bus_type = {
    .name        = "i2c",
    .match        = i2c_device_match,
    .probe        = i2c_device_probe,
    .remove        = i2c_device_remove,
    .shutdown    = i2c_device_shutdown,
    .pm        = &i2c_device_pm_ops,
};
EXPORT_SYMBOL_GPL(i2c_bus_type);
//////////////////////////////
static int __init i2c_init(void)
{
    int retval;

    retval = bus_register(&i2c_bus_type);
    if (retval)
        return retval;
#ifdef CONFIG_I2C_COMPAT
    i2c_adapter_compat_class = class_compat_register("i2c-adapter");
    if (!i2c_adapter_compat_class) {
        retval = -ENOMEM;
        goto bus_err;
    }
#endif
    retval = i2c_add_driver(&dummy_driver);
    if (retval)
        goto class_err;
    return 0;

class_err:
#ifdef CONFIG_I2C_COMPAT
    class_compat_unregister(i2c_adapter_compat_class);
bus_err:
#endif
    bus_unregister(&i2c_bus_type);
    return retval;
}

static void __exit i2c_exit(void)
{
    i2c_del_driver(&dummy_driver);
#ifdef CONFIG_I2C_COMPAT
    class_compat_unregister(i2c_adapter_compat_class);
#endif
    bus_unregister(&i2c_bus_type);
}

/* We must initialize early, because some subsystems register i2c drivers
 * in subsys_initcall() code, but are linked (and initialized) before i2c.
 */
postcore_initcall(i2c_init);
module_exit(i2c_exit);

3  i2c-dev
3.1 概述
之前在介绍I2C子系统时，提到过使用i2c-dev.c文件在应用程序中实现我们的I2C从设备驱动。不过，它实现的是一个虚拟，临时的i2c_client，随着设备文件的打开而产生，并随着设备文件的关闭而撤销。I2c-dev.c针对每个I2C适配器生成一个主设备号为89的设备文件，实现了i2c_driver的成员函数以及文件操作接口，所以i2c-dev.c的主题是”i2c_driver成员函数+字符设备驱动”。
3.2 i2c-dev.c源码分析
初始化模块

static int __init i2c_dev_init(void)
{
         res= register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);
 
         i2c_dev_class= class_create(THIS_MODULE, "i2c-dev");
 
         /*Keep track of adapters which will be added or removed later */
         res= bus_register_notifier(&i2c_bus_type, &i2cdev_notifier);
 
         /*绑定已经存在的适配器 */
         i2c_for_each_dev(NULL,i2cdev_attach_adapter);
}

I2c-dev初始化函数主要做了注册名为”i2c”的字符设备文件和”i2c-dev”的类
i2cdev_read和i2cdev_write
I2c-dev.c中实现的i2cdev_read和i2cdev_write函数不具有太强的通用性，只适合下面这种单开始信号情况：

而不适合多开始信号的情况：

所以我们经常会使用i2cdev_ioctl函数的I2C_RDWR，在分析i2cdev_ioctl函数之前，我们需要了解一个结构体：

/* This is the structure as used in theI2C_RDWR ioctl call */
struct i2c_rdwr_ioctl_data {
         structi2c_msg __user *msgs;         /* pointersto i2c_msgs */
         __u32nmsgs;                    /* number ofi2c_msgs */
};

Msgs     表示单个开始信号传递的数据；
Nmsgs     表示有多少个msgs，比如上图，单开始信号时，nmsgs等于1；多开始信号时，nmsgs等于2

struct i2c_msg {
         __u16addr;     /* slave address                         */
         __u16flags;  /* 默认为写入 */
#define I2C_M_TEN                  0x0010     /*this is a ten bit chip address */
#define I2C_M_RD           0x0001     /* read data,from slave to master */
#define I2C_M_NOSTART                  0x4000     /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_REV_DIR_ADDR     0x2000     /*if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_IGNORE_NAK          0x1000     /*if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_NO_RD_ACK           0x0800     /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_RECV_LEN               0x0400     /* length will be first received byte */
         __u16len;                  /* msg length                              */
         __u8*buf;                 /* pointer to msgdata                       */
};

使用i2cdev_ioctl函数的I2C_RDWR指令会调用到i2cdev_ioctl_rdrw函数：

static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
                   unsignedlong arg)
{
         structi2c_rdwr_ioctl_data rdwr_arg;
         structi2c_msg *rdwr_pa;
         u8__user **data_ptrs;
         inti, res;
 
         if(copy_from_user(&rdwr_arg,
                               (struct i2c_rdwr_ioctl_data __user *)arg,
                               sizeof(rdwr_arg)))
                   return-EFAULT;
 
         if(rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
                   return-EINVAL;
 
         rdwr_pa= kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg), GFP_KERNEL);
 
         if(copy_from_user(rdwr_pa, rdwr_arg.msgs,
                               rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
                   kfree(rdwr_pa);
                   return-EFAULT;
         }
 
         res= i2c_transfer(client->adapter, rdwr_pa, rdwr_arg.nmsgs);
         while(i-- > 0) {
                   if(res >= 0 && (rdwr_pa[i].flags & I2C_M_RD)) {
                            if(copy_to_user(data_ptrs[i], rdwr_pa[i].buf,
                                                rdwr_pa[i].len))
                                     res= -EFAULT;
                   }
                   kfree(rdwr_pa[i].buf);
         }
}

咋一看，还挺复杂，其实主要做了一件事情：把用户空间传递过来的i2c_rdwr_ioctl_data数据进行错误检查，然后调用i2c_transfer函数与适配器进行通信，如果是接收数据，代码会将访问到的数据传回i2c_rdwr_ioctl_data的buf中。I2c_transfer最终会调用到I2C适配器具体实现的master_xfer函数来与硬件进行通信。
3.3 用户空间驱动模板

#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>

#define OSA_SOK      0  ///< Status : OK
#define OSA_EFAIL   -1  ///< Status : Generic error

#define I2C_DEFAULT_INST_ID  (2)
#define I2C_TRANSFER_SIZE_MAX   (254)

#ifndef TRUE
#define TRUE              1
#endif

#ifndef FALSE
#define FALSE             0
#endif

typedef unsigned short    Bool;
typedef unsigned long long Uint64;      ///< Unsigned 64-bit integer
typedef unsigned int Uint32;            ///< Unsigned 32-bit integer
typedef unsigned short Uint16;          ///< Unsigned 16-bit integer
typedef unsigned char Uint8;            ///< Unsigned  8-bit integer

#define OSA_ERROR(...) \
  do \
  { \
        fprintf(stderr, " ERROR  (%s|%s|%d): ", __FILE__, __func__, __LINE__); \
        fprintf(stderr, __VA_ARGS__); \
  } \
  while(0);

typedef struct {

  int fd;

} OSA_I2cHndl;

#define OSA_I2C_DEBUG


static char xtod(char c) {
  if (c>='0' && c<='9') return c-'0';
  if (c>='A' && c<='F') return c-'A'+10;
  if (c>='a' && c<='f') return c-'a'+10;
  return c=0;        // not Hex digit
}
  

static int HextoDec(char *hex, int l)
{
  if (*hex==0) 
    return(l);

  return HextoDec(hex+1, l*16+xtod(*hex)); // hex+1?
}


int xstrtoi(char *hex)      // hex string to integer
{
  return HextoDec(hex,0);
}


int OSA_i2cOpen(OSA_I2cHndl *hndl, Uint8 instId)
{
        char deviceName[20];
        int status = 0;

        sprintf(deviceName, "/dev/i2c-%d", instId);
    printf("dev name = %s \n", deviceName);

        hndl->fd = open(deviceName, O_RDWR);

        if(hndl->fd<0)
                return OSA_EFAIL;

        return status;
}

int OSA_i2cRead8(OSA_I2cHndl *hndl, Uint16 devAddr, Uint8 *reg, Uint8 *value, Uint32 count)
{
        int i, j;
        int status = 0;
        struct i2c_msg * msgs = NULL;
        struct i2c_rdwr_ioctl_data data;

        msgs = (struct i2c_msg *) malloc(sizeof(struct i2c_msg) * count * 2);

        if(msgs==NULL)
        {
                printf(" I2C (0x%02x): Malloc ERROR during Read !!! (reg[0x%02x], count = %d)\n", devAddr, reg[0], count);
                return OSA_EFAIL;
        }

        for (i = 0, j = 0; i < count * 2; i+=2, j++)
        {
                msgs[i].addr  = devAddr;
                msgs[i].flags = 0;
                msgs[i].len   = 1;
                msgs[i].buf   = &reg[j];

                msgs[i+1].addr  = devAddr;
                msgs[i+1].flags = I2C_M_RD /* | I2C_M_REV_DIR_ADDR */;
                msgs[i+1].len   = 1;
                msgs[i+1].buf   = &value[j];
        }

        data.msgs = msgs;
        data.nmsgs = count * 2;

        status = ioctl(hndl->fd, I2C_RDWR, &data);
        if(status < 0)
        {
                status = OSA_EFAIL;
#ifdef OSA_I2C_DEBUG
                printf(" I2C (0x%02x): Read ERROR !!! (reg[0x%02x], count = %d)\n", devAddr, reg[0], count);
#endif
        }
        else
                status = OSA_SOK;

        free(msgs);

        return status;
}

int OSA_i2cWrite8(OSA_I2cHndl *hndl, Uint16 devAddr,  Uint8 *reg, Uint8 *value, Uint32 count)
{
        int i,j;
        unsigned char * bufAddr;
        int status = 0;

        struct i2c_msg * msgs = NULL;
        struct i2c_rdwr_ioctl_data data;

        msgs = (struct i2c_msg *) malloc(sizeof(struct i2c_msg) * count);

        if(msgs==NULL)
        {
                printf(" I2C (0x%02x): Malloc ERROR during Write !!! (reg[0x%02x], count = %d)\n", devAddr, reg[0], count);
                return OSA_EFAIL;
        }

        bufAddr = (unsigned char *) malloc(sizeof(unsigned char) * count * 2);

        if(bufAddr == NULL)
        {
                free(msgs);

                printf(" I2C (0x%02x): Malloc ERROR during Write !!! (reg[0x%02x], count = %d)\n", devAddr, reg[0], count);
                return OSA_EFAIL;
        }

        for (i = 0, j = 0; i < count; i++, j+=2)
        {
                bufAddr[j] = reg[i];
                bufAddr[j + 1] = value[i];

                msgs[i].addr  = devAddr;
                msgs[i].flags = 0;
                msgs[i].len   = 2;
                msgs[i].buf   = &bufAddr[j];
        }
        data.msgs = msgs;
        data.nmsgs = count;

        status = ioctl(hndl->fd, I2C_RDWR, &data);
        if(status < 0)
        {
                status = OSA_EFAIL;
#ifdef OSA_I2C_DEBUG
                printf(" I2C (0x%02x): Write ERROR !!! (reg[0x%02x], count = %d)\n", devAddr, reg[0], count);
#endif
        }
        else
                status = OSA_SOK;

        free(msgs);
        free(bufAddr);

        return status;
}

int OSA_i2cRawWrite8(OSA_I2cHndl *hndl, Uint16 devAddr, Uint8 *value, Uint32 count)
{
        int status = 0;

        struct i2c_msg msgs[1];
        struct i2c_rdwr_ioctl_data data;

        msgs[0].addr  = devAddr;
        msgs[0].flags = 0;
        msgs[0].len   = count;
        msgs[0].buf   = value;

        data.msgs = msgs;
        data.nmsgs = 1;

        status = ioctl(hndl->fd, I2C_RDWR, &data);
        if(status < 0)
        {
                status = OSA_EFAIL;
#ifdef OSA_I2C_DEBUG
                printf(" I2C (0x%02x): Raw Write ERROR !!! (count = %d)\n", devAddr, count);
#endif
        }
        else
        status = OSA_SOK;

        return status;
}


int OSA_i2cRawRead8(OSA_I2cHndl *hndl, Uint16 devAddr, Uint8 *value, Uint32 count)
{
        int status = 0;

        struct i2c_msg msgs[1];
        struct i2c_rdwr_ioctl_data data;

        msgs[0].addr  = devAddr;
        msgs[0].flags = I2C_M_RD;
        msgs[0].len   = count;
        msgs[0].buf   = value;

        data.msgs = msgs;
        data.nmsgs = 1;

        status = ioctl(hndl->fd, I2C_RDWR, &data);
        if(status < 0)
        {
                status = OSA_EFAIL;
#ifdef OSA_I2C_DEBUG
                printf(" I2C (0x%02x): Raw Read ERROR !!! count = %d)\n", devAddr, count);
#endif
        }
        else
                status = OSA_SOK;

        return status;
}

int OSA_i2cClose(OSA_I2cHndl *hndl)
{
        return close(hndl->fd);
}


int OSA_i2cTestShowUsage(char *str)
{
        printf(" \n");
        printf(" I2C Test Utility, \r\n");
        printf(" Usage: %s -r|-w <devAddrInHex> <regAddrInHex> <regValueInHex or numRegsToReadInDec> \r\n", str);
        printf(" \n");
        return 0;
}


int main(int argc, char **argv)
{
        OSA_I2cHndl i2cHndl;
        Uint8 devAddr, numRegs;
        Bool doRead;
        int status, i;

        static Uint8 regAddr[I2C_TRANSFER_SIZE_MAX], regValue8[I2C_TRANSFER_SIZE_MAX];

        if(argc<3) {
                OSA_i2cTestShowUsage(argv[0]);
                return -1;
        }

        if(strcmp(argv[1], "-r")==0)
                doRead=TRUE;
        else
        if(strcmp(argv[1], "-w")==0)
                doRead=FALSE;
        else {
                OSA_i2cTestShowUsage(argv[0]);
                return -1;
        }

        devAddr = 0;
        numRegs = 4;
        regValue8[0] = 0;
        regAddr[0] = 0;

        if(argc>2)
                devAddr = xstrtoi(argv[2]);

        if(argc>3)
                regAddr[0] = xstrtoi(argv[3]);

        if(argc>4) {
                if(doRead)
                {
                        numRegs = atoi(argv[4]);
                        if(numRegs>I2C_TRANSFER_SIZE_MAX)
                                numRegs = I2C_TRANSFER_SIZE_MAX;
                }
                else {
                        regValue8[0] = xstrtoi(argv[4]);
                }
        }

        if(devAddr==0) {
                printf(" I2C: Invalid device address\n");
                OSA_i2cTestShowUsage(argv[0]);
                return -1;
        }

        status = OSA_i2cOpen(&i2cHndl, I2C_DEFAULT_INST_ID);

        if(status != OSA_SOK) {
                OSA_ERROR("OSA_i2cOpen( instId = %d )\n", I2C_DEFAULT_INST_ID);
                return status;
        }

        if(status==OSA_SOK)
        {
                if(doRead) {
                for(i=0; i<numRegs; i++)
                regValue8[i] = 0;

                for(i=1; i<numRegs; i++)
                {
                        regAddr[i] = regAddr[0]+i;
                }

                status = OSA_i2cRead8(&i2cHndl, devAddr, regAddr, regValue8, numRegs);

                if(status==OSA_SOK) {
                        for(i=0; i<numRegs; i++) {
                                printf(" I2C (0x%02x): 0x%02x = 0x%02x \n", devAddr, regAddr[i], regValue8[i] );
                        }
                } else {
                        printf(" I2C (0x%02x): Read ERROR !!! (reg[0x%02x], count = %d)\n", devAddr, regAddr[0], numRegs);
                }

                } else {
                        status = OSA_i2cWrite8(&i2cHndl, devAddr, regAddr, regValue8, 1);
                        if(status==OSA_SOK) {
                                status = OSA_i2cRead8(&i2cHndl, devAddr, regAddr, regValue8, 1);
                        }

                        if(status==OSA_SOK) {
                                printf(" I2C (0x%02x): 0x%02x = 0x%02x \n", devAddr, regAddr[0], regValue8[0] );
                        } else {
                                printf(" I2C (0x%02x): Write ERROR !!! (reg[0x%02x], value = 0x%02x\n", devAddr, regAddr[0], regValue8[0]);
                        }
                }

                OSA_i2cClose(&i2cHndl);
        }

        return 0;
}