linux与硬件通信

CPU通过总线和各种设备相连，每种外设都是通过寄存器进行控制。外设可以将寄存器映射到I/O端口或者I/O内存，例如ISA大多映射到端口，而PCI大多映射到内存。这都和RAM内存不同，因为I/O操作都会有边际效应，不能使用高速缓存，也不能发生访问指令重新排序的优化。这不是问题，因为启动内核时告诉了RAM地址和大小，内核不会对其它地址使用高速缓存。

在使用I/O端口前，必须先声明（虽然这不是必须的），确保端口此时别的驱动程序没有使用。不过ARM中都是映射到I/O内存。所以下面只说I/O内存。

对于ram内存，linux都是经过MMU用页表映射的方式访问物理地址的。对于I/O内存基本也是这样的。（不过有的机器，I/O内存访问时没有经过mmu页表，所以也就不需要内核建立页表，arm是不可以这样的，一定要先映射到内核虚拟地址）
还有一种情况：静态映射，即在map_desc结构数组中定义映射关系后，驱动就可以直接用那个虚拟地址的偏移来访问寄存器了。

访问I/O内存：先request_mem_region声明一下（虽然这不是必须的），确保没有其它的驱动程序在使用；再由内核建立页表映射ioremap。
解除映射用iounmap，不再使用I/O内存时用release_mem_region声明。
访问函数：ioread8,ioread16,ioread32;iowrite8,iowrite16,iowrite32;
不应该使用老的接口：readb,readw,readl;writeb,writew,writel;

例子：用上面的知识编写LED驱动程序
头文件：mach/regs-gpio.h定义了大多基地址，可以自定义头文件mach/archer-gpio.h定义详细的寄存器。
源文件：我用misc设备来实现led驱动，在misc/archer-led.c。

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>//cdev
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/slab.h>//kmalloc
//
#include <linux/ioctl.h>
#include <linux/timer.h>
#include <asm/atomic.h>
#include <linux/spinlock.h>
#include <linux/poll.h>
#include <linux/miscdevice.h>
//
#include <mach/map.h>
#include <mach/regs-gpio.h>
#include <mach/archer-gpio.h>


#define DEVICE_NAME "OK6410_LED"
#define DEVICE_MINOR    0
#define LED_ON  0x1
#define LED_OFF 0x2

struct ok6410_led_dev
{
    struct miscdevice misc;
    int open_counter;
    spinlock_t lock;
    struct semaphore sem;
};

struct ok6410_led_dev *ok6410_led_devp;
int device_minor=DEVICE_MINOR;

int ok6410_led_open(struct inode *inode,struct file *filp)
{
    unsigned int reg;
    filp->private_data=ok6410_led_devp;

    spin_lock(&ok6410_led_devp->lock);
    if(ok6410_led_devp->open_counter>0)
    {
        ok6410_led_devp->open_counter++;
        spin_unlock(&ok6410_led_devp->lock);
        printk(KERN_ERR "second open\n");
        return 0;
    }
    ok6410_led_devp->open_counter++;
    spin_unlock(&ok6410_led_devp->lock);
    printk(KERN_ERR "first open\n");
    //

    reg=readl(S3C64XX_GPMCON);
    reg&=(~0xffff);
    reg|=0x1111;
    writel(reg,S3C64XX_GPMCON);
    //four bits
    reg=readl(S3C64XX_GPMDAT);
    //all light
    reg&=(~0xf);
    writel(reg,S3C64XX_GPMDAT);

    return 0;
}

int ok6410_led_release(struct inode *inode,struct file *filp)
{
    unsigned int reg;
    spin_lock(&ok6410_led_devp->lock);
    ok6410_led_devp->open_counter--;
    if(ok6410_led_devp->open_counter>0)
    {
        spin_unlock(&ok6410_led_devp->lock);
        printk(KERN_ERR "second release\n");
        return 0;
    }
    spin_unlock(&ok6410_led_devp->lock);
    printk(KERN_ERR "first release\n");

    reg=readl(S3C64XX_GPMDAT);
    reg|=0xf;
    writel(reg,S3C64XX_GPMDAT);
    reg=readl(S3C64XX_GPMCON);
    reg&=(~0xffff);
    writel(reg,S3C64XX_GPMCON);

    return 0;
}

ssize_t ok6410_led_read(struct file *filp,char __user *buf,
    size_t size,loff_t *ppos)
{
    unsigned char reg;
    struct ok6410_led_dev *dev=filp->private_data;
//    if(down_interrupt(&dev->sem))
//        return -ERESTARTSYS;
    down(&dev->sem);
    reg=readb(S3C64XX_GPMDAT);

/*    if(put_user(reg,(unsigned int *)buf))
        return -EFAULT;
    else
    */
    buf[0]=reg;
    up(&dev->sem);
    return sizeof(unsigned char);
}

ssize_t ok6410_led_write(struct file *filp,const char __user *buf,
    size_t size,loff_t *ppos)
{
    unsigned char reg;
    struct ok6410_led_dev *dev=filp->private_data;
/*    if(get_user(reg,(unsigned int *)buf))
        return -EFAULT;
*/
//    if(down_interrupt(&dev->sem))
//        return -ERESTARTSYS;
    down(&dev->sem);
    reg=readb(S3C64XX_GPMDAT);
    reg&=0xf0;//高位不变
    reg|=buf[0]&0x0f;
    writeb(reg,S3C64XX_GPMDAT);
    up(&dev->sem);
    return sizeof(unsigned char);
}

long ok6410_led_ioctl(struct file *filp,
    unsigned int cmd,unsigned long arg)
{
    unsigned char reg;
    struct ok6410_led_dev *dev=filp->private_data;
    switch(cmd)
    {
        case LED_ON:
            reg=0x00;//0x00 ???
//            if(down_interrupt(&dev->sem))
//                return -ERESTARTSYS;
            down(&dev->sem);
            writeb(reg,S3C64XX_GPMDAT);
            up(&dev->sem);
            break;
        case LED_OFF:
            reg=0x0f;
//            if(down_interrupt(&dev->sem))
//                return -ERESTARTSYS;
            down(&dev->sem);
            writeb(reg,S3C64XX_GPMDAT);
            up(&dev->sem);
            break;
        default:
            return -EINVAL;
    }
    return 0;
}

struct file_operations ok6410_led_fops=
{
    .owner=    THIS_MODULE,
    .open=    ok6410_led_open,
    .release=ok6410_led_release,
    .read=    ok6410_led_read,
    .write=    ok6410_led_write,
//    .ioctl=    ok6410_led_ioctl,
    .unlocked_ioctl = ok6410_led_ioctl,
};
/*
struct miscdevice misc=
{
    .minor= MISC_DYNAMIC_MINOR,
    .name=    DEVICE_NAME,
    .fops=    &ok6410_led_fops,
};
*/
int __init ok6410_led_init(void)
{
    int ret;
    //malloc
    ok6410_led_devp=kmalloc(sizeof(struct miscdevice),GFP_KERNEL);
    if(!ok6410_led_devp)
    {
        printk(KERN_ERR "malloc fail\n");
        return -ENOMEM;
    }
    memset(ok6410_led_devp,0,sizeof(struct ok6410_led_dev));

    //set misc
    if(device_minor==0)
        ok6410_led_devp->misc.minor=MISC_DYNAMIC_MINOR;
    else
        ok6410_led_devp->misc.minor=device_minor;
    ok6410_led_devp->misc.name=DEVICE_NAME;
    ok6410_led_devp->misc.fops=&ok6410_led_fops;

    //register cdev
    ret=misc_register(&ok6410_led_devp->misc);
    if(ret<0)
    {
        printk(KERN_ERR "register fail\n");
        kfree(ok6410_led_devp);
        return ret;
    }

    ok6410_led_devp->open_counter=0;
    spin_lock_init(&ok6410_led_devp->lock);
    sema_init(&ok6410_led_devp->sem,1);

    printk(KERN_ERR "register success\n");
    return 0;
}

void __exit ok6410_led_exit(void)
{
    misc_deregister(&ok6410_led_devp->misc);
    kfree(ok6410_led_devp);
}

MODULE_AUTHOR("Archer");
MODULE_LICENSE("Dual BSD/GPL");

module_param(device_minor,int,S_IRUGO);

module_init(ok6410_led_init);
module_exit(ok6410_led_exit);