计算机通信协议之--I2C

xiangerersheng

2244人浏览 · 2025-07-07 09:54:53

xiangerersheng · 2025-07-07 09:54:53 发布

计算机通信协议之I2C(Inter-Integrated Circuit)

一、简介：

I2C（Inter-Integrated Circuit）是一种同步、串行、半双工通信协议，由飞利浦（现恩智浦）于1982年设计，主要用于短距离设备间通信。其核心特点是仅需两根信号线即可实现多主机多从机通信。

在这里插入图片描述

硬件组成：

SDA：双向数据线，传输实际数据；
SCL：由主机控制的时钟线，同步数据收发；
上拉电阻：一般为4.7kΩ，确保空闲时为高电平

通信特点：

地址寻址：每个从设备有唯一的7位或10位的地址，支持同一总线挂载多个从机，主设备通过从机的地址来进行主从之间通信；
速度模式：标准（100kbps）、快速（400kbps）、高速（3.4Mkbps）;
多主机支持：通过仲裁机制避免总线冲突；

主模式/从模式:
标准的I2C通讯只有一个主机，其他都为从机，但是现在大部分的MCU的I2C都包含主模式（Master），从模式（Slave）两种。

主模式：时钟生成、起始位/终止位停止；
从模式：一般是MCU作为设备被更高级的嵌入式设备访问如树莓派等，设置为从模式，从模式下，主控制器将作为从机可以被访问。

数据帧格式：

起始位：SCL为高电平时，SDA从高变低；
地址位：7/10位从机地址+1位读写（1为写、0为读）；
应答位：ACK/NACK，每字节后接收方发送确认信号，通常主机发送完8位数据后，会将SDA设置为输入状态，从机在下一个时钟信号周期内，通过将SDA拉低，来表示应答信号；
数据位：8位数据+应答位（可连续传输多个数据位）；
停止位：SCL为高电平时，SDA从低变高；

典型应用场景：

传感器数据读取（如温度传感器）
EEPROM存储器读写
显示屏控制（如OLED）
微控制器与外设通信

二、工作时序

数据有效性：SCL在高电平时，SDA有效；反之，则无效；
因此SDA上的数据变化只能发生在SCL为低电平之间；
在这里插入图片描述
I2C写时序：

1）首先，SCL为高电平时，主机将SDA从高变低，发送开始信号；
2）发送从机设备地址，如果从机地址为7位，则发送8位地址位，高7位为地址位，最后一位为读写位；（主机发送地址位后，所有从机设备都会接收该数据，然后检测是否是自身地址，如果是，则做出响应信号ACK）
3）主机丢失SDA的控制权，从机在SCL为高电平时，从机将SDA信号线从高位变为地位，来回复应答信号ACK；
4）主机重新发送开始信号；
5）主机发送要写入的寄存器地址；
6）从机发送应答信号；
7）主机发送要写入寄存器的数据；
8）从机发送应答信号；
9）停止信号；

I2C读数据：
读数据要比写数据稍微复杂一些，主要分为4个步骤，第一步发送从机地址，第二步发送要读取的寄存器地址，第三步重新发送从机地址，最后一步是I2C从机输出读取的寄存器地址；
在这里插入图片描述

1）首先主机发送开始信号；
2）主机发送从机地址，因为这一次是向从机发送信号，所以读写控制位为写；
3）从机应答信号；
4）重新发送START信号；
5）发送读寄存器地址；
6）从机应答信号；
7）主机重新发送从机地址，此时，读写控制位为读(0);
8)从机发送ACK；
9）主机释放SDA控制权，从机发送ACK信号；
10）从机通过SDA信号线向主机传输数据；
11）主机接收到数据后，发送ACK信号；
12）主机发送NO ACK信号，表示读取完成，从机不需要发送信号；
13）主机发送STOP信号；

三、STM32 I2C通信实践

3.1 STM32 I2C相关寄存器介绍

寄存器	位数	相关功能
控制寄存器I2C_CR1	32	相关功能使能，如外设、中断、报警等
控制寄存器I2C_CR2	32	数据值设置，如起始、外设地址、应答等
时序寄存器I2C_TIMINGR	32	配置SCL的时序频率
中断、状态寄存器I2C_ISR	32	读取此时中断和外设的工作状态
接收数据寄存器I2C_RXDR	32	低八位储存着I2C总线接收到的数据字节
发送数据寄存器I2C_TXDR	低八位有效	保存待发送到I2C总线的数据字节

3.2 I2C裸机实验-I2C光照&接近传感器实验

开发环境：STM32IDECUBE
硬件资源：STM32、AP3216、LED灯、UATR、I2C5

3.3 资源配置

使用STM32IDE自带的MX来对开发板需要用到的资源以及时钟进行配置，配置过程如下：

首先对I2C5进行配置，包括配置一些产生，比如speed mode、speed Frequeny等；以及对两个引脚PA11、PA12，配置为开漏输出、上拉模式，如下：
这里，我们速度设置为快速模式（400kHZ）
对时钟频率进行设置，这里采用HSE作为时钟输入，最后I2C5上的时钟频率为104.5MHz：

2、逻辑驱动开发

接下来，我们就来实现简单的读取传感器数据的代码
首先，新建一个AP3216.h文件

/*
 * AP3216.h
 *
 *  Created on: Jul 4, 2025
 *      Author: Zhangshiyi
 */
#ifndef INC_AP3216_H_
#define INC_AP3216_H_

#include "i2c.h"
extern I2C_HandleTypeDef hi2c5;
#define AP3216_ADDR 0X3C

uint8_t ap3216_init(); //初始化
void ap3216_write_one_byte(uint8_t reg,uint8_t data); //写一个字节
uint8_t ap3216_read_one_byte(uint8_t reg);//读一个字节

void ap3216_read_data(uint16_t* ir,uint16_t* ps,uint16_t* als);
#endif /* INC_AP3216_H_ */

然后创建一个AP3216.c文件，首先初始化一下该传感器，主要包括I2C的一个初始化以及向传感器发送复位指令、状态指令等；

uint8_t ap3216_init(void){
	uint8_t temp=0;
	MX_I2C5_Init();
	ap3216_write_one_type(0x00,0x04);//复位ap3216
	HAL_Delay(50);
	ap3216_write_one_type(0x00,0x03);//开启ALS、PS、IR
	temp=ap3216_read_one_type(0x00);
	if(temp == 0x03){
		return 0;
	}
	else
		return -1;
	
}

接下来，实现一下接收/发送单个字节的逻辑，逻辑也比较简单，主要使用HAL库封装好的接口，来进行接收和发送：
**HAL_I2C_Master_Transmit()**这个函数，可以打开源代码看一下，其主要的实现逻辑就是发送单个字节到传感器寄存器的时序，包括开始信号、发送传感器地址、相应信号、发送寄存器地址、发送数据。

void ap3216_write_one_type(uint8_t reg,uint8_t data){
	uint8_t sent_data[2];
	sent_data[0] = reg;//寄存器地址
	sent_data[1] = data;//发送的数据
	HAL_I2C_Master_Transmit(&hi2c5,AP3216_ADDR, sent_data, 2, 1000);
	
}

uint8_t ap3216_read_one_type(uint8_t reg){
	uint8_t res;
	uint8_t senddata = reg;//发送数据
	//首先发送要读取的寄存器地址
	HAL_I2C_Master_Transmit(&hi2c5,AP3216_ADDR, &sent_data, 1, 1000);
	//读取数据
	HAL_I2C_Master_Receive(&hi2c5, AP3216_ADDR, &res, 1, 1000);
	return res;
}

最后，实现接收传感器数据的逻辑，因为我们设置的是三种模式都使能，所以要接收三种类型的数据，大家可以对照着传感器的寄存器表来编写：

void ap3216_read_data(uint16_t* ir,uint16_t* ps,uint16_t* als){
	uint8_t buf[6];
	for(int i=0;i<6;i++){
		buf[i] = ap3216_read_one_type(0x0A+i);
	}
	if(buf[0]&0x80){
		*ir = 0;
	}
	else
		*ir = ((uint16_t)buf[1] << 2) | (buf[0] & 0x03);
	
	//判断ps
	if(buf[4] & 0x40) *ps = 0;
	else
		*ps = ((uint16_t)(buf[5]&0x3F)<<4) |(buf[4]&0x0F);
	
	*als = ((uint16_t)buf[3] << 8) | buf[2];
}

AP3216传感器寄存器表(部分)：
在这里插入图片描述
当然，以上是硬件I2C代码的实现，也就是我们的板子上本身自带了I2C的总线及功能，如果没有的话，也可以进行软件模拟I2C的实现，这里大家有兴趣自行观看，可以帮助大家更深刻的了解I2C的通信协议以及过程的实现。

四、Linux下I2C的实际应用

还是上一章的传感器实验，这一章我们来学习一下如果上linux系统的话，如何使用I2C进行通信。

4.1 Linux I2C总线框架简介

Linux 内核开发者为了让驱动开发工程师在内核中方便的添加自己的 I2C 设备驱动程序，
方便大家更容易的在 linux 下驱动自己的 I2C 接口硬件，进而引入了 I2C 总线框架，我们一般也叫作 I2C 子系统， Linux 下 I2C 子系统总体框架如下所示：
在这里插入图片描述
1、应用层

提供用户空间访问 I²C 总线的接口：
- /dev/i2c-X：通过 i2c-dev 接口访问。
- sysfs 和 debugfs：用于调试和查看设备信息。

2、I2C核心（I2C Core）

管理I2C子系统的全局资源，包括注册和注销I2C适配器(I2C Adapter)、管理I2C设备，通过统一的I2C通信接口(如i2c_transfer())
核心数据结构：
struct i2c_adapter：表示一个 I²C 控制器。
struct i2c_client：表示一个 I²C 从设备。
struct i2c_driver：表示一个 I²C 设备驱动。
struct i2c_board_info：静态设备信息（旧式）。
struct i2c_device_id：设备 ID 匹配表。

3、I2C总线驱动(I2C adapter)

每个I2C控制器都对应一个适配器，主要负责：
- 实现底层硬件SCL、SDL的控制
- 执行一次或多次I2C通信传输

总线驱动一般芯片厂家都会编写的，不需要用户自己编写(除非是半导体公司上班，工作内容就是写适配器驱动的)

4、I2C设备驱动(I2C client driver)
每个 I²C 从设备（如传感器、OLED 屏幕）需要一个驱动来处理其特定功能。通常需要在设备树中动态注册设备。
设备驱动一般需要我们自己写，一般关注两个结构体：i2c_client和i2c_driver

1. i2c_client结构体
i2c_client 是 Linux I²C 子系统中的一个核心结构体，用于表示连接在 I²C 总线上的从设备（Slave Device）。它记录了与该从设备相关的各种信息，如地址、适配器、驱动匹配信息、私有数据等。

struct i2c_client {
    unsigned short flags;       /* 标志位 */
    unsigned short addr;        /* 从机地址（7位或10位）*/
    char name[I2C_NAME_SIZE];  /* 设备名称 */
    struct i2c_adapter *adapter;/* 指向所属的 I2C 适配器 */
    struct device dev;          /* 设备模型结构体 */
    int irq;                    /* 中断号 */
    struct list_head detected;  /* 链表节点，用于探测列表 */
    void *driver_data;          /* 私有数据，供驱动使用 */
};

i2c_driver结构体

struct i2c_driver {
    unsigned int class;

    /* 驱动方法 */
    int (*attach_adapter)(struct i2c_adapter *);
    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);
    int (*resume)(struct i2c_client *);

    /* 设备 ID 匹配表 */
    const struct i2c_device_id *id_table;

    /* 驱动信息 */
    struct device_driver driver;

    /* OF 匹配表（用于设备树） */
    const struct of_device_id *of_match_table;

    /* ACPI 匹配表 */
    const struct acpi_device_id *acpi_match_table;
};

首先需要在设备树中注册我们的I2C设备，该器件挂在i2c5总线接口上，因此我们需要在i2c5节点下创建一个子节点来描述Ap3216设备，如下：

&i2c5 {
	pinctrl-names = "default", "sleep";
	pinctrl-0 = <&i2c5_pins_a>;
	pinctrl-1 = <&i2c5_pins_sleep_a>;
	status = "okay";

	ap3216c@1e {
		compatible = " alientek,ap3216c"; //属性值
		reg = <0x1e>;//器件地址
};
}；

设置完后，编写AP3216驱动，首先是.h文件
主要就是定义各种寄存器地址

#define AP3216C_ADDR    	0X1E	/* AP3216C器件地址  */

/* AP3316C寄存器 */
#define AP3216C_SYSTEMCONG	0x00	/* 配置寄存器       */
#define AP3216C_INTSTATUS	0X01	/* 中断状态寄存器   */
#define AP3216C_INTCLEAR	0X02	/* 中断清除寄存器   */
#define AP3216C_IRDATALOW	0x0A	/* IR数据低字节     */
#define AP3216C_IRDATAHIGH	0x0B	/* IR数据高字节     */
#define AP3216C_ALSDATALOW	0x0C	/* ALS数据低字节    */
#define AP3216C_ALSDATAHIGH	0X0D	/* ALS数据高字节    */
#define AP3216C_PSDATALOW	0X0E	/* PS数据低字节     */
#define AP3216C_PSDATAHIGH	0X0F	/* PS数据高字节     */

#endif

.c文件

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/i2c.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include "ap3216creg.h"

#define AP3216C_CNT	1
#define AP3216C_NAME	"ap3216c"

struct ap3216c_dev {
	struct i2c_client *client;	/* i2c 设备 */
	dev_t devid;			/* 设备号 	 */
	struct cdev cdev;		/* cdev 	*/
	struct class *class;	/* 类 		*/
	struct device *device;	/* 设备 	 */
	struct device_node	*nd; /* 设备节点 */
	unsigned short ir, als, ps;		/* 三个光传感器数据 */
};

/*
 * @description	: 从ap3216c读取多个寄存器数据
 * @param - dev:  ap3216c设备
 * @param - reg:  要读取的寄存器首地址
 * @param - val:  读取到的数据
 * @param - len:  要读取的数据长度
 * @return 		: 操作结果
 */
static int ap3216c_read_regs(struct ap3216c_dev *dev, u8 reg, void *val, int len)
{
	int ret;
	struct i2c_msg msg[2];
	struct i2c_client *client = (struct i2c_client *)dev->client;

	/* msg[0]为发送要读取的首地址 */
	msg[0].addr = client->addr;			/* ap3216c地址 */
	msg[0].flags = 0;					/* 标记为发送数据 */
	msg[0].buf = &reg;					/* 读取的首地址 */
	msg[0].len = 1;						/* reg长度*/

	/* msg[1]读取数据 */
	msg[1].addr = client->addr;			/* ap3216c地址 */
	msg[1].flags = I2C_M_RD;			/* 标记为读取数据*/
	msg[1].buf = val;					/* 读取数据缓冲区 */
	msg[1].len = len;					/* 要读取的数据长度*/

	ret = i2c_transfer(client->adapter, msg, 2);
	if(ret == 2) {
		ret = 0;
	} else {
		printk("i2c rd failed=%d reg=%06x len=%d\n",ret, reg, len);
		ret = -EREMOTEIO;
	}
	return ret;
}

/*
 * @description	: 向ap3216c多个寄存器写入数据
 * @param - dev:  ap3216c设备
 * @param - reg:  要写入的寄存器首地址
 * @param - val:  要写入的数据缓冲区
 * @param - len:  要写入的数据长度
 * @return 	  :   操作结果
 */
static s32 ap3216c_write_regs(struct ap3216c_dev *dev, u8 reg, u8 *buf, u8 len)
{
	u8 b[256];
	struct i2c_msg msg;
	struct i2c_client *client = (struct i2c_client *)dev->client;
	
	b[0] = reg;					/* 寄存器首地址 */
	memcpy(&b[1],buf,len);		/* 将要写入的数据拷贝到数组b里面 */
		
	msg.addr = client->addr;	/* ap3216c地址 */
	msg.flags = 0;				/* 标记为写数据 */

	msg.buf = b;				/* 要写入的数据缓冲区 */
	msg.len = len + 1;			/* 要写入的数据长度 */

	return i2c_transfer(client->adapter, &msg, 1);
}

/*
 * @description	: 读取ap3216c指定寄存器值，读取一个寄存器
 * @param - dev:  ap3216c设备
 * @param - reg:  要读取的寄存器
 * @return 	  :   读取到的寄存器值
 */
static unsigned char ap3216c_read_reg(struct ap3216c_dev *dev, u8 reg)
{
	u8 data = 0;

	ap3216c_read_regs(dev, reg, &data, 1);
	return data;
}

/*
 * @description	: 向ap3216c指定寄存器写入指定的值，写一个寄存器
 * @param - dev:  ap3216c设备
 * @param - reg:  要写的寄存器
 * @param - data: 要写入的值
 * @return   :    无
 */
static void ap3216c_write_reg(struct ap3216c_dev *dev, u8 reg, u8 data)
{
	u8 buf = 0;
	buf = data;
	ap3216c_write_regs(dev, reg, &buf, 1);
}

/*
 * @description	: 读取AP3216C的数据，读取原始数据，包括ALS,PS和IR, 注意！
 *				: 如果同时打开ALS,IR+PS的话两次数据读取的时间间隔要大于112.5ms
 * @param - ir	: ir数据
 * @param - ps 	: ps数据
 * @param - ps 	: als数据 
 * @return 		: 无。
 */
void ap3216c_readdata(struct ap3216c_dev *dev)
{
	unsigned char i =0;
    unsigned char buf[6];
	
	/* 循环读取所有传感器数据 */
    for(i = 0; i < 6; i++) {
        buf[i] = ap3216c_read_reg(dev, AP3216C_IRDATALOW + i);	
    }

    if(buf[0] & 0X80) 	/* IR_OF位为1,则数据无效 */
		dev->ir = 0;					
	else 				/* 读取IR传感器的数据   		*/
		dev->ir = ((unsigned short)buf[1] << 2) | (buf[0] & 0X03); 			
	
	dev->als = ((unsigned short)buf[3] << 8) | buf[2];	/* 读取ALS传感器的数据 			 */  
	
    if(buf[4] & 0x40)	/* IR_OF位为1,则数据无效 			*/
		dev->ps = 0;    													
	else 				/* 读取PS传感器的数据    */
		dev->ps = ((unsigned short)(buf[5] & 0X3F) << 4) | (buf[4] & 0X0F); 
}

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int ap3216c_open(struct inode *inode, struct file *filp)
{
	/* 从file结构体获取cdev的指针，在根据cdev获取ap3216c_dev结构体的首地址 */
	struct cdev *cdev = filp->f_path.dentry->d_inode->i_cdev;
	struct ap3216c_dev *ap3216cdev = container_of(cdev, struct ap3216c_dev, cdev);

	/* 初始化AP3216C */
	ap3216c_write_reg(ap3216cdev, AP3216C_SYSTEMCONG, 0x04);		/* 复位AP3216C 			*/
	mdelay(50);														/* AP3216C复位最少10ms 	*/
	ap3216c_write_reg(ap3216cdev, AP3216C_SYSTEMCONG, 0X03);		/* 开启ALS、PS+IR 		*/
	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t ap3216c_read(struct file *filp, char __user *buf, size_t cnt, loff_t *off)
{
	short data[3];
	long err = 0;

	struct cdev *cdev = filp->f_path.dentry->d_inode->i_cdev;
	struct ap3216c_dev *dev = container_of(cdev, struct ap3216c_dev, cdev);
	
	ap3216c_readdata(dev);

	data[0] = dev->ir;
	data[1] = dev->als;
	data[2] = dev->ps;
	err = copy_to_user(buf, data, sizeof(data));
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int ap3216c_release(struct inode *inode, struct file *filp)
{
	return 0;
}

/* AP3216C操作函数 */
static const struct file_operations ap3216c_ops = {
	.owner = THIS_MODULE,
	.open = ap3216c_open,
	.read = ap3216c_read,
	.release = ap3216c_release,
};

 /*
  * @description     : i2c驱动的probe函数，当驱动与
  *                    设备匹配以后此函数就会执行
  * @param - client  : i2c设备
  * @param - id      : i2c设备ID
  * @return          : 0，成功;其他负值,失败
  */
static int ap3216c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	int ret;
	struct ap3216c_dev *ap3216cdev;
	
	/* */
	ap3216cdev = devm_kzalloc(&client->dev, sizeof(*ap3216cdev), GFP_KERNEL);
	if(!ap3216cdev)
		return -ENOMEM;
		
	/* 注册字符设备驱动 */
	/* 1、创建设备号 */
	ret = alloc_chrdev_region(&ap3216cdev->devid, 0, AP3216C_CNT, AP3216C_NAME);
	if(ret < 0) {
		pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", AP3216C_NAME, ret);
		return -ENOMEM;
	}

	/* 2、初始化cdev */
	ap3216cdev->cdev.owner = THIS_MODULE;
	cdev_init(&ap3216cdev->cdev, &ap3216c_ops);
	
	/* 3、添加一个cdev */
	ret = cdev_add(&ap3216cdev->cdev, ap3216cdev->devid, AP3216C_CNT);
	if(ret < 0) {
		goto del_unregister;
	}
	
	/* 4、创建类 */
	ap3216cdev->class = class_create(THIS_MODULE, AP3216C_NAME);
	if (IS_ERR(ap3216cdev->class)) {
		goto del_cdev;
	}

	/* 5、创建设备 */
	ap3216cdev->device = device_create(ap3216cdev->class, NULL, ap3216cdev->devid, NULL, AP3216C_NAME);
	if (IS_ERR(ap3216cdev->device)) {
		goto destroy_class;
	}
	ap3216cdev->client = client;
	/* 保存ap3216cdev结构体 */
	i2c_set_clientdata(client,ap3216cdev);

	return 0;
destroy_class:
	device_destroy(ap3216cdev->class, ap3216cdev->devid);
del_cdev:
	cdev_del(&ap3216cdev->cdev);
del_unregister:
	unregister_chrdev_region(ap3216cdev->devid, AP3216C_CNT);
	return -EIO;
}

/*
 * @description     : i2c驱动的remove函数，移除i2c驱动的时候此函数会执行
 * @param - client 	: i2c设备
 * @return          : 0，成功;其他负值,失败
 */
static int ap3216c_remove(struct i2c_client *client)
{
	struct ap3216c_dev *ap3216cdev = i2c_get_clientdata(client);
	/* 注销字符设备驱动 */
	/* 1、删除cdev */
	cdev_del(&ap3216cdev->cdev);
	/* 2、注销设备号 */
	unregister_chrdev_region(ap3216cdev->devid, AP3216C_CNT); 
	/* 3、注销设备 */
	device_destroy(ap3216cdev->class, ap3216cdev->devid);
	/* 4、注销类 */
	class_destroy(ap3216cdev->class); 
	return 0;
}

/* 传统匹配方式ID列表 */
static const struct i2c_device_id ap3216c_id[] = {
	{"alientek,ap3216c", 0},  
	{}
};

/* 设备树匹配列表 */
static const struct of_device_id ap3216c_of_match[] = {
	{ .compatible = "alientek,ap3216c" },
	{ /* Sentinel */ }
};

/* i2c驱动结构体 */	
static struct i2c_driver ap3216c_driver = {
	.probe = ap3216c_probe,
	.remove = ap3216c_remove,
	.driver = {
			.owner = THIS_MODULE,
		   	.name = "ap3216c",
		   	.of_match_table = ap3216c_of_match, 
		   },
	.id_table = ap3216c_id,
};
		   
/*
 * @description	: 驱动入口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init ap3216c_init(void)
{
	int ret = 0;

	ret = i2c_add_driver(&ap3216c_driver);
	return ret;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit ap3216c_exit(void)
{
	i2c_del_driver(&ap3216c_driver);
}

/* module_i2c_driver(ap3216c_driver) */

module_init(ap3216c_init);
module_exit(ap3216c_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ALIENTEK");
MODULE_INFO(intree, "Y");