#include <linux/mm.h>
#include <asm/io.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/rtc.h> /* get the user-level API */
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <mach/at91_pio.h>
#include <mach/gpio.h>
#include <linux/kdev_t.h>
#include <linux/types.h>
#include <linux/cdev.h>
#include <linux/platform_device.h>
#include <linux/version.h>
/*通过测试也是可以的*/
#define DEV_NAME "iic" /* 加载模式后，执行”cat /proc/devices”命令看到的设备名称 */
//#define DEV_MAJOR 231 /* 主设备号 */
#define DEV_MAJOR 0
#define DEV_MINOR 0
///
#define I2C_SCL_H (at91_set_gpio_value(AT91_PIN_PA24, 1))
#define I2C_SCL_Low (at91_set_gpio_value(AT91_PIN_PA24, 0))
#define I2C_SDA_OUT (at91_set_gpio_output(AT91_PIN_PA23,1)) /* SDA OUT*/
#define I2C_SDA_IN (at91_set_gpio_input(AT91_PIN_PA23, 1)) /* SDA IN*/
#define I2C_SDA_Low (at91_set_gpio_value(AT91_PIN_PA23, 0)) /* SDA Low*/
#define I2C_SDA_H (at91_set_gpio_value(AT91_PIN_PA23, 1)) /* SDA H*/
#define I2C_SDA_Value (at91_get_gpio_value(AT91_PIN_PA23)) /* SDA H*/
//if(at91_get_gpio_value(AT91_PIN_PA0)==1)//读I/O就可以了 真他妈的搞不懂
///
//#define SPI_READ_MODE _IOR('D', 1, long)
//#define SPI_WRITE_MODE _IOW('D', 1, long)
#define TWD_CLOCK_H _IOW('D', 2, int)
#define TWD_CLOCK_L _IOW('D', 3, int)
//#define SPI_READ_DATA _IOR('D', 4, long)
//#define SPI_WRITE_DATA _IOW('D', 4, long)
struct i2c_dev
{
dev_t devno; //变量是设备号
int major;
int minor;
struct class_device *class_dev;
struct class *class;
struct cdev cdev;
};
struct i2c_dev *at91_i2c;
static void __iomem *pio_base;
/* 应用程序对设备文件/dev/led执行open(...)时， * 就会调用led_open函数 */
delay()
/**********************************************************************
**函数原型： i2c_delay(int num)
**入口参数: num
**出口参数: 无
**返 回 值： 无
**说 明： I2C的延迟函数
************************************************************************/
void i2c_delay(int num)
{
int i;
while(num--)
{
for(i = 0;i<100;i++);
}
}
///*********************************************************************
///**函数原型： void I2CStart()
///**入口参数: 无
///**出口参数: 无
///**返 回 值： 无
///**说 明： 启动I2C总线
///**********************************************************************
void I2cStart()
{
I2C_SDA_OUT; //SDA输出
I2C_SDA_H; //SDA=1;
i2c_delay(50); //延时>1us
I2C_SCL_H; //SCL=1;
i2c_delay(250); //延时>4.7us
I2C_SDA_Low; //SDA=0
i2c_delay(250); //延时>4us
I2C_SCL_Low ; //SCL=0;
i2c_delay(50); //延时>1us
}
///**********************************************************************
///**函数原型： void I2cSendByte(int data)
///**入口参数: data
///**出口参数: 无
///**返 回 值： 无
///**说 明： 向I2C写入数据
///************************************************************************
void I2cSendByte(unsigned char data)
{
unsigned char flag, sz; //定义局部寄存器
I2C_SDA_OUT; //SDA输出
for(flag=0x0080; flag!=0x00;flag=flag/2)
{
sz=data&flag;
if(sz==0)
{
I2C_SDA_Low; //SDA=0
i2c_delay(50); //1us
I2C_SCL_H; //SCL=1;
i2c_delay(250); //5us
I2C_SCL_Low ; //SCL=0;
}
else
{
I2C_SDA_H; //SDA=1
i2c_delay(50); //1us
I2C_SCL_H; //SCL=1;
i2c_delay(250); //5us
I2C_SCL_Low ; //SCL=0;
}
}
}
/**********************************************************************
**函数原型： I2cRecak()
**入口参数: 无
**出口参数: 无
**返 回 值： 应答值
**说 明： 检查应答位子程序(返回0表示有应答）
************************************************************************/
int I2cRecak()
{
unsigned char Ack=1;
unsigned char m=1;
I2C_SDA_OUT; //SDA输出
I2C_SDA_H; //SDA=1
i2c_delay(50); //2us
I2C_SDA_IN; //SDA输入
I2C_SCL_H; //SCL=1;
i2c_delay(50); //3us
if(I2C_SDA_Value == 1) //表示无应答
{
i2c_delay(50);
I2C_SCL_Low ; //SCL=0;
i2c_delay(50); //1us......
}
else
{
Ack=0;
i2c_delay(50);
I2C_SCL_Low ; //SCL=0;
i2c_delay(50); //1us......
}
return(Ack);
}
///**********************************************************************
///**函数原型： void I2cRecByte()
///**入口参数: 无
///**出口参数: 无
///**返 回 值： 数据
///**说 明： 从I2C中读取数据
///************************************************************************/
int I2cReadByte()
{
unsigned char M=0;
int flag;
I2C_SDA_OUT; //SDA输出
I2C_SDA_H; //SDA=1
I2C_SDA_IN; //SDA输入
for(flag=7;flag>=0;flag--)
{
I2C_SCL_H; //SCL=1
i2c_delay(100); //2us...
M=M|(I2C_SDA_Value << flag); //保留读取的那位
i2c_delay(250); //5us...
I2C_SCL_Low ; //SCL=0
i2c_delay(100); //3us
}
return(M);
}
///**********************************************************************
///**函数原型： void I2cAck()
///**入口参数: 无
///**出口参数: 无
///**返 回 值： 无
///**说 明： 对I2C总线中产生应答
///***********************************************************************
void I2cAck( )
{
I2C_SDA_OUT; //SDA输出
I2C_SDA_Low; //SDA=0
i2c_delay(50); //2us.....
I2C_SCL_H; //SCL=1
i2c_delay(250); //5us......
I2C_SCL_Low ; //SCL=0
i2c_delay(50); //2us......
}
/**********************************************************************
**函数原型： void I2cNoAck()
**入口参数: 无
**出口参数: 无
**返 回 值： 无
**说 明：不对I2C总线中产生应答
************************************************************************/
void I2cNoAck()
{
I2C_SDA_OUT; //SDA输出
I2C_SDA_H; //SDA=1
i2c_delay(50); //2us.....
I2C_SCL_H; //SCL=1;
i2c_delay(250); //5us....
I2C_SCL_Low ; //SCL=0;
i2c_delay(50); //2us......
}
/**********************************************************************
**函数原型： void I2CStop()
**入口参数: 无
**出口参数: 无
**返 回 值： 无
**说 明： 停止IC总线
************************************************************************/
void I2cStop()
{
I2C_SDA_OUT; //SDA输出
I2C_SDA_Low; //SDA=0
i2c_delay(50); //2us........
I2C_SCL_H; //SCL=1;
i2c_delay(250); //5us........//延时
I2C_SDA_H; //SDA=1
i2c_delay(250); //5us......
}
static int i2c_open(struct inode *inode,
struct file *file)
{
/*pio_base = ioremap(0xFFFFF400,512); //PIOA开始的地址 以及空间512字节
writel(0x01800000, pio_base + PIO_PER); //PIO的使能寄存器 表示向该寄存器写入0x00000040的数据
writel(0x01800000, pio_base + PIO_PUER); //pull—up 使能寄存器 表示向该寄存器写入0x00000040的数据
writel(0x01000000, pio_base + PIO_ODSR); //输出数据状态寄存器 表示向该寄存器写入0x00000040的数据
writel(0x01000000, pio_base + PIO_OER); //输出使能寄存器 表示向该寄存器写入0x00000040的数据
*/
at91_set_A_periph(AT91_PIN_PA23, 1); //TWD
at91_set_A_periph(AT91_PIN_PA24, 1); //TWD CLOCK
at91_set_gpio_output(AT91_PIN_PA24, 1); //I/O 口设置 clock
at91_set_deglitch(AT91_PIN_PA24, 1);
printk(KERN_INFO "::open_iic\n");
return 0;
}
static int i2c_ioctl( struct inode *inode,
struct file *filp,
unsigned int cmd,
unsigned long arg)
{
//long mode=0x01000000;
switch(cmd){
case TWD_CLOCK_H:
I2C_SCL_H;
printk(KERN_INFO "::I2C_CLK_H\n");
break;
case TWD_CLOCK_L:
I2C_SCL_Low;
printk(KERN_INFO "::I2C_CLK_L\n");
break;
default: return -EINVAL;
break;
}
return 0;
}
/**********************************************************************
**函数原型： i2c_read(struct file *file, const char __user *buf, size_t count)
**入口参数:
**出口参数: 无
**返 回 值： 无
**说 明： 通用的读24LC256的子程序（（指针是8字节的读操作已经成功）
************************************************************************/
static int i2c_read(struct file *file, const char __user *buf, size_t count)
{
unsigned char dat,i;
unsigned char *buffer;
unsigned char missing;
unsigned char counter=count;
ssize_t status = 0;
buffer=kmalloc(count * sizeof(char),GFP_KERNEL);
LABLE: I2cStart();
dat=0xA2; //设置I2c的开始状态
I2cSendByte(dat); //送出器件地址字0xA3
printk("read_dat0=0x%02X\n",dat);
dat=I2cRecak(); //检查应答位
if(dat==0)
{
dat=0x00; //dat=24LC256的块内地址的高字节 （因为每次只能送8位）
printk("read_dat1=0x%02X\n",dat);
I2cSendByte(dat); //送出24LC256的块内地址的高字节
dat=I2cRecak(); //检查应答位
if(dat==0)
{
I2cStart();
dat=0xA3;
I2cSendByte(dat); //送出24LC256的读指令
//printk("read_dat2=0x%02X\n",dat);
dat=I2cRecak(); //检查应答位
if(dat==1)
{
goto LABLE;//无则重新开始
printk("read FUCK\n");
}
else
{
//printk("read FUCK_in\n");
//printk("read_count2=0x%02X\n",counter);
for(;counter!=1;counter--)
{
dat=I2cReadByte(); //读取一个字节的数据
*(buffer++)=dat; //把读取的数据存入数组
printk("read_dat3=0x%02X\n",*(buffer-1));
I2cAck(); //产生应答信号
}
//printk("read_count4=0x%02X\n",counter);
dat=I2cReadByte(); //接收最后一个数据
I2cNoAck(); //发出应答
*buffer=dat; //把读取的数据放入数组
//printk("read_dat5=0x%02X\n",*(buffer));
}
}
}
// printk("read_count=0x%02X\n",count);
buffer=buffer-(count-1);
missing=copy_to_user(buf,buffer, count);//boy
if(missing != 0)
{
kfree(buffer);
status = -EFAULT;
}
for(i=0;i<4;i++)printk("read_dat6=0x%02X\n",*(buf+i));
printk("read FUCK_out\n");
I2cStop();
return 0;
}
/********************************************************
**函数原型： void Write(uint8 * array, uint16 address,uint16 control,uint16 n)
**入参数: array addres control n
**出口参数: 无
**返 回 值： 无
**说 明? 通用的写24LC256的子程序(指针是8字节的写操作已经成功）
************************************************************************/
/通用的读写24LC256的程序，ARRAY=缓冲区首地址 address=块内地址，
/control=控制字节
/n=读写的字节数adders=N*64+M
/N=第几页，
/M=第几个字节
static int i2c_write(struct file *file, const char __user *buf, size_t count)
{
unsigned char dat,i;
unsigned char missing;
unsigned char *buff;
unsigned char counter=count-2;
ssize_t status = 0;
printk(KERN_INFO "i2c_write\n");
buff = kmalloc(count*sizeof(char), GFP_KERNEL);
missing=copy_from_user(buff,buf, count);
if(missing != 0)
{
kfree(buff);
status = -EFAULT;
}
//LCM_SPA_Low; //WP=0;设置写允许
LOOP: I2cStart(); //设置I2c的开始状态
I2cSendByte(*buff); //送出器件地址字0xA2
printk("buff=0x%02X\n",*buff);
dat=I2cRecak(); //检查应答位
if(dat==0)
{
dat=*(buff+1); //0x00;
printk("write_dat=0x%02X\n",dat);
I2cSendByte(dat); //送出24LC256的块内地址的高字节
dat=I2cRecak(); //检查应答位
if(dat==0)
{
// dat=*(buff+2); //送出24LC256的低地址
//I2cSendByte(dat); //送出24LC256的低地址
// dat=I2cRecak(); //检查应答位
// if(dat==0) //如果有应答位
// {
for(i=0;i<counter;i++)
{
//buff++;
I2cSendByte(*(buff+2+i)); //写出一个字节的数据0x23
printk("write_dat1=0x%02X\n",*(buff+2+i));
dat=I2cRecak(); //检查应答位 dat==0,表明写成功
if(dat==1) goto LOOP; //如果无应答位,写操作失败，重新开始
}
// }
}
}
I2cStop(); //返回一个状态字，以确操作是否成功
//LCM_SPA_H; //WP=1;写操作完成，设置写保护
return 0;
}
static int i2c_close(
struct inode *inode,
struct file *file)
{
/*
int i;
for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++)
{
free_irq(button_irqs[i].irq, NULL);
}
*/
return 0;
}
static struct file_operations i2c_fops =
{
.owner = THIS_MODULE,
.open = i2c_open,
.ioctl = i2c_ioctl,
.read = i2c_read,
.write = i2c_write,
.release = i2c_close,
};
static int i2c_init(void)
{
int result,err;
printk(DEV_NAME "::i2c_init\n");
at91_i2c = kmalloc(sizeof(struct i2c_dev), GFP_KERNEL);
if( DEV_MAJOR != 0){ /*静态申请设置号*/
at91_i2c->devno = MKDEV(DEV_MAJOR,DEV_MINOR);
result = register_chrdev_region(at91_i2c->devno,1,DEV_NAME);
at91_i2c->major = DEV_MAJOR;
at91_i2c->minor = DEV_MINOR;
}else {
result = alloc_chrdev_region(&at91_i2c->devno,DEV_MINOR,1,DEV_NAME); /*动态申请设置号*/
at91_i2c->major = MAJOR(at91_i2c->devno);
at91_i2c->minor = DEV_MINOR;
}
if(result < 0){
printk(KERN_ERR"i2c::can't get major\n");
kfree(at91_i2c);
return result;
}
cdev_init(&at91_i2c->cdev,&i2c_fops); /*设置注册 初始化设备*/
at91_i2c->cdev.owner = THIS_MODULE;
at91_i2c->cdev.ops = &i2c_fops;
err = cdev_add(&at91_i2c->cdev,at91_i2c->devno,1);
if(err){
printk(KERN_INFO"::error %d adding led\n",err);
}
at91_i2c->class = class_create(THIS_MODULE, DEV_NAME); /*创建一个类*/
if( IS_ERR(at91_i2c->class) ){ /*IS＿ERR() PTR＿ERR()等函数是专门用来处理CLASS之类的返回错误代码 */
return PTR_ERR(at91_i2c->class);
}
at91_i2c->class_dev = device_create(at91_i2c->class, NULL,/*创建在/dev目录下创建相应的设备节点。这样，加载模块的时候，*/
/* 用户空间中的udev会自动响应device_create(…)函数，去/sysfs下寻找对应的类从而创建设备节点。*/
// 第一个参数指定所要创建的设备所从属的类，第二个参数是这个设备的父设备，如果没有就指定为NULL，第三个参数是设备号，第四个参数是设备名称，第五个参数是从设备号
at91_i2c->devno,
NULL,DEV_NAME);
if( IS_ERR(at91_i2c->class_dev) ){
return PTR_ERR(at91_i2c->class_dev);
}
return 0;
}
static void __exit i2c_exit(void)
{
device_destroy(at91_i2c->class, at91_i2c->devno);
class_destroy(at91_i2c->class); 还定义了class_destroy(…)函数，用于在模块卸载时删除类。
cdev_del(&at91_i2c->cdev);
unregister_chrdev_region(at91_i2c->devno,1);
kfree(at91_i2c);
printk(DEV_NAME ":: led_exit\n");
}
module_init(i2c_init);
module_exit(i2c_exit);
MODULE_AUTHOR("zhd wangyulu");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("at91sam9g20 led");
/*****Kconfig*******************************
config baite_LED
tristate "baite_led"
default m
******************************************/
/****Makeflie********************************
obj-$(CONFIG_baite_LED) +=baite_led.o
******************************************/
以上是我的AT91的iic的软件驱动，其实只要稍加改动就可以应用在其他的上面。
下面是我的应用代码，就是用来测试该驱动的，以上都是通过我的测试，可以用的
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
//IIC Define the command constant
//#define SPI_READ_MODE _IOR('D', 1, long)
//#define SPI_WRITE_MODE _IOW('D', 1, long)
#define TWD_CLOCK_H _IOW('D', 2, int)
#define TWD_CLOCK_L _IOW('D', 3, int)
//#define SPI_READ_DATA _IOR('D', 4, long)
//#define SPI_WRITE_DATA _IOW('D', 4, long)
unsigned char Tx_buffer[6]={0xA2,0x00,0x89,0x12,0x23,0x34};
unsigned char Rx_buffer[4]={0};
/***********主程序***********/
int main(int argc, char **argv)
{
int fd,ret,i;
fd=open("/dev/iic",O_RDWR);
if(fd<0)
{
perror("open error");
}
else printf("open iic success\n");
//while(1)
//{
if(write(fd,Tx_buffer,sizeof(Tx_buffer)/sizeof(Tx_buffer[0]))<0) //注意fd？
{
perror("read wrong::");
exit(1);
}
if(read(fd,Rx_buffer,sizeof(Rx_buffer)/sizeof(Rx_buffer[0]))<0) //注意fd？
{
perror("read wrong::");
exit(1);
}
printf("Rx_buffer=::0x%02X\n",Rx_buffer[0]);
printf("Rx_buffer=::0x%02X\n",Rx_buffer[1]);
printf("Rx_buffer=::0x%02X\n",Rx_buffer[2]);
printf("Rx_buffer=::0x%02X\n",Rx_buffer[3]);
//}
//sleep(1);
close(fd);
return 0;
}
希望有帮助！
2047
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
