i2c 驱动一：简介

最新推荐文章于 2024-01-18 22:54:06 发布

qqliyunpeng

最新推荐文章于 2024-01-18 22:54:06 发布

阅读量1.9k

点赞数 1

分类专栏： linux驱动文章标签： i2c linux 驱动 jz2440

本文链接：https://blog.csdn.net/qqliyunpeng/article/details/52790976

版权

linux驱动专栏收录该内容

41 篇文章 7 订阅

订阅专栏

有关linux的i2c相关文章有一下几篇，他们互相关联，应该一同看：

- i2c 驱动一：简介

- i2c 驱动二：devfs文件系统

- i2c 驱动三：自己实现设备和驱动分离

- i2c 驱动四：sysfs文件系统

- i2c 驱动五：gpio模拟i2c

1. 内核源码中有关 i2c 的目录和文件：

1.1 有关 i2c 的驱动在 driver 的 i2c 目录下，先来介绍一下关键的几个文件：

i2c-core.c，实现了 I2C 核心的功能以及/proc/bus/i2c*接口
i2c-dev.c，代表一个 i2c 的adapter ，一个 i2c或者 smbus 的主设备，不是一个i2c的从设备 i2c_client，这个文件提供了 read()、write()、read()、ioctl()和 close()等函数。i2c 的主设备号是89，次设备号是 0～255 ，自动注册的设备节点是“i2c-%d” （i2c-0, i2c-1,…, i2c-10,…）
busses/s3c2410.c，是 2440/2410 的驱动，其中包括 adapter 中的master_xfer 的实现和关联
chip文件夹，包含一些特定的 i2c 设备驱动，但是现在内核版本是 3.4.112 ，将这个文件的内容合并到了 misc 文件夹。
busses文件夹，包含了一些i2c总线的驱动，如针对S3C2410、S3C2440 和 S3C6410 等处理器的I2C 控制器驱动为 i2c-s3c2410.c
algos文件夹，实现了i2c总线适配器的 algorithm
mutex文件夹，实现了 i2c switch 的功能，扩展了i2c的路数，使得有限的i2c资源扩展出足够的接口，解决了i2c容量的问题

1.2 简单的理解：

i2c-dev.c 是设备文件
busses/s3c2410.c 是驱动文件

其他文件是提供支持的文件

2. 在 include/linux/i2c.h 中定义了 i2c 用到关键的结构体：

2.1 i2c_client 结构体：

struct i2c_client { 
    unsigned int flags;                 /* 标志 */ 
    unsigned short addr;                /* 低 7 位为芯片地址 */ 
    char name[I2C_NAME_SIZE];           /* 设备名称 */ 
    struct i2c_adapter *adapter;        /*依附的 i2c_adapter*/ 
    struct i2c_driver *driver;          /*依附的 i2c_driver */ 
    struct device dev;                  /* 设备结构体*/ 
    int irq;                            /* 设备使用的中断号*/ 
    struct list_head list;              /* 链表头 */  
    struct completion released;         /* 用于同步 */ 
 };

代表一个挂载到 i2c 总线上的一个实体的从设备，包含该设备所需的数据：

【该 i2c 设备所依附的 i2c 控制器】：struct i2c_adapter *adapter

【该 i2c 设备的驱动】：struct i2c_driver *driver

【该 i2c 设备的地址】：addr

【该 i2c 设备的名字】：name

2.2 i2c_driver 结构体：

 struct i2c_driver { 
    int id; 
    unsigned int class; 
    int (*attach_adapter)(struct i2c_adapter *); /*依附 i2c_adapter 函数指针 */ 
    int (*detach_adapter)(struct i2c_adapter *); /*脱离 i2c_adapter 函数指针*/ 
    int (*detach_client)(struct i2c_client *);   /*i2c client 脱离函数指针*/ 
    int (*probe)(struct i2c_client *, const struct i2c_device_id *); 
    int (*remove)(struct i2c_client *); 
    void (*shutdown)(struct i2c_client *); 
    int (*suspend)(struct i2c_client *, pm_message_t mesg); 
    int (*resume)(struct i2c_client *); 
    int (*command)(struct i2c_client *client, unsigned int cmd, void *arg); 
    struct device_driver driver; 
    const struct i2c_device_id *id_table; /* 该驱动所支持的设备 ID 表 */ 
    int (*detect)(struct i2c_client *, int kind, struct i2c_board_info *); 
    const struct i2c_client_address_data *address_data; 
    struct list_head clients; 
};

i2c设备的驱动程序

2.3 i2c_algorithm 结构体：

struct i2c_algorithm { 
    int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs,  int num);  /*i2c 传输函数指针*/ 
    int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,  unsigned short flags, char read_write, 
                       u8 command, int size, union i2c_smbus_data * data); /*smbus 传输函数指针*/ 
   u32 (*functionality) (struct i2c_adapter *);  /*返回适配器支持的功能*/ 
 };

算法，具体实现硬件上的传输控制

2.4 i2c_adapter 结构体：

struct i2c_adapter { 
    struct module *owner;           /*所属模块*/ 
    unsigned int id;                /*algorithm 的类型，定义于 i2c-id.h，以 I2C_ALGO_开始*/ 
    unsigned int class; 
    struct i2c_algorithm *algo;      /*总线通信方法结构体指针*/ 
    void *algo_data;                 /* algorithm 数据 */ 
    int (*client_register)(struct i2c_client *);      /*client 注册时调用*/ 
    int (*client_unregister)(struct i2c_client *);    /*client 注销时调用*/ 
    u8 level; 
    struct semaphore bus_lock;       /*控制并发访问的自旋锁*/ 
    struct semaphore clist_lock; 
    int timeout; 
    int retries;                   /*  重试次数  */ 
    struct device dev;             /* 适配器设备 */ 
    struct class_device class_dev; /* 类设备 */ 
    int nr;  /* /dev/i2c-devnr */  /* (1)这里要注意 */
    struct list_head clien;        /* client 链表头*/ 
    struct list_head list; 
    char name[48];  /*适配器名称*/ 
    struct completion dev_released;    /*用于同步*/ 
};

每一个 adapter 对应一个物理上的 i2c 控制器

2.5 i2c_msg 结构体：

struct i2c_msg { 
    __u16 addr;         /* 设备地址*/ 
    __u16 flags;        /* 标志，下边是标志的定义 */ 
#define I2C_M_TEN 0x0010    /* 这是一个10位的芯片地址 */
#define I2C_M_RD 0x0001     /* 从从设备读数据，如果要写的话，flags = 0 */
#define I2C_M_NOSTART 0x4000          /*  */
#define I2C_M_REV_DIR_ADDR 0x2000     /*  */
#define I2C_M_IGNORE_NAK 0x1000       /*  */
#define I2C_M_NO_RD_ACK 0x0800        /*  */
#define I2C_M_RECV_LEN 0x0400         /* 长度将会是接收的第一个字节 */
    __u16 len;      /* 消息长度*/ 
    __u8 *buf;      /* 消息数据*/ 
 };

2.6 以上的几个结构体之间的关系：

3. 对 i2c-dev.c 文件中的函数的理解：

struct file_operations i2cdev_fops = {
    ...
    .read = i2cdev_read,
    .write = i2cdev_write,
    .unlocked_ioctl= i2cdev_ioctl,
    .open = i2cdev_open,
    .release = i2cdev_release,
};

3.1i2cdev_open 函数 (.open)

static int i2cdev_open(struct inode *inode, struct file *file)
{
	unsigned int minor = iminor(inode);
	struct i2c_client *client;
	struct i2c_adapter *adap;
	struct i2c_dev *i2c_dev;

	i2c_dev = i2c_dev_get_by_minor(minor);
	if (!i2c_dev)
		return -ENODEV;

	adap = i2c_get_adapter(i2c_dev->adap->nr); /* (3)通过adap->nr找到相应的adapter的首地址，idr机制采用的是radix树，可以很方便的将整数和指针关联起来，要了解更多idr机制，可以查看 http://blog.sina.com.cn/s/blog_476d8cf30100nhfc.html */
	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->name = i2c-dev ... */

	client->adapter = adap;  /* (1)匹配上 adapter，并且关联 client中的 adapter 指针 */
	file->private_data = client; /* (2)放到私有数据中去 */

	return 0;
}

说明：对 client 的其他成员的赋值在 ioctl 中由用户完成

3.2 单个 msg 的读 (.read)

/* buf 是用于存放接收到的数据的指针，count 是数据中字节数 */

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 = kmalloc(count, GFP_KERNEL);
	if (tmp == NULL)
		return -ENOMEM;

	pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
		iminor(file->f_path.dentry->d_inode), count);

	ret = i2c_master_recv(client, tmp, count); /* (1)将读到的数据放到了 tmp指针指向的空间 里边 */
	if (ret >= 0)
		ret = copy_to_user(buf, tmp, count) ? -EFAULT : ret;
	kfree(tmp);
	return ret;
}

将读到的数据放到了 msg 里边

int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
{
	struct i2c_adapter *adap = client->adapter;
	struct i2c_msg msg;
	int ret;

	msg.addr = client->addr;
	msg.flags = client->flags & I2C_M_TEN;
	msg.flags |= I2C_M_RD;
	msg.len = count;
	msg.buf = buf;

	ret = i2c_transfer(adap, &msg, 1);  /* (1)调用 adapter 中的 master_xfer 函数 */

	/*
	 * If everything went ok (i.e. 1 msg received), return #bytes received,
	 * else error code.
	 */
	return (ret == 1) ? count : ret;
}

对 (1) 中 adapter 中的 master_xfer 指针的赋值在 busses/s3c2410.c 中
subsys_initcall(i2c_adap_s3c_init);
--> i2c_adap_s3c_init{platform_driver_register(&s3c24xx_i2c_driver);}
--> s3c24xx_i2c_driver = {.probe = s3c24xx_i2c_probe,}
--> s3c24xx_i2c_probe{i2c->adap.algo = &s3c24xx_i2c_algorithm;}
--> s3c24xx_i2c_algorithm{.master_xfer= s3c24xx_i2c_xfer,}
--> s3c24xx_i2c_xfer(struct i2c_adapter *adap,
struct i2c_msg *msgs, int num)
--> s3c24xx_i2c_doxfer(i2c, msgs, num);
--> s3c24xx_i2c_enable_irq(i2c); s3c24xx_i2c_message_start(i2c, msgs);
timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);/* 阻塞在这里，直到 msg_num = 0，或者超过 5s */

这张图可以看到，当接收，或者发送完一个字节在ack后边会产生一个中断
在probe中有申请中断
s3c24xx_i2c_probe(struct platform_device *pdev){ret = request_irq(i2c->irq, s3c24xx_i2c_irq, 0,
dev_name(&pdev->dev), i2c);}
--> s3c24xx_i2c_irq(int irqno, void *dev_id){i2c_s3c_irq_nextbyte(i2c, status);}
--> i2c_s3c_irq_nextbyte{switch (i2c->state)
{
case STATE_STOP:
case STATE_START:
case STATE_WRITE:
byte = i2c->msg->buf[i2c->msg_ptr++];
writeb(byte, i2c->regs + S3C2410_IICDS);
case STATE_READ:
byte = readb(i2c->regs + S3C2410_IICDS);
i2c->msg->buf[i2c->msg_ptr++] = byte;
}}
至此，数据发送的整个过程就全说完

3.3 单个 msg 的写 (.write)

static ssize_t i2cdev_write(struct file *file, const char __user *buf,
		size_t count, loff_t *offset)
{
	int ret;
	char *tmp;
	struct i2c_client *client = file->private_data;

	if (count > 8192)
		count = 8192;

	tmp = memdup_user(buf, count);
	if (IS_ERR(tmp))
		return PTR_ERR(tmp);

	pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
		iminor(file->f_path.dentry->d_inode), count);

	ret = i2c_master_send(client, tmp, count);  /* 发送一个 count 字节的 msg */
	kfree(tmp);
	return ret;
}

3.4 给用户层提供的控制 ioctl (.unlocked_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:
		/* NOTE:  devices set up to work with "new style" drivers
		 * can't use I2C_SLAVE, even when the device node is not
		 * bound to a driver.  Only I2C_SLAVE_FORCE will work.
		 *
		 * Setting the PEC flag here won't affect kernel drivers,
		 * which will be using the i2c_client node registered with
		 * the driver model core.  Likewise, when that client has
		 * the PEC flag already set, the i2c-dev driver won't see
		 * (or use) this setting.
		 */
		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:
		if (arg)
			client->flags |= I2C_CLIENT_PEC;
		else
			client->flags &= ~I2C_CLIENT_PEC;
		return 0;
	case I2C_FUNCS:
		funcs = i2c_get_functionality(client->adapter);
		return put_user(funcs, (unsigned long __user *)arg);

	case I2C_RDWR:
		return i2cdev_ioctl_rdrw(client, arg);  /* 实现 多个 msg 的读写 */

	case I2C_SMBUS:
		return i2cdev_ioctl_smbus(client, arg);

	case I2C_RETRIES:
		client->adapter->retries = arg;
		break;
	case I2C_TIMEOUT:
		/* 单位是 10ms. */
		client->adapter->timeout = msecs_to_jiffies(arg * 10);
		break;
	default:
		return -ENOTTY;
	}
	return 0;
}

3.5 多个msg的读写

static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
		unsigned long arg)
{
	struct i2c_rdwr_ioctl_data rdwr_arg;  /* (1)应用程序要想发送多个msg需要用到的结构体 */
	struct i2c_msg *rdwr_pa;
	u8 __user **data_ptrs;
	int i, res;

	if (copy_from_user(&rdwr_arg,
			   (struct i2c_rdwr_ioctl_data __user *)arg,
			   sizeof(rdwr_arg)))  /* (2)从用户空间传给内核空间 */
		return -EFAULT;

	/* 限制一次发送的 msg 的最大的个数是 42 */
	if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
		return -EINVAL;

	rdwr_pa = memdup_user(rdwr_arg.msgs,
			      rdwr_arg.nmsgs * sizeof(struct i2c_msg));  /* (3)取出 rdwr_arg 中的 msg */
	if (IS_ERR(rdwr_pa))
		return PTR_ERR(rdwr_pa);

	data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);
	if (data_ptrs == NULL) {
		kfree(rdwr_pa);
		return -ENOMEM;
	}

	res = 0;
	for (i = 0; i < rdwr_arg.nmsgs; i++) {
		/* Limit the size of the message to a sane amount;
		 * and don't let length change either. */
		if ((rdwr_pa[i].len > 8192) ||
		    (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
			res = -EINVAL;
			break;
		}
		data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf;
		rdwr_pa[i].buf = memdup_user(data_ptrs[i], rdwr_pa[i].len);
		if (IS_ERR(rdwr_pa[i].buf)) {
			res = PTR_ERR(rdwr_pa[i].buf);
			break;
		}
	}
	if (res < 0) {
		int j;
		for (j = 0; j < i; ++j)
			kfree(rdwr_pa[j].buf);
		kfree(data_ptrs);
		kfree(rdwr_pa);
		return res;
	}

	res = i2c_transfer(client->adapter, rdwr_pa, rdwr_arg.nmsgs);  /* (4)发送 nmsgs 个 msg */
	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);
	}
	kfree(data_ptrs);
	kfree(rdwr_pa);
	return res;
}

(1)的结构体 i2c_rdwr_ioctl_data
需要包含头文件 <i2c-dev.h>

struct i2c_rdwr_ioctl_data {
	struct i2c_msg __user *msgs; /* i2c_msgs 指针 */
	__u32 nmsgs;                 /* i2c_msgs 的个数 */
};

4. 用户写一个i2c驱动需要做的：

包含头文件： <linux/i2c.h><linux/i2c-dev.h>
从设备的地址需要右移一位
msg.flags = 0 是写，msg.flags =I2C_M_RD 是读
打开的i2c的设备是 open("/dev/i2c-0",O_RDWR); (需要先查看/dev 是不是有，如果没有，需要内核去支持 i2c 驱动)