#导入Word文档图片# Linux下I2C驱动架构全面分析​

层名​

描述​

I2C设备驱动层​

真正实现具体设备的时序的代码。使用核心层提供API接口写，有特定编写框架。​

I2C核心层​

提供了I2C总线驱动和设备驱动的注册、注销方法、I2C通信方法(”algorithm”)，与具体适配器无关的代码以及探测设备，检测设备地址的上层代码等。​

提供了设备驱动层和适配器驱动层需要API接口，以及实现收发数据管理功能。起到一个连接上下两的作用。​

I2C适配器驱动层​

对I2C硬件体系结构中适配器端的实现。​

适配器可由CPU控制，甚至可以直接集成在CPU内部。​

通俗说就是直接操作硬件上IIC控制的的驱动代码。真正的实现IIC数据收发。​

文件​

功能描述​

i2c-core.c​

这个文件实现了I2C核心的功能以及/proc/bus/i2c*接口。​

i2c-dev.c​

实现了I2C适配器设备文件的功能，每一个I2C适配器都被分配一个设备。通过适配器访设备时的主设备号都为89，次设备号为0-255。​

I2c-dev.c并没有针对特定的设备而设计，只是提供了通用的read(),write(),和ioctl()等接口，应用层可以借用这些接口访问挂接在适配器上的I2C设备的存储空间或寄存器，并控制I2C设备的工作方式。​

busses文件夹​

这个文件中包含了一些I2C总线的驱动，如针对S3C2410，S3C2440，S3C6410等处理器的I2C控制器驱动为i2c-s3c2410.c。​

algos文件夹​

实现了一些I2C总线适配器的algorithm。​

[root@WBYQ /]# ls /dev/i2c-* -l​

crw-rw---- 1 root root 89, 0 Jul 12 01:30 /dev/i2c-0​

crw-rw---- 1 root root 89, 1 Jul 12 01:30 /dev/i2c-1​

crw-rw---- 1 root root 89, 2 Jul 12 01:30 /dev/i2c-2​

crw-rw---- 1 root root 89, 3 Jul 12 01:30 /dev/i2c-3​

crw-rw---- 1 root root 89, 7 Jul 12 01:30 /dev/i2c-7​

crw-rw---- 1 root root 89, 8 Jul 12 01:30 /dev/i2c-8​

[root@WBYQ /]#​

struct i2c_driver {​

unsigned int class;​

/* Notifies the driver that a new bus has appeared or is about to be​

* removed. You should avoid using this, it will be removed in a​

老接口，可能会消失，建议不要使用.​

*/​

int (*attach_adapter)(struct i2c_adapter *) __deprecated;​

int (*detach_adapter)(struct i2c_adapter *) __deprecated;​

/* 新的接口,用来替代上面两个接口,必须实现,功能类型平台模型的probe，remove*/​

int (*probe)(struct i2c_client *, const struct i2c_device_id *);​

int (*remove)(struct i2c_client *);​

/* driver model interfaces that don't relate to enumeration */​

void (*shutdown)(struct i2c_client *);​

int (*suspend)(struct i2c_client *, pm_message_t mesg);​

int (*resume)(struct i2c_client *);​

/* Alert callback, for example for the SMBus alert protocol.​

* The format and meaning of the data value depends on the protocol.​

* For the SMBus alert protocol, there is a single bit of data passed​

* as the alert response's low bit ("event flag").​

*/​

void (*alert)(struct i2c_client *, unsigned int data);​

/* a ioctl like command that can be used to perform specific functions​

* with the device.​

*/​

int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);​

struct device_driver driver;​

const struct i2c_device_id *id_table;​

/* Device detection callback for automatic device creation */​

int (*detect)(struct i2c_client *, struct i2c_board_info *);​

const unsigned short *address_list;​

struct list_head clients;​

};​

struct i2c_client {​

； 标志，比如说设备地址10位还是7位​

unsigned short addr; 低7位为芯片地址​

char name[I2C_NAME_SIZE];设备名称，随便,但是要和驱动层id_table相同​

struct i2c_adapter *adapter;依附的 i2c_adapter，它表示一个IIC控制器​

依附的i2c_driver​

设备结构体​

设备所使用的中断号​

链表头​

};​

int i2c_add_driver(struct i2c_driver *driver) ​

void i2c_del_driver(struct i2c_driver *driver)​

int i2c_master_send(struct i2c_client *client,​

const char *buf ,​

发送函数​

int i2c_master_recv(struct i2c_client *client, char *buf ,int count) ​

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)​

struct i2c_msg {​

__u16 addr;/* 这条消息是发送给谁*/​

__u16 flags; /* 消息额外的标志，可选择的值有以下宏*/​

#define I2C_M_TEN0x0010/* 表示目标器件地址是10位的 */​

#define I2C_M_RD0x0001/* 在从设备中读取数据 */​

/* 没有专门定义一个写的标志，默认是写，*/​

//以下标志使用不到​

#define I2C_M_NOSTART0x4000/* if I2C_FUNC_NOSTART */​

#define I2C_M_REV_DIR_ADDR0x2000/* if I2C_FUNC_PROTOCOL_MANGLING */​

#define I2C_M_IGNORE_NAK0x1000/* if I2C_FUNC_PROTOCOL_MANGLING */​

#define I2C_M_NO_RD_ACK0x0800/* if I2C_FUNC_PROTOCOL_MANGLING */​

#define I2C_M_RECV_LEN0x0400/* length will be first received byte */​

__u16 len;/* 传输的数据字节数量*/​

__u8 *buf;/* 接收/发送缓冲区*/​

};​

char subaddr = 10; //内部地址​

char data[100]={1,2,3};//等待发送的数据​

struct i2c_msg msgs[2]={​

[0]={​

.addr = EEPROM_DEVICE_ADDR,//EEPROM_DEVICE_ADDR器件地址 ​

.flags= 0 , //默认是写​

.len = 1,​

.buf =&subaddr​

},​

[1]={​

器件地址 ​

.flags= 0 ,​

.len = 2,​

.buf = data​

}, ​

};​

i2c_transfer(client->adapter,msgs,2);​

static int i2c_register_adapter(struct i2c_adapter *adap) //注册IIC适配器，该函数在下面两个函数里已经调用​

int i2c_add_adapter(struct i2c_adapter *adapter) //声明并注册i2c适配器，使用动态总线编号​

int i2c_add_numbered_adapter(struct i2c_adapter *adap) //声明并注册i2c适配器，使用静态总线编号​

struct i2c_adapter {​

struct module *owner;​

unsigned int class;允许探测的类 */​

const struct i2c_algorithm *algo; /*访问总线的函数接口*/​

void *algo_data;​

/* data fields that are valid for all devices*/​

struct rt_mutex bus_lock;​

int timeout;/*时间节拍*/​

int retries; /*重试*/​

struct device dev;/* the adapter device */​

int nr; /*总线编号*/​

char name[48]; /*总线名称*/​

struct completion dev_released;​

struct mutex userspace_clients_lock;​

struct list​

#include <linux/init.h>​

#include <linux/module.h>​

#include <linux/platform_device.h>​

#include <linux/i2c.h>​

#include <linux/gpio.h>​

#include <mach/gpio.h>​

#include <plat/gpio-cfg.h>​

static struct i2c_adapter adapter;​

/* 声明我们的i2c功能 */​

static u32 i2c_support(struct i2c_adapter *adap)​

{​

return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART |​

I2C_FUNC_PROTOCOL_MANGLING;​

}​

static int i2c_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,int num)​

{​

printk("设备地址:0x%X\n",msgs[0].addr);​

if(num==1) //写模式​

{​

printk("写模式:\n");​

printk("寄存器起始位置:%d\n",msgs[0].buf[0]);​

printk("写入的数据长度:%d\n",msgs[0].len-1);​

int i;​

printk("数据如下:");​

for(i=1;i<=msgs[0].len-1;i++)​

{​

printk("%d ",msgs[0].buf[i]);​

}​

printk("\n");​

}​

else if(num==2)//读模式​

{​

printk("读模式:\n");​

printk("寄存器起始位置:%d\n",msgs[0].buf[0]);​

printk("读取的数据长度:%d\n",msgs[1].len);​

int i;​

//给数据赋值,模拟数据读取​

for(i=0;i<msgs[1].len;i++)​

{​

msgs[1].buf[i]=i+66;​

}​

printk("\n");​

}​

return 0;​

}​

static const struct i2c_algorithm my_i2c_algorithm = {​

.master_xfer= i2c_master_xfer, //底层调用函数​

.functionality= i2c_support, //支持的功能声明​

};​

static int __init i2c_adapter_init(void)​

{​

strlcpy(adapter.name, "my_exynos_i2c", sizeof(adapter.name));​

adapter.owner = THIS_MODULE;​

adapter.algo = &my_i2c_algorithm; /*适配器对应的功能函数*/​

adapter.retries = 2;​

adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;​

if(i2c_add_adapter(&adapter)!=0)​

{​

printk("IIC适配器注册失败!\n");​

return 0;​

}​

printk("适配器注册的总线编号:%d\n",adapter.nr);​

printk("i2c_adapter_init!!\n");​

return 0;​

}​

static void __exit i2c_adapter_exit(void)​

{​

i2c_del_adapter(&adapter);​

printk(" i2c_adapter_exit!\n");​

}​

module_init(i2c_adapter_init);​

module_exit(i2c_adapter_exit);​

MODULE_LICENSE("GPL");​

int i2c_del_adapter(struct i2c_adapter *adap)​

struct i2c_adapter *i2c_get_adapter(int nr)​

s32 i2c_smbus_read_byte_data(const struct i2c_client *client,u8 command)：​

s32 i2c_smbus_write_byte_data(const struct i2c_client *client, ​

u8 command, u8 value)​

s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, ​

u8 command, ​

u8 length, ​

u8 *values)​

s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, ​

u8 command, ​

u8 length, ​

u8 *values)​

//编写器件ID列表​

static const struct i2c_device_id ft5x0x_id_table[] = {​

{ "ft5x0x", 0 },​

{},​

};​

MODULE_DEVICE_TABLE(i2c, ft5x0x_id_table);​

struct i2c_client *tsclient;​

/* 编写probe函数，针对单点 */​

static int __devinit ft5x0x_probe(struct i2c_client *client,​

const struct i2c_device_id *id)​

{​

s32 val;​

设备层传入的client结构​

给用户提供访问接口​

……​

return 0;​

}​

/* 编写反探测函数 */​

static int __devexit ft5x0x_remove(struct i2c_client *client)​

{​

return 0;​

}​

//1-驱动层核心核心结构​

static struct i2c_driver ft5x0x_driver = {​

.driver = {​

可以在 sys/bus/i2c/drivers查看到​

.owner = THIS_MODULE,​

},​

.probe = ft5x0x_probe,​

.remove = __devexit_p(ft5x0x_remove),​

.id_table = ft5x0x_id_table,​

};​

//模块初始换函数​

static __init int ft5x0x_drv_init(void)​

{​

注册一个IIC驱动 */​

i2c_add_driver(&ft5x0x_driver);​

return 0;​

}​

//模块卸载函数​

static __exit void ft5x0x_drv_exit(void)​

{​

i2c_del_driver(&ft5x0x_driver);​

}​

module_init(ft5x0x_drv_init);​

module_exit(ft5x0x_drv_exit);​

MODULE_LICENSE("GPL");​

struct i2c_adapter *i2c_get_adapter(int nr)​

i2c_put_adapter(struct i2c_adapter *adap)​

struct i2c_client *i2c_new_probed_device(struct i2c_adapter *adap,​

struct i2c_board_info *info,​

unsigned short const *addr_list,​

int (*probe)(struct i2c_adapter *, unsigned short addr))​

/**​

* struct i2c_board_info - template for device creation​

用来初始化 i2c_client.name​

用来初始化 i2c_client.flags​

用来初始化 i2c_client.addr​

用来初始化 i2c_client.dev.platform_data​

* @archdata: copied into i2c_client.dev.archdata​

* @of_node: pointer to OpenFirmware device node​

用来初始化 i2c_client.irq​

*/​

struct i2c_board_info {​

chartype[I2C_NAME_SIZE]; ​

unsigned shortflags;​

unsigned shortaddr;​

void*platform_data;​

struct dev_archdata*archdata;​

struct device_node *of_node;​

intirq;​

};​

void i2c_unregister_device(struct i2c_client*client)​

static const unsigned short ft5x0x_i2c[] = {​

0x38, I2C_CLIENT_END​

};//地址为0x38 ​

Symbol: TOUCHSCREEN_FT5X0X [=n] ​

Type : tristate ​

Prompt: FocalTech ft5x0x TouchScreen driver ​

Defined at drivers/input/touchscreen/Kconfig:312 ​

Depends on: !S390 && !UML && INPUT [=y] && INPUT_TOUCHSCREEN [=y] && MACH_TINY4412 [=y] ​

Location: ​

-> Device Drivers ​

-> Input device support ​

-> Generic input layer (needed for keyboard, mouse, ...) (INPUT [=y]) ​

-> Touchscreens (INPUT_TOUCHSCREEN [=y]) ​

│ ​

#include <linux/i2c.h>​

#include <linux/slab.h>​

#include <linux/export.h>​

#include <linux/module.h>​

static struct i2c_client *ft5x0x_client;​

/* 传入iic的设备地址和name给iic驱动端 */​

static const unsigned short ft5x0x_i2c[] = {​

0x38, I2C_CLIENT_END​

};​

static __init int ft5x0x_dev_init(void)​

{​

struct i2c_adapter *i2c_adap;​

struct i2c_board_info ft5x0x_info;​

memset(&ft5x0x_info, 0, sizeof(struct i2c_board_info));​

strlcpy(ft5x0x_info.type, "ft5x0x", I2C_NAME_SIZE);​

i2c_adap = i2c_get_adapter(1); //根据总线号取得适配器指针​

注册iic设备 */​

ft5x0x_client = i2c_new_probed_device(i2c_adap, &ft5x0x_info, ​

ft5x0x_i2c, NULL);​

i2c_put_adapter(i2c_adap);​

return 0;​

}​

static __exit void ft5x0x_dev_exit(void)​

{​

i2c_unregister_device(ft5x0x_client);​

}​

module_init(ft5x0x_dev_init);​

module_exit(ft5x0x_dev_exit);​

MODULE_LICENSE("GPL");​

int __initi2c_register_board_info(int busnum,​

struct i2c_board_info const *info, ​

unsigned len)​

static struct i2c_board_info ft5x06_info[] = {​

//必选，实际上是填充了type和addr成员。 ​

I2C_BOARD_INFO("ft5x0x_ts", (0x70 >> 1)), ​

.platform_data = &ft5x0x_pdata, //平台数据可有可无，根据的驱动需要传递。​

}​

#define I2C_BOARD_INFO(dev_type, dev_addr) \​

.type = dev_type, .addr = (dev_addr)​

i2c_register_board_info(1, ft5x06_info,1);​

Device Drivers ---> ​

Input device support ---> ​

[*] Touchscreens ---> ​

<> FocalTech ft5x0x TouchScreen driver ​

开发板触摸屏芯片驱动-将*号去掉​

#include <linux/init.h>​

#include <linux/module.h>​

#include <linux/platform_device.h>​

#include <linux/i2c.h>​

#include <linux/irq.h>​

#include <linux/gpio.h>​

#include <mach/gpio.h>​

#include <plat/gpio-cfg.h>​

static struct i2c_client *i2cClient = NULL;​

static unsigned short const i2c_addr_list[] = ​

{ ​

0x38, I2C_CLIENT_END​

};//地址队列​

static int __init i2c_dev_init(void)​

{​

struct i2c_adapter *i2c_adap;//获取到的总线存放在这个结构体​

struct i2c_board_info i2c_info;//设备描述结构体，里面存放着欲设备的名字还有地址​

/*获取IIC控制器*/​

i2c_adap = i2c_get_adapter(1);​

/*清空结构体*/​

memset(&i2c_info,0,sizeof(struct i2c_board_info));​

/*名称的赋值*/​

strlcpy(i2c_info.type,"FT5X06",I2C_NAME_SIZE);​

/*获取中断号*/​

i2c_info.irq=gpio_to_irq(EXYNOS4_GPX1(6));​

/*创建IIC设备--客户端*/​

i2cClient = i2c_new_probed_device(i2c_adap,&i2c_info,i2c_addr_list,NULL);​

/*设置模块信息 */​

i2c_put_adapter(i2c_adap);​

printk("i2c_dev_init!!\n");​

return 0;​

}​

static void __exit i2c_dev_exit(void)//平台设备端的出口函数​

{​

printk(" i2c_dev_exit ok!!\n");​

/*注销设备*/​

i2c_unregister_device(i2cClient);​

/*释放*/​

i2c_release_client(i2cClient);​

//增加模块计数​

try_module_get(i2c_adap->owner);​

}​

module_init(i2c_dev_init);​

module_exit(i2c_dev_exit);​

MODULE_LICENSE("GPL");​

#include <linux/init.h>​

#include <linux/module.h>​

#include <linux/platform_device.h>​

#include <linux/i2c.h>​

#include <linux/interrupt.h>​

#include <linux/irq.h>​

#include <linux/workqueue.h>​

static struct work_struct work;​

static struct i2c_client *client_drv;​

static const struct i2c_device_id i2c_id[] =​

{​

{"FT5X06",0},//设备端的名字为"myiic",0表示不需要私有数据​

{}​

};​

//工作队列处理函数​

static void work_func(struct work_struct *work)​

{​

s32 x=0,y=0,num=0;​

/*1. 读出按下的点数量*/​

num=i2c_smbus_read_byte_data(client_drv,0x02)&0x0f;​

/*2. 读取X坐标*/​

x=(i2c_smbus_read_byte_data(client_drv,0x03)&0x0f)<<8; //高位​

x|=i2c_smbus_read_byte_data(client_drv,0x04); //低位​

/*3. 读取Y坐标*/​

y=(i2c_smbus_read_byte_data(client_drv,0x05)&0x0f)<<8; //高位​

y|=i2c_smbus_read_byte_data(client_drv,0x06); //低位​

printk("num=%d,x=%d,y=%d\n",num,x,y);​

}​

//中断服务函数​

static irqreturn_t irq_handler(int irq, void *dev)​

{​

schedule_work(&work); ​

return IRQ_NONE;​

}​

static int i2c_probe(struct i2c_client *client, const struct i2c_device_id *device_id)//匹配成功时调用​

{​

client_drv=client;​

printk("i2c_probe!!!\n");​

printk("驱动端IIC匹配的地址=0x%x\n",client->addr);​

注册触摸屏的中断*/​

if(request_irq(client->irq,irq_handler,IRQ_TYPE_EDGE_BOTH,client->name,NULL)!=0)​

{​

中断注册失败!\n");​

}​

/*初始化工作*/​

INIT_WORK(&work,work_func);​

return 0;​

}​

static int i2c_remove(struct i2c_client *client)​

{​

printk("i2c_remove!!!\n");​

//注销中断​

free_irq(client->irq,NULL);​

return 0;​

}​

struct i2c_driver i2c_drv =​

{​

.driver = //这个不添加会报错，实际上没作用​

{​

.name = "XL",​

.owner = THIS_MODULE,​

},​

.probe = i2c_probe, //探测函数​

.remove = i2c_remove, //资源卸载​

.id_table = i2c_id, //里面有一个名字的参数用来匹配设备端名字​

};​

/*iic驱动端*/​

static int __init i2c_drv_init(void)​

{​

i2c_add_driver(&i2c_drv);//向iic总线注册一个驱动​

return 0;​

}​

static void __exit i2c_drv_exit(void)//平台设备端的出口函数​

{​

i2c_del_driver(&i2c_drv);​

}​

module_init(i2c_drv_init);​

module_exit(i2c_drv_exit);​

MODULE_LICENSE("GPL");​

#include <linux/init.h>​

#include <linux/module.h>​

#include <linux/platform_device.h>​

#include <linux/i2c.h>​

static struct i2c_client *i2cClient = NULL;​

static unsigned short i2c_addr_list[0xFF]={0x46,I2C_CLIENT_END};​

static int __init i2c_dev_init(void)​

{​

int i;​

struct i2c_adapter *i2c_adap;//获取到的总线存放在这个结构体​

struct i2c_board_info i2c_info;//设备描述结构体，里面存放着欲设备的名字还有地址​

/*获取IIC控制器*/​

i2c_adap = i2c_get_adapter(1);​

/*清空结构体*/​

memset(&i2c_info,0,sizeof(struct i2c_board_info));​

/*名称的赋值*/​

strlcpy(i2c_info.type,"IT7260_touch",I2C_NAME_SIZE);​

/*创建IIC设备--客户端*/​

i2cClient = i2c_new_probed_device(i2c_adap,&i2c_info,i2c_addr_list,NULL);​

if(i2cClient==NULL)​

{​

printk("地址不存在\r\n");​

}​

else​

{​

printk("地址存在0x%x\r\n",i-1);​

}​

/*设置模块信息 */​

i2c_put_adapter(i2c_adap);​

printk("i2c_dev_init!!\n");​

return 0;​

}​

static void __exit i2c_dev_exit(void)//平台设备端的出口函数​

{​

printk(" i2c_dev_exit ok!!\n");​

/*注销设备*/​

i2c_unregister_device(i2cClient);​

/*释放*/​

i2c_release_client(i2cClient);​

}​

module_init(i2c_dev_init);​

module_exit(i2c_dev_exit);​

MODULE_LICENSE("GPL");​

#include <linux/module.h>​

#include <linux/kernel.h>​

#include <linux/input.h>​

#include <linux/interrupt.h>​

#include <linux/pm.h>​

#include <linux/slab.h>​

#include <asm/io.h>​

#include <linux/i2c.h>​

#include <linux/timer.h>​

#include <linux/gpio.h>​

#include <linux/irq.h>​

#include <plat/ctouch.h>​

static int it7260_irq; //中断号​

static struct i2c_client *it7260_client; //IIC客户端​

static struct work_struct work; 工作队列​

static void it7260_ts_poscheck(struct work_struct *work)​

{​

unsigned char buf[14];​

unsigned short xpos, ypos;​

unsigned char event=0;​

memset(buf, 0, sizeof(buf));​

/*读取触摸屏寄存器数据*/​

i2c_smbus_read_i2c_block_data(it7260_client,0xE0,14,buf);​

/*触摸按键*/​

if (buf[0] == 0x41)​

{​

if (buf[1] == 0x04)printk("stat=%d,KEY_MENU=%d\n",buf[1],!!buf[2]);​

else if (buf[1] == 0x03)printk("stat=%d,KEY_HOMEPAGE=%d\n",buf[1],!!buf[2]);​

else if (buf[1] == 0x02)printk("stat=%d,KEY_BACK=%d\n",buf[1],!!buf[2]);​

else if (buf[1] == 0x01)printk("stat=%d,KEY_SEARCH=%d\n",buf[1],!!buf[2]);​

}​

/* 第一个点*/​

if (buf[0] & 0x01)​

{​

xpos = ((buf[3] & 0x0F) << 8) | buf[2];​

ypos = ((buf[3] & 0xF0) << 4) | buf[4];​

event = buf[5] & 0x0F;​

printk("x=%d,y=%d,ev=%d\n",xpos,ypos,event);​

}​

}​

static irqreturn_t it7260_ts_isr(int irq, void *dev_id)​

{​

schedule_work(&work);​

return IRQ_HANDLED;​

}​

/*​

资源匹配函数​

*/​

static int it7260_ts_probe(struct i2c_client *client,const struct i2c_device_id *idp)​

{​

it7260_client = client;​

INIT_WORK(&work, it7260_ts_poscheck);​

it7260_irq = gpio_to_irq(EXYNOS4_GPX1(6));​

request_irq(it7260_irq, it7260_ts_isr,IRQ_TYPE_EDGE_BOTH,client->name, NULL);​

return 0;​

}​

/*​

资源卸载函数​

*/​

static int __devexit it7260_ts_remove(struct i2c_client *client)​

{​

free_irq(it7260_irq, NULL);​

return 0;​

}​

/*IIC驱动名称匹配结构*/​

static const struct i2c_device_id it7260_ts_id[] = {​

{"IT7260_touch", 0},​

{}/* should not omitted */​

};​

/*底层结构*/​

static struct i2c_driver it7260_ts_driver = {​

.driver={​

.name = "IT7260",​

},​

.probe = it7260_ts_probe, /*资源探测*/​

.remove = it7260_ts_remove, /*资源卸载*/​

.id_table = it7260_ts_id, /*ID匹配*/​

};​

static int __init it7260_ts_init(void)​

{​

return i2c_add_driver(&it7260_ts_driver);​

}​

static void __exit it7260_ts_exit(void)​

{​

i2c_del_driver(&it7260_ts_driver);​

}​

module_init(it7260_ts_init);​

module_exit(it7260_ts_exit);​

MODULE_LICENSE("GPL");​

MODULE_DESCRIPTION("it7260 touchscreen driver");​

#include <stdio.h>​

#include <sys/types.h>​

#include <sys/stat.h>​

#include <fcntl.h>​

/*​

AT24C02 应用层测试代码​

*/​

int main(int argc,char **argv)​

{​

int fp;​

char buff_write[]="AT24C02读写测试!123456789ABCDEFG";​

char buff_read[100];​

fp=open("/dev/Tiny4412_AT24C02",O_RDWR);​

if(fp<0) /*判断文件是否打开成功*/​

{​

printf("AT24C02 driver open error!\n");​

return -1;​

}​

printf("写入的数据:%s\n",buff_write);​

write(fp,buff_write,strlen(buff_write)+1); /*调用写函数->向驱动层传递数据*/​

read(fp,buff_read,strlen(buff_write)+1); /*调用读函数->获取驱动层的数据*/​

printf("读出的数据：%s\n",buff_read);​

close(fp);​

return 0;​

}​

#include <linux/init.h>​

#include <linux/module.h>​

#include <linux/platform_device.h>​

#include <linux/i2c.h>​

/*获取总线*/​

struct i2c_adapter *i2c_adap; //获取到的总线存放在这个结构体​

static struct i2c_client *i2cClient = NULL;​

//AT24C02固定地址 b1010​

//AT24C02硬件地址 b000​

//组合:b1010000 = 0x50​

//注意:IIC标准地址是7位​

static unsigned short const i2c_addr_list[] = ​

{ ​

0x50, I2C_CLIENT_END​

};//地址队列​

static int __init i2c_dev_init(void)​

{​

struct i2c_board_info i2c_info;//设备描述结构体，里面存放着欲设备的名字还有地址​

i2c_adap = i2c_get_adapter(0); //获取0号总线​

if(i2c_adap==NULL)​

{​

printk("AT24C02--II总线0 获取失败!!\n");​

}​

memset(&i2c_info,0,sizeof(struct i2c_board_info));//把设备描述结构体清空结构体清空​

strlcpy(i2c_info.type,"Tiny4412_AT24C02",I2C_NAME_SIZE);//把设备的名字赋值给i2c_info​

i2cClient = i2c_new_probed_device(i2c_adap,&i2c_info,i2c_addr_list,NULL);​

if(i2cClient==NULL)​

{​

printk("AT24C02 0x%x:地址不可用!!\n",i2c_addr_list[0]);​

}​

i2c_put_adapter(i2c_adap);​

printk("AT24C02_dev_init初始化成功!!\n");​

return 0;​

}​

static void __exit i2c_dev_exit(void)//平台设备端的出口函数​

{​

/*注销设备*/​

i2c_unregister_device(i2cClient);​

i2c_release_client(i2cClient);​

printk("AT24C02_dev_exit ok!!\n");​

}​

module_init(i2c_dev_init);​

module_exit(i2c_dev_exit);​

MODULE_LICENSE("GPL");​

#include <linux/init.h>​

#include <linux/module.h>​

#include <linux/platform_device.h>​

#include <linux/i2c.h>​

#include <linux/interrupt.h> /*注册中断相关*/​

#include <linux/irq.h> 中断边沿类型定义*/​

#include <linux/gpio.h> 中断IO口定义*/​

#include <linux/workqueue.h> /*工作队列相关*/​

#include <linux/mutex.h> /*互斥信号量头文件*/​

#include <linux/delay.h>​

#include <linux/miscdevice.h> /*杂项设备相关结构体*/​

#include <linux/fs.h> /*文件操作集合头文件*/​

#include <linux/uaccess.h> /*使用copy_to_user和copy_from_user*/​

static struct i2c_client *at24cxx_client;​

/*互斥锁相关*/​

/*互斥锁*/​

static DEFINE_MUTEX(my_mutexname);​

/*相关的函数声明*/​

static u8 i2c_read_data(u8 addr,u8 len,u8* str);​

static ssize_t at24cxx_read(struct file *my_file, char __user *buf, size_t my_size, loff_t * my_loff);​

static int at24cxx_release(struct inode *my_inode, struct file *my_file);​

static ssize_t at24cxx_write(struct file *my_file, const char __user *buf, size_t my_size, loff_t *my_loff);​

static int at24cxx_open(struct inode *my_inode, struct file *my_file);​

/*定义一个文件操作集合结构体*/​

static struct file_operations ops_at24cxx={​

.owner = THIS_MODULE,​

读函数-被应用层read函数调用*/​

写函数-被应用层write函数调用*/​

打开函数-被应用层open函数调用*/​

释放函数*/​

};​

/*定义一个杂项设备结构体*/​

static struct miscdevice misce_at24cxx={​

.minor =MISC_DYNAMIC_MINOR, /*自动分配次设备号*/​

.name = "Tiny4412_AT24C02", /*名称 在dev/目录下边可以找到*/​

.fops = &ops_at24cxx, /*文件操作集合*/​

};​

/*​

IIC驱动端​

*/​

static const struct i2c_device_id i2c_id[] =​

{​

{"Tiny4412_AT24C02",0},//设备端的名字为"my_at24c02",后面的表示需要私有数据​

{}​

};​

/*----------------------------------​

写数据函数​

参数​

addr:地址​

len :长度​

str :数据首地址​

------------------------------------*/​

static u8 i2c_write_data(u8 addr,u8 len,u8* str)​

{​

u8 i,flag=0;​

for(i=0;i<len;i++)​

{​

/*循环写入数据*/​

flag=i2c_smbus_write_byte_data(at24cxx_client,addr+i,str[i]);​

if(flag<0)return -1;​

写延时*/​

}​

return flag;​

}​

/*-----------------------------------------​

AT24C02测试​

写入一个字节再读出来比较​

------------------------------------------*/​

static s32 at24cxx_test(void)​

{​

s32 data;​

/*写入数据*/​

data=i2c_smbus_write_byte_data(at24cxx_client,0,0xAA);​

if(data<0)printk("at24cxx write data error!\n"); ​

msleep(2); /*写延时*/​

/*读出数据*/​

data=i2c_smbus_read_byte_data(at24cxx_client,0);​

if(data<0)printk("at24cxx read data error!\n"); ​

if(data==0xAA)​

{​

return 0;​

}​

else​

{​

return -1;​

}​

}​

/*----------------------------------​

读数据函数​

参数​

addr:地址​

len :长度​

str :存放数据首地址​

------------------------------------*/​

static u8 i2c_read_data(u8 addr,u8 len,u8* str)​

{​

u8 i,flag=0;​

for(i=0;i<len;i++)​

{​

/*循环读出数据*/​

flag=i2c_smbus_read_byte_data(at24cxx_client,addr+i);​

if(flag<0)return -1;​

str[i]=flag;​

}​

return flag;​

}​

static int at24cxx_open(struct inode *my_inode, struct file *my_file)​

{​

return 0;​

}​

static u8 at24cxx_addr=0;​

static ssize_t at24cxx_read(struct file *my_file, char __user *buf, size_t my_len, loff_t * my_loff)​

{​

int error;​

u8 read_buff[100];​

i2c_read_data(at24cxx_addr,my_len,read_buff);​

error=copy_to_user(buf,read_buff,my_len);​

return error;​

}​

static ssize_t at24cxx_write(struct file *my_file, const char __user *buf, size_t my_len, loff_t *my_loff)​

{​

int error;​

u8 write_buff[100];​

unsigned char key=0; ​

error=copy_from_user(write_buff,buf,my_len); //接收应用层的数据​

error=i2c_write_data(at24cxx_addr,my_len,write_buff);​

return error;​

}​

static int at24cxx_release(struct inode *my_inode, struct file *my_file)​

{​

return 0;​

}​

static int i2c_probe(struct i2c_client *client, const struct i2c_device_id *device_id)//匹配成功时调用​

{​

at24cxx_client=client;​

s32 data=0;​

printk("<1>""AT24C02驱动端资源匹配成功!\n");​

printk("<1>""驱动端IIC匹配的地址=0x%x\n",client->addr);​

mutex_lock(&my_mutexname); /*获取互斥锁*/​

/* 检测适配器是否支持smbus字节读写函数 */​

if(i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) ​

{​

printk("适配器支持smbus字节读写函数\n");​

}​

if(at24cxx_test()<0) /*测试AT24C02是否OK*/​

{​

printk("AT24C02 device read/write error!\n");​

}​

else​

{​

printk("AT24C02 device read/write ok!\n");​

}​

if(misc_register(&misce_at24cxx)==0)/*注册*/​

{​

printk("misc AT24C02 init ok!\n");​

}​

else​

{​

printk("misc AT24C02 init error!\n");​

}​

mutex_unlock(&my_mutexname); /*释放互斥锁*/​

return 0;​

}​

static int i2c_remove(struct i2c_client *client)​

{​

if(misc_deregister(&misce_at24cxx)==0)/*注销*/​

{​

printk("at24cxx remove exit ok!\n");​

}​

printk("i2c_remove!!!\n");​

printk("i2c_驱动端卸载成功!!!\n");​

return 0;​

}​

struct i2c_driver i2c_drv =​

{​

.driver = //这个不添加会报错，实际上没作用​

{​

.name = "AT24C02", /*sys/bus/i2c/drivers*/​

.owner = THIS_MODULE,​

},​

.probe = i2c_probe,//探测函数​

.remove = i2c_remove,​

.id_table = i2c_id,//里面有一个名字的参数用来匹配设备端名字​

};​

/*iic驱动端*/​

static int __init i2c_drv_init(void)​

{​

i2c_add_driver(&i2c_drv);//向iic总线注册一个驱动​

return 0;​

}​

static void __exit i2c_drv_exit(void)//平台设备端的出口函数​

{​

i2c_del_driver(&i2c_drv);​

}​

module_init(i2c_drv_init);​

module_exit(i2c_drv_exit);​

MODULE_LICENSE("GPL");​

#include <stdio.h>​

#include <sys/types.h>​

#include <sys/stat.h>​

#include <fcntl.h>​

/*​

PCF8591 应用层测试代码​

*/​

int main(int argc,char **argv)​

{​

unsigned char data=0;​

int fp;​

float tmp; // tmp=5.34v 0.34​

int a;​

int b;​

fp=open("/dev/Tiny4412_PCF8591",O_RDWR);​

if(fp<0) /*判断文件是否打开成功*/​

{​

printf("PCF8591 driver open error!\n");​

return -1;​

}​

while(1)​

{​

read(fp,&data,1);​

write(fp,&data,1);​

printf("ADC1=%d\n",data);​

tmp=(float)data*(5.0/255); //电压= 采集的数字量*(参考电压/分辨率);​

a=tmp; //a=5 tmp=5.3​

b=(int)((tmp-a)*1000); //b=0.34​

printf("ADC1=%d.%dV\r\n",(int)a,(int)b); ​

sleep(1);​

}​

close(fp);​

return 0;​

}​

#include <linux/init.h>​

#include <linux/module.h>​

#include <linux/platform_device.h>​

#include <linux/i2c.h>​

/*获取总线*/​

struct i2c_adapter *i2c_adap; //获取到的总线存放在这个结构体​

static struct i2c_client *i2cClient = NULL;​

//PCF8591固定地址 b1001​

//PCF8591硬件地址 b000​

//组合:b1001000 = 0x48​

//注意:IIC标准地址是7位​

static unsigned short const i2c_addr_list[] = ​

{ ​

0x48, I2C_CLIENT_END​

};//地址队列​

static int __init i2c_dev_init(void)​

{​

struct i2c_board_info i2c_info;//设备描述结构体，里面存放着欲设备的名字还有地址​

i2c_adap = i2c_get_adapter(0); //获取0号总线​

if(i2c_adap==NULL)​

{​

printk("PCF8591--II总线0 获取失败!!\n");​

}​

memset(&i2c_info,0,sizeof(struct i2c_board_info));//把设备描述结构体清空结构体清空​

strlcpy(i2c_info.type,"Tiny4412_PCF8591",I2C_NAME_SIZE);//把设备的名字赋值给i2c_info​

i2cClient = i2c_new_probed_device(i2c_adap,&i2c_info,i2c_addr_list,NULL);​

if(i2cClient==NULL)​

{​

printk("PCF8591 0x%x:地址不可用!!\n",i2c_addr_list[0]);​

}​

i2c_put_adapter(i2c_adap);​

printk("PCF8591_dev_init初始化成功!!\n");​

return 0;​

}​

static void __exit i2c_dev_exit(void)//平台设备端的出口函数​

{​

/*注销设备*/​

i2c_unregister_device(i2cClient);​

i2c_release_client(i2cClient);​

printk("PCF8591_dev_exit ok!!\n");​

}​

module_init(i2c_dev_init);​

module_exit(i2c_dev_exit);​

MODULE_LICENSE("GPL");​

#include <linux/init.h>​

#include <linux/module.h>​

#include <linux/platform_device.h>​

#include <linux/i2c.h>​

#include <linux/interrupt.h> /*注册中断相关*/​

#include <linux/irq.h> 中断边沿类型定义*/​

#include <linux/gpio.h> 中断IO口定义*/​

#include <linux/workqueue.h> /*工作队列相关*/​

#include <linux/mutex.h> /*互斥信号量头文件*/​

#include <linux/delay.h>​

#include <linux/miscdevice.h> /*杂项设备相关结构体*/​

#include <linux/fs.h> /*文件操作集合头文件*/​

#include <linux/uaccess.h> /*使用copy_to_user和copy_from_user*/​

#define AIN0 0x40​

#define AIN1 0x41​

#define AIN2 0x42​

#define AIN3 0x43​

static struct i2c_client *PCF8591_client; /*IIC设备总线*/​

/*读取PCF8591 ADC数据*/​

unsigned char PCF8591_ReadADC(unsigned char ch)​

{​

return i2c_smbus_read_byte_data(PCF8591_client,ch); ​

}​

static int PCF8591_open(struct inode *my_inode, struct file *my_file)​

{​

return 0;​

}​

static ssize_t PCF8591_read(struct file *my_file, char __user *buf, size_t my_len, loff_t * my_loff)​

{​

unsigned char data=PCF8591_ReadADC(AIN0);​

copy_to_user(buf,&data,1);​

data=PCF8591_ReadADC(AIN1);​

printk("1:%d\r\n",data);​

data=PCF8591_ReadADC(AIN2);​

printk("2:%d\r\n",data);​

data=PCF8591_ReadADC(AIN3);​

printk("3:%d\r\n",data);​

return 0;​

}​

static ssize_t PCF8591_write(struct file *my_file, const char __user *buf, size_t my_len, loff_t *my_loff)​

{​

//DAC输出​

i2c_smbus_write_byte_data(PCF8591_client,0x40,100);​

return 0;​

}​

static int PCF8591_release(struct inode *my_inode, struct file *my_file)​

{​

return 0;​

}​

/*定义一个文件操作集合结构体*/​

static struct file_operations ops_PCF8591={​

.owner = THIS_MODULE,​

读函数-被应用层read函数调用*/​

写函数-被应用层write函数调用*/​

打开函数-被应用层open函数调用*/​

释放函数*/​

};​

/*定义一个杂项设备结构体*/​

static struct miscdevice misce_PCF8591={​

.minor =MISC_DYNAMIC_MINOR, /*自动分配次设备号*/​

.name = "Tiny4412_PCF8591", /*名称 在dev/目录下边可以找到*/​

.fops = &ops_PCF8591, /*文件操作集合*/​

};​

static int i2c_probe(struct i2c_client *client, const struct i2c_device_id *device_id)//匹配成功时调用​

{​

PCF8591_client=client;​

printk("<1>""驱动端IIC匹配的地址=0x%x\n",client->addr);​

/* 检测适配器是否支持smbus字节读写函数 */​

if(i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) ​

{​

printk("适配器支持smbus字节读写函数\n");​

}​

/*注册*/​

misc_register(&misce_PCF8591);​

return 0;​

}​

static int i2c_remove(struct i2c_client *client)​

{​

misc_deregister(&misce_PCF8591);/*注销*/​

printk("i2c_驱动端卸载成功!!!\n");​

return 0;​

}​

/*​

IIC驱动端​

*/​

static const struct i2c_device_id i2c_id[] =​

{​

{"Tiny4412_PCF8591",0},//设备端的名字为"my_PCF8591",后面的表示需要私有数据​

{}​

};​

struct i2c_driver i2c_drv =​

{​

.driver=​

{​

.name = "PCF8591", ​

.owner = THIS_MODULE,​

},​

.probe = i2c_probe,​

.remove = i2c_remove,​

.id_table = i2c_id,​

};​

static int __init i2c_drv_init(void)​

{​

i2c_add_driver(&i2c_drv);//向iic总线注册一个驱动​

return 0;​

}​

static void __exit i2c_drv_exit(void)//平台设备端的出口函数​

{​

i2c_del_driver(&i2c_drv);​

}​

module_init(i2c_drv_init);​

module_exit(i2c_drv_exit);​

MODULE_LICENSE("GPL");​