Linux的I2C子系统

Bertha 。 2022-01-27 04:41 251阅读 0赞

原文网址：[Linux的I2C子系统\_IT利刃出鞘的博客-CSDN博客][Linux_I2C_IT_-CSDN]

# i2c\_adapter、i2c\_client等结构体分析 #

## 结构体之间的包含关系 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70][]

## i2c\_adapter结构体 ##

**i2c\_adapter的重要成员**  
struct i2c\_algorithm \*algo // 主控的数据传输的算法  
struct device dev // 主控分配的device结构体，可以通过dev获得i2c\_adapter等操作。  
int nr // 适配器编号，即：i2c通道编号。驱动可以通过这个编号获得i2c\_adapter  
**i2c\_adapter的内存分配**  
在主控程序的probe函数中会分配i2c\_adapter的内存  
**i2c\_adapter的使用**  
驱动可以直接通过i2c\_get\_adapter函数，以adapter编号为参数获得i2c\_adapter结构体，进而调用其相关函数完成数据传输。

注意：  
i2c\_get\_adapter函数会调用idr\_find(&i2c\_adapter\_idr, nr)；  
i2c\_add\_numbered\_adapter和i2c\_add\_adapter函数中都会调用idr\_alloc向i2c\_adapter添加adapter i2c\_get\_adapter；  
调用后要使用i2c\_put\_adapter释放掉adapter。

## i2c\_client结构体 ##

**i2c\_client的重要成员**  
unsigned short addr // 外设的地址（7bit）  
struct i2c\_adapter \*adapter // 本外设所关联的主控适配器  
struct device dev // device结构体

**i2c\_client的内存分配和使用  
（1）i2c-dev.c**   
open函数中分配i2c\_client结构体，设置adapter等成员，将file->private\_data指向本结构体；  
write,read,ioctl等函数中通过file->private\_data获得i2c\_client结构体，进行其他操作。  
**（2）外设驱动**   
分配i2c\_client结构体，设置其adapter等成员，驱动中可以将i2c\_client作为参数调用i2c\_transfer、i2c\_master\_send、i2c\_master\_recv等函数。  
**（3）主控、mux驱动层**  
如果主控设备（i2c\_add\_adapter）和mux驱动（i2c\_add\_driver）都存在，则最终会分配i2c\_client结构体，并将其挂到mux驱动(i2c\_driver)的clients链表上边。

# I2C系统调用过程 #

## 整体调用过程 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1][]

## 调用过程路径1 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 2][]

## 调用过程路径2 ##

# ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 3][]I2C底层框架 #

## 底层调用流程例1 ##

**（i2c-hisilicon.c）**

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 4][]底层调用流程例2 ##

**(i2c-hisi-v110.c)**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 5][]

## 底层调用流程例3 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 6][]

## 用到mux时的流程 ##

**（一般不用mux）**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 7][]

## 驱动程序使用流程 ##

**(ipc\_stm8.c)**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 8][]

**注意：**  
 i2c\_put\_adapter最好在初始化或者打开时 进行，不能放在module\_exit修饰的退出函数中。如果放在了module\_exit函数修饰的  
出函 数中，会导致rmmod时失败。  
原因：i2c\_get\_adapter会调用 try\_module\_get函数使i2c\_adapter使用计数加一， rmmod函数会先检查模块使用计数，再调用自己 定义的函数，如果i2c\_put\_adapter在退出函数中， 那么在rmmod检查时使用计数还是1，会导致 rmmod失败，无法卸载。

## mux驱动流程 ##

**（一般不用mux）**

**（pca9541.c）**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 9][]

# ak4954操作流程 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 10][]

# 示例源码（应用调用控制器） #

#include <unistd.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <errno.h>
    #include <sys/ioctl.h>
    #include <sys/mman.h>
    #include <sys/stat.h>
    #include <sys/types.h>
    #include <linux/types.h>
    #include <linux/i2c.h>
    #include <linux/i2c-dev.h>
    
    #define I2C_DEV	"/dev/i2c-1"
    #define MEM_DEV	"/dev/mem"
    #define PAGE_SIZE_MASK 	0xfffff000
    #define PAGE_SIZE	4096
    
    static int g_fd = -1;
    static int g_slave_addr;
    struct i2c_rdwr_ioctl_data g_i2c_data;
    
    static u8 g_i2c_addr[] = {
    	0x12,0x13,0x14,0x15,0x16
    };
    
    static u8 g_i2c_reg_val[] = {
    	0x08,0x05,0x11,0x03,0x30
    };
    
    int test_i2c_write(unsigned short reg, 
    	unsigned char addr_byte_num,unsigned char val)
    {
    	unsigned char buf[4];
    	int ret;
    
    	g_i2c_data.nmsgs 	= 1;
    
    	buf[0] = reg & 0xff;
    	buf[1] = val;
    	(g_i2c_data.msgs[0]).len =  2;
    	(g_i2c_data.msgs[0]).addr  = g_slave_addr;
    	(g_i2c_data.msgs[0]).buf   = buf;
    	(g_i2c_data.msgs[0]).flags = 0;
    
    	ret = ioctl(g_fd, I2C_RDWR, &g_i2c_data);
    	if(ret < 0) {
    		printf("i2c ioctl error(write)\n");
    		return -1;
    	}
    
    	return 0;
    }
    
    int test_i2c_read(unsigned short reg, 
    	unsigned char addr_byte_num,unsigned char *val)
    {
    	int ret;
    	unsigned char reg_buf[4] = {0};
    	unsigned char val_buf[4] = {0};
    
    	if(addr_byte_num == 2) {
    		reg_buf[0] = (reg >> 8) & 0xFF;
    		reg_buf[1] = reg & 0xFF;
    	} else if(addr_byte_num == 1){
    		reg_buf[0] = reg & 0xff;
    	}
    
    	(g_i2c_data.msgs[0]).len = addr_byte_num;  
    	(g_i2c_data.msgs[0]).addr = g_slave_addr;
    	(g_i2c_data.msgs[0]).flags = 0;
    	(g_i2c_data.msgs[0]).buf = reg_buf;
    	
    	(g_i2c_data.msgs[1]).len = 1; 
    	(g_i2c_data.msgs[1]).addr = g_slave_addr;
    	(g_i2c_data.msgs[1]).flags = I2C_M_RD;
    	(g_i2c_data.msgs[1]).buf = val_buf;
    
    	g_i2c_data.nmsgs	= 2;
    	
    	ret = ioctl(g_fd, I2C_RDWR, &g_i2c_data);
    	if(ret < 0) {
    		printf("i2c ioctl error(read)\n");
    		return -1;
    	}
    			
    	*val = val_buf[0];
    
    	return 0;
    }
    
    int test_i2c_init(void)
    {
    	int ret = -1;
    
    	g_fd = open(I2C_DEV, O_RDWR, 0);
    	if(g_fd < 0) {
    		printf("open %s error\n",I2C_DEV);
    		return -1;
    	}
    
    	ret = ioctl(g_fd, I2C_TENBIT, 0);
    	if(ret < 0) {
    		printf("set 7 bit error\n");
    		goto out;
    	}
    
    	ret = ioctl(g_fd, I2C_SLAVE_FORCE, g_slave_addr);
    	if (ret < 0)
    	{
    		printf("set slave address err!\n");
    		goto out;
    	}
    
    	g_i2c_data.msgs = (struct i2c_msg *)malloc(g_i2c_data.nmsgs * sizeof(struct i2c_msg));
    	if(g_i2c_data.msgs == NULL) {
    		ret = -1;
    		goto out;
    	}
    
    	return 0;
    out:
    	if(g_fd > 0) 
    		close(g_fd);
    
    	if(g_i2c_data.msgs != NULL) 
    		free(g_i2c_data.msgs);
    	return ret;
    }
    
    
    static void *memmap(unsigned long phy_addr)
    {
    	int memfd = -1;
    	unsigned long phy_addr_in_page, page_diff;
    	unsigned long size_in_page = PAGE_SIZE;
    	void *addr = NULL;
    
    	memfd = open (MEM_DEV, O_RDWR | O_SYNC);
    	if (memfd < 0) {
    		printf("memmap():open %s error!\n", MEM_DEV);
    		return NULL;
    	}
    
    	phy_addr_in_page = phy_addr & PAGE_SIZE_MASK;
    	page_diff = phy_addr - phy_addr_in_page;
    
    	addr = mmap ((void *)0, size_in_page, PROT_READ|PROT_WRITE, MAP_SHARED, memfd, phy_addr_in_page);
    	if (addr == MAP_FAILED) {
    		printf("memmap():mmap @ 0x%lx error\n", phy_addr_in_page);
    		close(memfd);
    		return NULL;
    	}
    
    	if(memfd > 0) 
    		close(memfd);
    
    	return (void *)(addr + page_diff);
    }
    
    
    int write_reg(u32 phy_addr, u32 value)
    {
    	void *vir_addr  = NULL;
    	vir_addr = memmap(phy_addr);
    	if(vir_addr == NULL) {
    		return -1;
    	}
    
    	*(unsigned int *)vir_addr = value;
    
    	return 0;
    }
    
    int read_reg(u32 phy_addr, u32 *value)
    {
    	void  *vir_addr = NULL;
    	vir_addr = memmap(phy_addr);
    	if(vir_addr == NULL) {
    		return -1;
    	}
    
    	*value = *(unsigned int *)vir_addr;
    
    	return 0;
    }
    
    void peripheral_reset(void)
    {
    	unsigned int val;
    	
    	/* reset */
    	read_reg(0x10200000, &val);
    	val &= ~(0x1 << 0);
    	write_reg(0x10200000, val);
    
    	usleep(10000);
    	
    	val |= (0x1 << 0);
    	write_reg(0x10200000, val);
    }
    
    static void memcmp_print(const void * src, const void * dest, unsigned int cnt)
    {
    	unsigned int i = 0, diff_index = 0, diff_flag = 0;
    	const unsigned char *buf1, *buf2;
    
    	if(!src || !dest){
    		printf("address is NULL\n");
    		return;
    	}
    	
    	for(i = 0, buf1 = src, buf2 = dest; i < cnt; i++){
    		if(*(buf1 + i) != *(buf2 + i)){
    			diff_flag  = 1;
    			diff_index = i;
    			break;
    		}
    	}
    	
    	if(diff_flag){
    		printf("Compare result : error\n"
    					"The first difference is : \n"
    					"src[%u]  = %#x\n"
    					"dest[%u] = %#x\n",
    					diff_index, *(buf1 + diff_index),
    					diff_index, *(buf2 + diff_index)
    					);
    	}else{
    		printf("Compare result : ok\n");
    	}
    }
    
    
    int main(int argc, char *argv[])
    {
    	int i = 0, ret = -1;
    	unsigned char r_buf[5] = {0};
    
    	g_slave_addr = 0x29;
    
    	peripheral_reset();
    	test_i2c_init();
    	
    	for(i = 0; i < sizeof(g_i2c_addr)/sizeof(g_i2c_addr[0]); i++){
    		test_i2c_write( g_i2c_addr[i], 1, g_i2c_reg_val[i]);
    	}
    	
    	memset(r_buf, 0, 5);
    	for(i = 0; i < sizeof(g_i2c_addr)/sizeof(g_i2c_addr[0]); i++){
    		test_i2c_read( g_i2c_addr[i], 1, &r_buf[i]);
    	}
    	memcmp_print(g_i2c_reg_val, r_buf, 5);
    	
    	close(g_fd);
    	free(g_i2c_data.msgs);
    	return 0;
    }

> --------------------

[Linux_I2C_IT_-CSDN]: https://knife.blog.csdn.net/article/details/90544802
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70]: /images/20220127/9f43094a034848f89d8ad321f56ae4c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1]: /images/20220127/faf001b8fe46411d82c7ccde142675e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 2]: /images/20220127/147832c672bb4d2e9076336fcd84b788.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 3]: /images/20220127/562472e2ff41445dbcf8ca82f2251a3d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 4]: /images/20220127/5c883e3b85bb4ed1b83cc6a21391b99a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 5]: /images/20220127/d80819c0f42b44949e2ec7bef8c68be6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 6]: /images/20220127/4a3890cc0cb84a9b8a8503287c7c5a03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 7]: /images/20220127/58c96d2aa5aa46b0a1f64dc78fd8f8f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 8]: /images/20220127/06df03bc83c84e3ca8702199a30a3bd9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 9]: /images/20220127/96b2faf093254f4ab7d880268ad71bc9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 10]: /images/20220127/8d3823e6327a40428844b80295be60bc.png