HardBirch

Linux下IIC总线驱动 备忘

时间:09-10-31 栏目:系统技术篇 作者:鲁智森也有文化 评论:0 点击: 1,331 次

目录:

1.四种模式的IIC驱动编写介绍

2.一个完整的IIC驱动(从器件接收模式
,并且是裸写驱动
)

 

1.1 开启从器件接收模式的示例

R_IICCON = 0xE2;
//



使能


ACK



,使能中断

R_IICADD = 0xAA;
//



从器件地址

R_IICSTAT = 0x10;
//



设置从器件接收模式


进入中断处理,读收数据:

unit8_t ch = R_IICDS & 0xff;
//



读取数据寄存器

R_IICCON &= 0xEF;
//



清除


IICCON[4]



恢复中断响应

RET;


 

1.2 开启从器件发送模式的示例

R_IICCON = 0xE2;
//



使能


ACK



,使能中断

R_IICADD = 0xAA;
//



从器件地址

R_IICSTAT = 0x50;
//



设置从器件接收模式


进入中断处理,发送数据:

unit8_t ch = extern_buffer[i];
//



取得待发送到从器件的数据

R_IICDS = ch;
//



写入数据到


IICDS


R_IICCON &= 0xEF;
//



清除


IICCON[4]



恢复中断响应

RET;


以切换模式的方式结束发送。

 

1.3 开启主器件发送模式的示例

R_IICCON = 0xE2;
//



使能


ACK



,使能中断

R_IICSTAT = 0xD0;
//



设置主器件发送模式


R_IICDS = 0xD0;
//



写入从器件地址到


IICDS



寄存器

R_IICSTAT = 0xF0;
//



送出


IICDS



中的数据

ACK



并进入中断处理:

uint8_t ch = extern_buffer[i];
//



取得待发送到从器件的数据

R_IICDS = ch;
//



再次写入数据到


IICDS


R_IICCON &= 0xEF;
//



清除


IICCON[4]



恢复中断响应

结束发送


:


R_IICSTAT = 0xD0;
//






IICSTAT[5]






0,



产生停止条件

 

1.4 开启主器件接收模式的示例

R_IICCON = 0xE2;
//



使能


ACK



,使能中断

R_IICSTAT = 0x90;
//



设置主器件接收模式

R_IICDS = 0xD0;
//



写入从器件地址到


IICDS


R_IICSTAT = 0xB0;
//



送出


IICDS



中的数据

ACK



并进入中断处理:

uint8_t ch = R_IICDS & 0xFF;
//



读取一个八位序列

R_IICCON &= 0xEF;
//



清除


IICCON[4]



恢复中断响应

结束接收


:


R_IICSTAT = 0x90;
//






IICSTAT[5]






0,



产生停止条件

 

2.1 驱动源代码


#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/poll.h>
#include <linux/wait.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <asm/arch/irqs.h>

#define DEVICE          "TEST_IIC"
#define DATA_LEN        6

int major = 233;
int minor = 0;
void *R_GPECON,*R_GPEUP,*R_IICCON,*R_IICSTAT,*R_IICADD,*R_IICDS;

int IIC_open(struct inode *, struct file *);
int IIC_release(struct inode *, struct file *);
ssize_t IIC_read(struct file *file, char* buf, size_t count, loff_t *f_pos);
unsigned int IIC_poll(struct file* file, poll_table* wait);
irqreturn_t interrupt_handle( int irq, void* dev_id, struct pt_regs* regs );

static void address_map(void)
{
#define  IIC_BASE       (0x54000000)
#define  IIC_GPECON     ( IIC_BASE + 0x40 )
#define  IIC_GPEUP      ( IIC_BASE + 0x48 )
#define  IIC_CON        ( IIC_BASE + 0x0 )
#define  IIC_STAT       ( IIC_BASE + 0x4 )
#define  IIC_ADDR       ( IIC_BASE + 0x8 )
#define  IIC_DS         ( IIC_BASE + 0xC )
        R_GPECON  = ioremap(IIC_GPECON,4);
        R_GPEUP   = ioremap(IIC_GPEUP ,4);
        R_IICCON  = ioremap(IIC_CON   ,4);
        R_IICSTAT = ioremap(IIC_STAT  ,4);
        R_IICADD  = ioremap(IIC_ADDR  ,4);
        R_IICDS   = ioremap(IIC_DS    ,4);
}

static void address_unmap(void)
{
        iounmap( R_GPECON );
        iounmap( R_GPEUP );
        iounmap( R_IICCON );
        iounmap( R_IICSTAT );
        iounmap( R_IICADD );
        iounmap( R_IICDS );
}

static struct file_operations fops = {
        owner :         THIS_MODULE,
        read:           IIC_read,
        open:           IIC_open,
        release:        IIC_release,
        poll:           IIC_poll,
};

struct IIC_dev{
        wait_queue_head_t rq;   // 读取等待队列
        uint8_t *buffer;
        uint32_t size;
        uint32_t index;
        struct semaphore sem;
        struct cdev cdev;
};
struct IIC_dev *my_dev;

static int __init IIC_init(void)
{
        // 1. 分配主设备号
        dev_t devno = MKDEV( major, minor );
        int ret = register_chrdev_region( devno, 1, DEVICE );
        if( ret < 0 )
        {
          printk(KERN_DEBUG "register major number failed with %d/n", ret);
          return ret;
        }
        printk(KERN_DEBUG "%s:register major number OK/n",DEVICE);

        // 2. 注册设备
        my_dev = kmalloc(sizeof(struct IIC_dev), GFP_KERNEL);
        memset( my_dev, 0, sizeof(struct IIC_dev) );
        cdev_init( &my_dev->cdev, &fops );
        my_dev->cdev.ops = &fops;
        my_dev->cdev.owner = THIS_MODULE;
        ret = cdev_add( &my_dev->cdev, devno, 1 );
        if( ret < 0 )
        {
          printk(KERN_DEBUG "register device failed with %d/n", ret);
          return ret;
        }
        printk(KERN_DEBUG "%s:register device OK/n",DEVICE);

        // 3. 分配本驱动要使用的内存
        my_dev->index = 0;
        my_dev->size = 128;
        my_dev->buffer = kmalloc( my_dev->size, GFP_KERNEL );
        if( NULL == my_dev->buffer )
        {
          printk(KERN_DEBUG "kmalloc failed/n");
          return -ENOMEM;
        }
        printk(KERN_DEBUG "%s:kmalloc buffer OK/n",DEVICE);

        // 4. 初始化信号量
        init_MUTEX( &(my_dev->sem) );
        printk(KERN_DEBUG "%s:init semaphore OK/n",DEVICE);

        // 5. 初始化等待队列头
        init_waitqueue_head(&my_dev->rq);

        // 6. Remap IIC 寄存器
        address_map();

        // 7. 设置 s3c2410 IIC
        unsigned int tmp = ioread32( R_GPEUP );
        tmp |= 0xc000;          //Pull-up disable
        iowrite32( tmp, R_GPEUP );

        tmp = ioread32( R_GPECON );
        tmp |= 0xa0000000;      //GPE15:IICSDA , GPE14:IICSCL
        iowrite32( tmp, R_GPECON );

        return 0;
}

static void __exit IIC_exit(void)
{
        dev_t devno = MKDEV( major, minor );
        // 以相反的顺序清除
        address_unmap();
        kfree( my_dev->buffer );
        cdev_del( &my_dev->cdev );
        kfree( my_dev );
        printk(KERN_DEBUG "%s:kfree OK/n",DEVICE);
        unregister_chrdev_region( devno, 1 );
        printk(KERN_DEBUG "%s:unregister device OK/n",DEVICE);
}

static void set_slave_recv_mode(void)
{
        iowrite8( 0xE2, R_IICCON ); // 使能ACK,使能中断
        iowrite8( 0xAA, R_IICADD ); // 从器件地址
        iowrite8( 0x10, R_IICSTAT); // 设置从器件接收模式
        barrier(); // 强制写入寄存器
}

int IIC_open(struct inode *inode, struct file *file)
{
        struct IIC_dev *dev = container_of(inode->i_cdev, struct IIC_dev, cdev);
        file->private_data = dev;

        if( down_interruptible(&dev->sem) )
                return -ERESTARTSYS;

        set_slave_recv_mode();

        int ret = request_irq( IRQ_IIC, interrupt_handle,
                                    SA_INTERRUPT, DEVICE, (void*)dev );
        if( ret )
        {
                printk( KERN_INFO "I2C: can't get assigned irq %d/n", IRQ_IIC );
        }
        return 0;
}

int IIC_read(struct file *file, char* buf, size_t count, loff_t *f_pos)
{
        struct IIC_dev *dev = file->private_data;
        size_t val = DATA_LEN;

        while( dev->index < val )
        {
                if( file->f_flags & O_NONBLOCK )
                        return -EAGAIN;
                // 在这里准备睡眠,等待条件为真
                if( wait_event_interruptible(dev->rq, (dev->index >= val)) )
                        return -ERESTARTSYS; // 返回非0表示被信号中断
        }
        if( copy_to_user(buf, dev->buffer, val) )
                return -EFAULT;
        memset( dev->buffer, 0, dev->size );
        dev->index = 0;

        set_slave_recv_mode();
        return val;
}

int IIC_release(struct inode *inode, struct file *file)
{
        struct IIC_dev *dev = file->private_data;

        iowrite8( 0x0, R_IICCON );
        iowrite8( 0x0, R_IICADD );
        iowrite8( 0x0, R_IICSTAT);
        barrier(); // 强制写入寄存器

        memset( dev->buffer, 0, dev->size );
        dev->index = 0;

        free_irq( IRQ_IIC, NULL );

        up(&dev->sem);
        return 0;
}

unsigned int IIC_poll(struct file* file, poll_table* wait)
{
        struct IIC_dev *dev = file->private_data;
        unsigned int mask = 0, val = DATA_LEN;

        poll_wait(file,&dev->rq,wait);
        if( dev->index >= val )
                mask |= POLLIN | POLLRDNORM;
        return mask;
}

irqreturn_t interrupt_handle( int irq, void* dev_id, struct pt_regs* regs )
{
        struct IIC_dev *dev = dev_id;
        int val = DATA_LEN;

        uint8_t ch = ioread8( R_IICDS );
        if( dev->index == 0 && ch == 0xAA )
                goto ret;
        dev->buffer[dev->index++] = ch;
        if( dev->index >= val )
        {
                wake_up_interruptible( &dev->rq );
                // 直接退出 Slave Receiver 模式
                return IRQ_HANDLED;
        }
ret:
        iowrite8( 0xEF, R_IICCON );
        return IRQ_HANDLED;
}

module_init(IIC_init);
module_exit(IIC_exit);

MODULE_AUTHOR("kf701.ye AT gmail.com");
MODULE_DESCRIPTION("Study");
MODULE_SUPPORTED_DEVICE(DEVICE);
MODULE_LICENSE("GPL");

 

声明: 本文由( 鲁智森也有文化 )原创编译,转载请保留链接: Linux下IIC总线驱动 备忘

Linux下IIC总线驱动 备忘:等您坐沙发呢!

发表评论


QQ群互动

Linux系统与内核学习群:194051772

WP建站技术学习交流群:194062106

魔豆之路QR

魔豆的Linux内核之路

魔豆的Linux内核之路

优秀工程师当看优秀书籍

优秀程序员,要看优秀书!

赞助商广告

友荐云推荐