1，i2c-tools的使用
Android-i2ctools 下载：
https://github.com/skyxiaoyan1/android-i2ctool编译会生成五个工具：i2cdetect、i2cset、i2cget、i2cdump、i2ctransfer，拷贝到开发板中就可以使用。
i2cdetect：用于扫描 i2c 总线上的设备，并显示地址
i2cset：设置i2c设备某个寄存器的值
i2cget：读取i2c设备某个寄存器的值
i2cdump：读取某个i2c设备所有寄存器的值
i2ctransfer：一次性读写多个字节
Android toybox源码中也有一些i2c tools，但是缺少i2ctransfer工具：
external/toybox/toys/other/i2ctools.c（1）i2cdetect
用i2cdetect检测有几组i2c总线在系统上，输入：./i2cdetect -l
Usage: i2cdetect [-y] [-a] [-q|-r] I2CBUS [FIRST LAST]
i2cdetect -F I2CBUS
i2cdetect -l
I2CBUS is an integer or an I2C bus name
If provided, FIRST and LAST limit the probing range.
y:关闭交互式，不会显示警告信息
a:扫描总线上所有设备
q:使用SMBus的"quick write"命令进行检测，不建议使用
r:使用SMBus的"receive byte"命令进行检测，不建议使用
i2cbus:指定查询某个总线编号
first、last：扫描的地址范围
lynkco:/ # i2cdetect -l
i2c-3 i2c Geni-I2C I2C Adapter
i2c-1 i2c Geni-I2C I2C Adapter
i2c-4 i2c Geni-I2C I2C Adapter
i2c-2 i2c Geni-I2C I2C Adapter用i2cdetect检测挂载在i2c总线上器件，输入 ./i2cdetect -r -y 1（检测i2c-1上的挂载情况）
lynkco:/sys/devices/platform/soc/a94000.i2c/i2c-1/1-0052 # i2cdetect -r -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- UU -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- UU -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --两个设备,设备地址0x52和设备地址0x64。
（2）i2cdump
用i2cdump查看器件所有寄存器的值，以总线1上0x52 这个器件为例，输入 i2cdump -f -y 2 0x52
lynkco:/sys/devices/platform/soc/a94000.i2c/i2c-1/1-0052 # i2cdump -f -y 1 0x52
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 09 14 07 08 18 60 22 00 b8 20 20 0e 89 55 40 08 ?????`".? ??U@?
10: 00 00 10 00 00 81 00 00 02 0d ea 0d d5 00 00 00 ..?..?..?????...
20: 34 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 4...............
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
40: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
50: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
60: a0 07 d0 00 00 00 08 00 00 00 00 00 00 00 00 00 ???...?.........
70: 00 00 00 00 41 00 00 00 00 00 00 00 00 00 00 00 ....A...........
80: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XXXXXXXXXXXXXXXX
90: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XXXXXXXXXXXXXXXX
a0: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XXXXXXXXXXXXXXXX
b0: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XXXXXXXXXXXXXXXX
c0: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XXXXXXXXXXXXXXXX
d0: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XXXXXXXXXXXXXXXX
e0: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XXXXXXXXXXXXXXXX
f0: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XXXXXXXXXXXXXXXX（3）i2cget
用i2cget 看单个寄存器地址, 以总线1上0x52 0x01这个寄存器为例 i2cget -f -y 1 0x52 0x01
lynkco:/ # i2cget -f -y 1 0x52 0x01
0x14Usage: i2cget [-f] [-y] [-a] I2CBUS CHIP-ADDRESS [DATA-ADDRESS [MODE]]
I2CBUS is an integer or an I2C bus name
ADDRESS is an integer (0x03 - 0x77, or 0x00 - 0x7f if -a is given)
MODE is one of:
b (read byte data, default)
w (read word data)
c (write byte/read byte)
Append p for SMBus PEC
f:强制访问
y:关闭交互模式，不会提示警告信息
i2cbus:总线编号
chip-address:i2c设备地址
data-address:i2c寄存器地址
mode:指定读取的大小，b字节，w字，s是SMBus块，i是i2c块
（4）i2cset
i2cset：向i2c设备某个寄存器写入值
Usage: i2cset [-f] [-y] [-m MASK] [-r] [-a] I2CBUS CHIP-ADDRESS DATA-ADDRESS [VALUE] ... [MODE]
I2CBUS is an integer or an I2C bus name
ADDRESS is an integer (0x03 - 0x77, or 0x00 - 0x7f if -a is given)
MODE is one of:
c (byte, no value)
b (byte data, default)
w (word data)
i (I2C block data)
s (SMBus block data)
Append p for SMBus PEC
f:强制访问
y:指令执行自动yes，否则会提示确认执行Continue? [Y/n] Y，不加参数y会有很多执行提示，可以帮助判断
r:写入后立即回读寄存器的值，并将结果与写入的值进行比较
i2cbus：总线编号
chip-address:i2c设备地址
data-address:i2c寄存器地址
value 要写入的值
mode：指定读取的大小，b字节，w字，s是SMBus块，i是i2c块
设置i2c-1上0x20器件的0x77寄存器值为0x3f
./i2cset -f -y 1 0x20 0x77 0x3f2，i2c-dev注册
i2c-dev.c文件完全可以被看作是一个i2c设备驱动，不过，它实现的i2c_client是虚拟的，临时的，主要是为了便于从用户空间操作i2c外设。
i2c-dev.c针对每个i2c适配器生成一个主设备号为89的设备文件，实现了i2c_driver的成员函数以及文件操作接口，因此i2c-dev.c的主体是"i2c_driver成员函数 + 字符设备驱动"。
2.1 i2c-dev注册代码流程
static int __init i2c_dev_init(void)
{
int res;
printk(KERN_INFO "i2c /dev entries driver\n");
res = register_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS, "i2c"); //注册设备编号，起始主设备号89, 起始次设备号为0
if (res)
goto out;
i2c_dev_class = class_create(THIS_MODULE, "i2c-dev"); //创建i2c-dev的class，为在linux文件系统中创建字符设备做准备
if (IS_ERR(i2c_dev_class)) {
res = PTR_ERR(i2c_dev_class);
goto out_unreg_chrdev;
}
i2c_dev_class->dev_groups = i2c_groups;
/* Keep track of adapters which will be added or removed later */
res = bus_register_notifier(&i2c_bus_type, &i2cdev_notifier); //监听i2c adapter设备的增加或移除事件，添加或移除adapter对应的 cdev和device
if (res)
goto out_unreg_class;
/* Bind to already existing adapters right away */
i2c_for_each_dev(NULL, i2cdev_attach_adapter);//通过函数i2c_for_each_dev遍历已经绑定的adapter，有多少个adapter就调用i2cdev_attach_adapter函数几次
return 0;
out_unreg_class:
class_destroy(i2c_dev_class);
out_unreg_chrdev:
unregister_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS);
out:
printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
return res;
}i2cdev_attach_adapter：
static int i2cdev_attach_adapter(struct device *dev, void *dummy)
{
struct i2c_adapter *adap;
struct i2c_dev *i2c_dev;
int res;
if (dev->type != &i2c_adapter_type) //device type为adapter才会被创建字符设备
return 0;
adap = to_i2c_adapter(dev); //通过dev获取对应的i2c adapter
i2c_dev = get_free_i2c_dev(adap); //给i2c_dev分配内存空间
if (IS_ERR(i2c_dev))
return PTR_ERR(i2c_dev);
cdev_init(&i2c_dev->cdev, &i2cdev_fops); //初始化一个字符设备结构体，并初始化device的fops，cdev->ops = fops;
i2c_dev->cdev.owner = THIS_MODULE;
device_initialize(&i2c_dev->dev);
i2c_dev->dev.devt = MKDEV(I2C_MAJOR, adap->nr); // i2c_dev->dev.devt
i2c_dev->dev.class = i2c_dev_class; //class
i2c_dev->dev.parent = &adap->dev; //parent
i2c_dev->dev.release = i2cdev_dev_release;
dev_set_name(&i2c_dev->dev, "i2c-%d", adap->nr); //设置device name为i2c-x，也就是我们在字符设备创建成功后看到的/dev/i2c-x设备
res = cdev_device_add(&i2c_dev->cdev, &i2c_dev->dev); //添加设备到系统，并且创建对应的字符设备到用户空间，cdev_add(cdev, dev->devt, 1); and device_add(dev);
if (res) {
put_i2c_dev(i2c_dev, false);
return res;
}
pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
adap->name, adap->nr);
return 0;
}2.2 cdev_device_add函数实现
/**
* cdev_device_add() - add a char device and it's corresponding
* struct device, linkink
* @dev: the device structure
* @cdev: the cdev structure
*
* cdev_device_add() adds the char device represented by @cdev to the system,
* just as cdev_add does. It then adds @dev to the system using device_add
* The dev_t for the char device will be taken from the struct device which
* needs to be initialized first. This helper function correctly takes a
* reference to the parent device so the parent will not get released until
* all references to the cdev are released.
*
* This helper uses dev->devt for the device number. If it is not set
* it will not add the cdev and it will be equivalent to device_add.
*
* This function should be used whenever the struct cdev and the
* struct device are members of the same structure whose lifetime is
* managed by the struct device.
*
* NOTE: Callers must assume that userspace was able to open the cdev and
* can call cdev fops callbacks at any time, even if this function fails.
*/
int cdev_device_add(struct cdev *cdev, struct device *dev)
{
int rc = 0;
if (dev->devt) {
cdev_set_parent(cdev, &dev->kobj);
rc = cdev_add(cdev, dev->devt, 1); //注册字符设备
if (rc)
return rc;
}
rc = device_add(dev); // 创建/dev/xxx，device_create()会调用到device_add
if (rc)
cdev_del(cdev);
return rc;
}2.3 i2cdev_fops
2.3.1 i2c-dev的字符设备操作集
static int i2cdev_open(struct inode *inode, struct file *file)
{
unsigned int minor = iminor(inode);
struct i2c_client *client;
struct i2c_adapter *adap;
adap = i2c_get_adapter(minor);
if (!adap)
return -ENODEV;
/* This creates an anonymous i2c_client, which may later be
* pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
*
* This client is ** NEVER REGISTERED ** with the driver model
* or I2C core code!! It just holds private copies of addressing
* information and maybe a PEC flag.
*/
client = kzalloc(sizeof(*client), GFP_KERNEL);
if (!client) {
i2c_put_adapter(adap);
return -ENOMEM;
}
snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
client->adapter = adap;
file->private_data = client; //创建一个临时的i2c_client，不注册进i2c core
return 0;
}
static ssize_t i2cdev_read(struct file *file, char __user *buf, size_t count,
loff_t *offset)
{
char *tmp;
int ret;
struct i2c_client *client = file->private_data;
if (count > 8192)
count = 8192;
tmp = kzalloc(count, GFP_KERNEL);
if (tmp == NULL)
return -ENOMEM;
pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
iminor(file_inode(file)), count);
ret = i2c_master_recv(client, tmp, count);
if (ret >= 0)
if (copy_to_user(buf, tmp, ret))
ret = -EFAULT;
kfree(tmp);
return ret;
}
static const struct file_operations i2cdev_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read = i2cdev_read,
.write = i2cdev_write,
/* 如果是64位的用户程序运行在64位的kernel上，调用的是unlocked_ioctl，如果是32位的APP运行在32位的kernel上，调用的也是unlocked_ioctl。*/
.unlocked_ioctl = i2cdev_ioctl,
/* compat_ioctl：支持64bit的driver必须要实现ioctl，当有32bit的userspace application call 64bit kernel的IOCTL的时候，这个callback会被调用到。如果没有实现compat_ioctl，那么32位的用户程序在64位的kernel上执行ioctl时会返回错误：Not a typewriter */
.compat_ioctl = compat_i2cdev_ioctl,
.open = i2cdev_open,
.release = i2cdev_release,
};I2c-dev.c提供的i2cdev_read()、i2cdev_write()函数对应于用户空间要使用的read()和write()文件操作接口，这两个部分分别调用I2C核心的i2c_master_recv() 和 i2c_master_send()函数来构造一条I2C消息并引发适配器Algorithm通信函数的调用， 以完成消息的传输。
但是，大多数稍微复杂一点的I2C设备的读写流程并不对应于一条消息，往往需要两条甚至多条消息来进行一次读写周期，在这种情况下，在应用层仍然调用read()、write()文件API来读写I2C设备，将不能正确读写。
鉴于上述原因，i2c-dev.c中的i2cdev_read() 和 i2cdev_write()函数不具备太强的通用性，只能适用于非RepStart模式的情况。对于由两条以上消息组成的读写，在用户空间需要组织i2c_msg消息数组并调用I2C_RDWR_IOCTL命令。
2.3.2 i2cdev_ioctl()函数框架
static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct i2c_client *client = file->private_data;
unsigned long funcs;
dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
cmd, arg);
switch (cmd) {
case I2C_SLAVE:
case I2C_SLAVE_FORCE:
if ((arg > 0x3ff) ||
(((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
return -EINVAL;
if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
return -EBUSY;
/* REVISIT: address could become busy later */
client->addr = arg;
return 0;
case I2C_TENBIT:
if (arg)
client->flags |= I2C_M_TEN;
else
client->flags &= ~I2C_M_TEN;
return 0;
case I2C_PEC:
return 0;
case I2C_FUNCS:
funcs = i2c_get_functionality(client->adapter);
return put_user(funcs, (unsigned long __user *)arg);
case I2C_RDWR: {
struct i2c_rdwr_ioctl_data rdwr_arg;
struct i2c_msg *rdwr_pa;
return i2cdev_ioctl_rdwr(client, rdwr_arg.nmsgs, rdwr_pa);
}
case I2C_SMBUS: {
return i2cdev_ioctl_smbus(client, data_arg.read_write,
data_arg.command,
data_arg.size,
data_arg.data);
}
case I2C_RETRIES:
if (arg > INT_MAX)
return -EINVAL;
client->adapter->retries = arg;
break;
case I2C_TIMEOUT:
if (arg > INT_MAX)
return -EINVAL;
/* For historical reasons, user-space sets the timeout
* value in units of 10 ms.
*/
client->adapter->timeout = msecs_to_jiffies(arg * 10);
break;
default:
/* NOTE: returning a fault code here could cause trouble
* in buggy userspace code. Some old kernel bugs returned
* zero in this case, and userspace code might accidentally
* have depended on that bug.
*/
return -ENOTTY;
}
return 0;
}2.3.3 ioctl支持的功能
kernel\msm_kernel\include\uapi\linux\i2c-dev.h
/* /dev/i2c-X ioctl commands. The ioctl's parameter is always an
* unsigned long, except for:
* - I2C_FUNCS, takes pointer to an unsigned long
* - I2C_RDWR, takes pointer to struct i2c_rdwr_ioctl_data
* - I2C_SMBUS, takes pointer to struct i2c_smbus_ioctl_data
*/
#define I2C_RETRIES 0x0701 /* number of times a device address should
be polled when not acknowledging */
#define I2C_TIMEOUT 0x0702 /* set timeout in units of 10 ms */
/* NOTE: Slave address is 7 or 10 bits, but 10-bit addresses
* are NOT supported! (due to code brokenness)
*/
#define I2C_SLAVE 0x0703 /* Use this slave address */
#define I2C_SLAVE_FORCE 0x0706 /* Use this slave address, even if it
is already in use by a driver! */
#define I2C_TENBIT 0x0704 /* 0 for 7 bit addrs, != 0 for 10 bit */
#define I2C_FUNCS 0x0705 /* Get the adapter functionality mask */
#define I2C_RDWR 0x0707 /* Combined R/W transfer (one STOP only) */
#define I2C_PEC 0x0708 /* != 0 to use PEC with SMBus */
#define I2C_SMBUS 0x0720 /* SMBus transfer */
2.3.4 ioctl实例
设置从设备地址
ioctl(fd, I2C_SLAVE, SLAVE_ADDR);
ioctl(fd, I2C_SLAVE_FORCE, SLAVE_ADDR);设置超时时间
ioctl(fd, I2C_TIMEOUT, 1);超时时间单位：10ms
设置重试次数
ioctl(fd, I2C_RETRIES, 1);I2C读写操作
struct i2c_rdwr_ioctl_data data;
ioctl(fd, I2C_RDWR, (unsigned long)&data);i2c-dev的读写操作是通过ioctl系统调用的I2C_RDWR命令完成，将struct i2c_rdwr_ioctl_data结构体的参数传递给内核态；
// include/uapi/linux/i2c-dev.h
struct i2c_rdwr_ioctl_data {
struct i2c_msg __user *msgs; /* pointers to i2c_msgs */
__u32 nmsgs; /* number of i2c_msgs */
};i2c_rdwr_ioctl_data结构体包含了指向i2c_msg结构体的消息指针msgs，和i2c_msg消息个数的nmsgs；
I2C传输数据是以字节为单位的，具体到i2c_msg结构体，buf表示要传输的数据，len表示传输的数据字节数；
I2C读取，需要两个i2c_msg组成的数组；第一个i2c_msg的buf，保存master向slave发出目标寄存器地址，len表示寄存器地址字节长度；第二个i2c_msg的buf，用来接收slave向master返回的数据，len表示期望读到的数据字节长度；
I2C写入，仅由一个i2c_msg组成；i2c_msg的buf，保存从slave的目标寄存器地址和要写入的数据，len表示期望写入的数据字节长度；
i2c_msg消息以数组格式定义，是为了访问连续，因为数组是连续内存存储的；
2.3.5 i2cdev_ioctl_rdwr函数实现
i2cdev_ioctl_rdwr()函数，处理通过ioctl()系统调用I2C_RDWR命令的操作，即对从设备读写的操作。
static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct i2c_client *client = file->private_data;
unsigned long funcs;
dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
cmd, arg);
switch (cmd) {
... ... ...
case I2C_RDWR: {
struct i2c_rdwr_ioctl_data rdwr_arg;
struct i2c_msg *rdwr_pa;
if (copy_from_user(&rdwr_arg,
(struct i2c_rdwr_ioctl_data __user *)arg,
sizeof(rdwr_arg)))
return -EFAULT;
if (!rdwr_arg.msgs || rdwr_arg.nmsgs == 0)
return -EINVAL;
/*
* Put an arbitrary limit on the number of messages that can
* be sent at once
*/
if (rdwr_arg.nmsgs > I2C_RDWR_IOCTL_MAX_MSGS)
return -EINVAL;
rdwr_pa = memdup_user(rdwr_arg.msgs,
rdwr_arg.nmsgs * sizeof(struct i2c_msg));
if (IS_ERR(rdwr_pa))
return PTR_ERR(rdwr_pa);
return i2cdev_ioctl_rdwr(client, rdwr_arg.nmsgs, rdwr_pa);
}
... ... ...
}
return 0;
}
static noinline int i2cdev_ioctl_rdwr(struct i2c_client *client,
unsigned nmsgs, struct i2c_msg *msgs)
{
u8 __user **data_ptrs;
int i, res;
data_ptrs = kmalloc_array(nmsgs, sizeof(u8 __user *), GFP_KERNEL);
if (data_ptrs == NULL) {
kfree(msgs);
return -ENOMEM;
}
res = 0;
for (i = 0; i < nmsgs; i++) {
/* Limit the size of the message to a sane amount */
if (msgs[i].len > 8192) {
res = -EINVAL;
break;
}
data_ptrs[i] = (u8 __user *)msgs[i].buf;
msgs[i].buf = memdup_user(data_ptrs[i], msgs[i].len);
if (IS_ERR(msgs[i].buf)) {
res = PTR_ERR(msgs[i].buf);
break;
}
/* memdup_user allocates with GFP_KERNEL, so DMA is ok */
msgs[i].flags |= I2C_M_DMA_SAFE;
... ... ...
//通过i2c_transfer进行i2c消息的收发
res = i2c_transfer(client->adapter, msgs, nmsgs);
while (i-- > 0) {
if (res >= 0 && (msgs[i].flags & I2C_M_RD)) {
if (copy_to_user(data_ptrs[i], msgs[i].buf,
msgs[i].len))
res = -EFAULT;
}
kfree(msgs[i].buf);
}
kfree(data_ptrs);
kfree(msgs);
return res;
}i2cdev_ioctl_rdwr()函数，完成了消息的收发操作，具体操作：
将i2c_rdwr_ioctl_data数据从用户空间拷贝到内核空间
将i2c_rdwr_ioctl_data.msgs消息数组从用户空间拷贝到内核空间
将i2c_rdwr_ioctl_data.msgs.buf数组从用户空间拷贝到内核空间
通过i2c_transfer()函数，以i2c_msg消息格式数组和从设备通信
2.4 监听i2c adapter设备的增加或移除事件，添加或移除adapter对应的 cdev和device
static int i2cdev_notifier_call(struct notifier_block *nb, unsigned long action,
void *data)
{
struct device *dev = data;
switch (action) {
case BUS_NOTIFY_ADD_DEVICE:
return i2cdev_attach_adapter(dev, NULL);
case BUS_NOTIFY_DEL_DEVICE:
return i2cdev_detach_adapter(dev, NULL);
}
return 0;
}
static struct notifier_block i2cdev_notifier = {
.notifier_call = i2cdev_notifier_call,
};BUS_NOTIFY_ADD_DEVICE notifier event的发出：
device_add(&control->dev);
/* Notify clients of device addition. This call must come
* after dpm_sysfs_add() and before kobject_uevent().
*/
if (dev->bus)
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
BUS_NOTIFY_ADD_DEVICE, dev);2.5 i2c cdev和device的创建结果示例
char device：
lynkco:/ # ls -l /dev/i2c-*
crw-rw---- 1 system system 89, 1 1970-11-20 21:04 /dev/i2c-1
crw-rw---- 1 system system 89, 2 1970-11-20 21:04 /dev/i2c-2
crw-rw---- 1 system system 89, 3 1970-11-20 21:04 /dev/i2c-3
crw-rw---- 1 system system 89, 4 1970-11-20 21:04 /dev/i2c-4
i2c-dev clas：
127|lynkco:/sys/class/i2c-dev # ls -l
total 0
lrwxrwxrwx 1 root root 0 2023-12-05 08:56 i2c-1 -> ../../devices/platform/soc/a94000.i2c/i2c-1/i2c-dev/i2c-1
lrwxrwxrwx 1 root root 0 2023-12-05 08:56 i2c-2 -> ../../devices/platform/soc/984000.i2c/i2c-2/i2c-dev/i2c-2
lrwxrwxrwx 1 root root 0 2023-12-05 08:56 i2c-3 -> ../../devices/platform/soc/988000.i2c/i2c-3/i2c-dev/i2c-3
lrwxrwxrwx 1 root root 0 2023-12-05 08:56 i2c-4 -> ../../devices/platform/soc/a84000.i2c/i2c-4/i2c-dev/i2c-4
sysfs device：
lynkco:/sys/devices/platform/soc/a94000.i2c/i2c-1/i2c-dev/i2c-1 # ls -l
total 0
-r--r--r-- 1 root root 4096 2023-12-05 08:56 dev
lrwxrwxrwx 1 root root 0 2023-12-05 08:56 device -> ../../../i2c-1
-r--r--r-- 1 root root 4096 2023-12-05 08:56 name
drwxr-xr-x 2 root root 0 2023-12-05 08:56 power
lrwxrwxrwx 1 root root 0 2023-12-05 08:56 subsystem -> ../../../../../../../class/i2c-dev
-rw-r--r-- 1 root root 4096 2023-12-05 08:56 uevent
3，在用户空间读写I2C设备
3.1 open
用户态使用open函数打开对应的I2C设备节点/dev/i2c-X，如：/dev/i2c-2；
int fd = -1;
fd = open("/dev/i2c-2", O_RDWR);i2c-dev在open时，为设备节点建立一个i2c_client，但是这个i2c_client并不加添加到i2c_adapter的client链表中，而是在用户关闭设备节点时，自动释放i2c_client。
3.2 read/write实现
使用操作普通文件的接口read()和write()。这两个函数间接调用了i2c_master_recv和 i2c_master_send。
但是在使用之前需要使用I2C_SLAVE设置从机地址，设置可能失败，需要检查返回值。这种通信过程进行I2C层的通信，一次只能进行一个方向的传输。
1）发送
int i2c_write_bytes(int fd, unsigned short addr, unsigned char *data, int len)
{
unsigned char *data_wr = NULL;
int ret = -1;
data_wr = malloc(len + 2);
if (!data_wr) {
printf("%s, malloc failed!\n", __func__);
return -1;
}
data_wr[0] = addr / 0xff;
data_wr[1] = addr % 0xff;
memcpy(&data_wr[2], data, len);
ioctl(fd, I2C_SLAVE, SLAVE_ADDR);
ioctl(fd, I2C_TIMEOUT, 1);
ioctl(fd, I2C_RETRIES, 1);
ret = write(fd, data_wr, len+2);
if (ret < 0) {
printf("%s, write failed, ret: 0x%x\n", __func__, ret);
return ret;
}
printf("%s, write ok, num: %d\n", __func__, ret);
if (data_wr != NULL) {
free(data_wr);
data_wr = NULL;
}
return ret;
}2）接收
int i2c_read_bytes(int fd, unsigned short addr, unsigned char *data, int len)
{
unsigned char addr_slave[2] = { 0 };
int ret = -1;
ioctl(fd, I2C_SLAVE, SLAVE_ADDR);
ioctl(fd, I2C_TIMEOUT, 1);
ioctl(fd, I2C_RETRIES, 1);
addr_slave[0] = addr / 0xff;
addr_slave[1] = addr % 0xff;
ret = write(fd, addr_slave, 2);
if (ret < 0) {
printf("%s, write failed, ret: 0x%x\n", __func__, ret);
return ret;
}
ret = read(fd, data, len);
if (ret < 0) {
printf("%s, read failed, ret: 0x%x\n", __func__, ret);
return ret;
}
printf("%s, read ok, num: %d\n", __func__, ret);
return ret;
}3.3 ioctl实现
可以更为灵活的read或者write数据，包括i2c_transfer。使用该方法可以以struct i2c_msg为参数，一次读取、或者写入、或者读取加写入，一定数量的数据。
1）发送
int i2c_write_bytes(int fd, unsigned short addr, unsigned char *data, int len)
{
struct i2c_rdwr_ioctl_data data_wr;
int ret = -1;
data_wr.nmsgs = 1;
data_wr.msgs = malloc(sizeof(struct i2c_msg) * data_wr.nmsgs);
if (!data_wr.msgs) {
printf("%s, msgs malloc failed!\n", __func__);
return -1;
}
data_wr.msgs[0].addr = SLAVE_ADDR;
data_wr.msgs[0].flags = 0;
data_wr.msgs[0].len = len + 2;
data_wr.msgs[0].buf = malloc(data_wr.msgs[0].len + 2);
if (!data_wr.msgs[0].buf) {
printf("%s, msgs buf malloc failed!\n", __func__);
return -1;
}
data_wr.msgs[0].buf[0] = addr / 0xff;
data_wr.msgs[0].buf[1] = addr % 0xff;
memcpy(&data_wr.msgs[0].buf[2], data, len);
ret = ioctl(fd, I2C_RDWR, (unsigned long)&data_wr);
if (ret < 0) {
printf("%s, ioctl failed, ret: 0x%x\n", __func__, ret);
return ret;
}
if (data_wr.msgs[0].buf != NULL) {
free(data_wr.msgs[0].buf);
data_wr.msgs[0].buf = NULL;
}
if (data_wr.msgs != NULL) {
free(data_wr.msgs);
data_wr.msgs = NULL;
}
return ret;
}2）接收
int i2c_read_bytes(int fd, unsigned short addr, unsigned char *data, int len)
{
struct i2c_rdwr_ioctl_data data_rd;
int ret = -1;
int i = 0;
data_rd.nmsgs = 2;
data_rd.msgs = malloc(sizeof(struct i2c_msg) * data_rd.nmsgs);
if (!data_rd.msgs) {
printf("%s, msgs malloc failed!\n", __func__);
return -1;
}
data_rd.msgs[0].addr = SLAVE_ADDR;
data_rd.msgs[0].flags = 0;
data_rd.msgs[0].len = 2;
data_rd.msgs[0].buf = malloc(data_rd.msgs[0].len);
if (!data_rd.msgs[0].buf) {
printf("%s, msgs buf malloc failed!\n", __func__);
return -1;
}
data_rd.msgs[0].buf[0] = addr / 0xff;
data_rd.msgs[0].buf[1] = addr % 0xff;
data_rd.msgs[1].addr = SLAVE_ADDR;
data_rd.msgs[1].flags = I2C_M_RD;
data_rd.msgs[1].len = len;
data_rd.msgs[1].buf = malloc(data_rd.msgs[1].len);
if (!data_rd.msgs[0].buf) {
printf("%s, msgs buf malloc failed!\n", __func__);
return -1;
}
memset(data_rd.msgs[1].buf, 0, data_rd.msgs[1].len);
ret = ioctl(fd, I2C_RDWR, (unsigned long)&data_rd);
if (ret < 0) {
printf("%s, ioctl failed, ret: 0x%x\n", __func__, ret);
return ret;
}
memcpy(data, data_rd.msgs[1].buf, len);
printf("%s, read ok, num: %d\n", __func__, ret);
if (data_rd.msgs[0].buf != NULL) {
free(data_rd.msgs[0].buf);
data_rd.msgs[0].buf = NULL;
}
if (data_rd.msgs[1].buf != NULL) {
free(data_rd.msgs[1].buf);
data_rd.msgs[1].buf = NULL;
}
if (data_rd.msgs != NULL) {
free(data_rd.msgs);
data_rd.msgs = NULL;
}
return ret;
}3.4 main函数
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>
#define SLAVE_ADDR 0x51
int arr_show(unsigned char *data, int len)
{
int i = 0;
for (i = 0; i < len; i++) {
printf("data[%d]: 0x%x\n", i, data[i]);
}
return 0;
}
void usage(void)
{
printf("xxx -r addr len\n");
printf("xxx -w addr data1 data2 ...\n");
}
int main(int argc, char *argv[])
{
int opt;
int fd = -1;
unsigned short addr;
unsigned char buf[256] = { 0 };
int len = 0;
int i = 0;
if (argc < 4) {
usage();
return -1;
}
fd = open("/dev/i2c-2", O_RDWR);
if (fd < 0) {
printf("%s, open failed!\n", __func__);
return -1;
}
while ((opt = getopt(argc, argv, "w:r:")) != -1) {
printf("optarg: %s\n", optarg);
printf("optind: %d\n", optind);
printf("argc: %d\n", argc);
printf("argv[optind]: %s\n", argv[optind]);
addr = (unsigned short)strtol(optarg, NULL, 0);
printf("addr: %d\n", addr);
switch(opt) {
case 'w':
for (len = 0; optind < argc; optind++, len++) {
buf[len] = (unsigned char)strtol(argv[optind], NULL, 0);
}
printf("len: %d\n", len);
i2c_write_bytes(fd, addr, buf, len);
break;
case 'r':
len = (unsigned int)strtol(argv[optind], NULL, 0);
printf("len: %d\n", len);
i2c_read_bytes(fd, addr, buf, len);
arr_show(buf, len);
break;
default:
printf("Invalid parameter!\n");
usage;
break;
}
}
close(fd);
return 0;
}参考链接：
【I2C】通用驱动i2c-dev分析_i2c-dev.c-CSDN博客
Linux-kernel中的i2c-dev驱动 | Mshrimp blog
