字符设备驱动（一）---led

一、总体架构

　　

二、硬件电路

　　1.硬件原理图

　　

　　

　　2.寄存器配置

　　

三、代码编写

　　写linux的设备驱动操作的是系统的虚拟地址，并不是像裸机程序一样操作的是物理地址。

　　物理地址要映射成虚拟地址，就要用到ioremap函数，用来把物理地址映射成虚拟地址。

　　3.1 确定主设备号

　　　　执行命令 cat proc/devices 可以查看到已经用了的主设备号，给自己的设备定义设备号的时候，可以选用没有被设备使用的主设备号。或者可以写0，让系统自动给我们的设备分配主设备号。

　　3.2 设备节点的创建方法

　　　　a. 手动创建

　　　　　　

　　　　b. 自动创建

　　　　　　应用程序里面应用udev机制

　　　　　　mdev机制：mdev会根据系统的信息，sys目录下有很多系统的信息。注册一个驱动程序的时候，会在此目录下生成设备的信息，mdev可以根据设备的信息自动创建设备节点。

　　　　　　

　　　　　　

　　3.3 源码

/*
 * =====================================================================================
 *       Filename:  led.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年05月22日 11时40分23秒
 *         Author:  YOUR NAME (), 
 *   Organization:  
 * =====================================================================================
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/class.h>
#include <linux/io.h>

/* 1.建立模块
 *    1.1 模块初始化模板
 *        1.1.1 映射寄存器
 *        1.1.2 注册设备驱动，告诉内核
 *            1.1.1.1 主设备号
 *        1.1.3 设备类的建立
 *                1.1.1.2.1 创建变量：设备类和设备
 *                1.1.1.2.2 创建设备类
 *                1.1.1.2.3 在设备类下创建设备
 *    1.2 模块退出模板
 *
 * 2.建立文件操作
 *    2.1 文件打开和关闭函数
 *        2.1.1 文件打开函数
 *    2.2 文件读写函数
 *        2.2.1 文件读函数
 *        2.2.2 文件写函数
 *            2.2.2.1 设置GPIO引脚输出的数据
 *                2.2.2.1.1 从用户空间读取数据
 *    2.3 创建文件操作结构体
 */

#define DEVICE_NAME        "leds"    /* 加载模式后，执行"cat /proc/devices"命令看到设备的名称 */
#define LED_MAJOR        231        /* 主设备号 */
static unsigned long gpio_va;    //次设备号

/* 1.1.1.2.1 创建变量：设备类和设备 */
static struct class *leds_class; //创建led类
static struct class_device *leds_class_devs[4];//在led类下面创建设备


static char leds_status = 0x0;
static DECLARE_MUTEX(leds_lock);    //定义赋值

//volatile unsigned long *gpfcon = NULL;
//volatile unsigned long *gpfdat = NULL;
#define GPIO_OFT(x) ((x) - 0x56000000)
#define GPFCON  (*(volatile unsigned long *)(gpio_va + GPIO_OFT(0x56000050)))
#define GPFDAT  (*(volatile unsigned long *)(gpio_va + GPIO_OFT(0x56000054)))

/* 2.1.1 文件打开函数 */
static int led_open(struct inode *inode, struct file *filp)
{
    int minor = MINOR(inode->irdev);//获取次设备号

    switch(minor)
    {
        case 0:
            GPFCON &= ~((0x3 << (4 * 2)) | (0x3 << (5 * 2)) | (0x3 << (6 * 2)));
            GPFCON |= ((0x1 << (4 * 2)) | (0x1 << (5 * 2)) | (0x1 << (6 * 2)));

            //初始化状态：LED灯全亮，gpf引脚输出0
            GPFDAT &= ~((1<<4) | (1<<5) | (1<<6));

            down(&leds_lock);
            leds_status = 0x0;
            up(&leds_lock);
            break;
        case 1:
            GPFCON &= ~(0x3 <<(4 * 2));
            GPFCON |= (1 << (4 * 2));

            //初始化状态：LED4亮，gpf4引脚输出0
            GPFDAT &= ~(1 << 4);

            down(&leds_lock);
            leds_status &= ~(1 << 0);
            up(&leds_lock);
            break;
        case 2:
            GPFCON &= ~(0x3 << (5 * 2));
            GPFCON |= (1 << (5 * 2));
            
            GPFDAT &= ~(1 << 5);
            
            down(&leds_lock);
            leds_status &= ~(1 << 1);
            up(&leds_lock);
            break;
        case 3:
            GPFCON &= ~(0x3 << (6 * 2));
            GPFCON |= (1 << (6 * 2));
            
            GPFDAT &= ~(1 << 6);
            
            down(&leds_lock);
            leds_status &= ~(1 << 2);
            up(&leds_lock);
            break;
    }

    return 0;
}


/* 2.2.1 文件读函数 */
static ssize_t led_read(struct file *filp, char __user *buff, ssize_t count, loff_t *oops)
{
    int minor = MINOR(filp->f_dentry->d_inode->i_rdev);//获取次设备号
    char val;

    switch(minor)
    {
        case 0:
            copy_to_user(buff, (const void *)&leds_status, 1);
            break;
        case 1:
            down(&leds_lock);
            val = leds_status & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        case 2:
            down(&leds_lock);
            val = (leds_status>>1) & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        case 3:
            down(&leds_lock);
            val = (leds_status>>2) & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
    }
    return 1;
}

/* 2.2.2 文件写函数 */
static ssize_t led_wirte(struct file *filp, const char __user *buff, ssize_t count, loff_t *oops)
{
    int minor = MINOR(file->fdentry->d_inode->i_rdev);
    char val;

    /* 2.2.2.1 设置GPIO引脚输出 */
        /* 2.2.2.1.1 从用户空间读取设置的数据 */
    copy_from_user(&val, buf, conut);

    switch(minor)
    {
        case 0:
            if (0 == val) //亮灯
                GPFDAT &= ~((1 << 4) | (1 << 5) | (1 << 6));
            else//灭灯
                GPFDAT |= (1 << 4) | (1 << 5) | (1 << 6); 
            down(&leds_lock);
            leds_status = val;
            up(&leds_lock);
            break;
        case 1:
            if (val == 0)
            {
                GPFDAT &= ~(1<<4);
                down(&leds_lock);
                leds_status &= ~(1<<0);
                up(&leds_lock);
            }
            else
            {
                GPFDAT |= (1 << 4);
                down(&leds_lock);
                leds_status |= (1<<0);                
                up(&leds_lock);
            }
            break;
        case 2:
            if (val == 0)
            {
                GPFDAT &= ~(1 << 5);
                down(&leds_lock);
                leds_status &= ~(1 << 1);
                up(&leds_lock);
            }
            else
            {
                GPFDAT |= (1 << 5);
                down(&leds_lock);
                leds_status |= (1 << 1); 
                up(&leds_lock);
            }
            break;
        case 3:
            if(val == 0)
            {
                GPFDAT &= ~(1 << 6);
                down(&leds_lock);
                leds_status &= ~(1 << 2);
                up(&leds_lock);
            }
            else
            {
                GPFDAT |= (1 << 6);
                down(&leds_lock);
                leds_status |= (1 << 2);                
                up(&leds_lock);
            }
            break;
    }

    return 1;
}

struct file_operations led_drv_fops = {
    .owner = THIS_MODULE;
    .open = led_open;
    .release = led_release;
    .read = led_read;
    .write = led_wirte;
}


/* 1.1 模块初始化函数 */
static int __init led_init(void)
{
    int ret;
    int minor = 0;

    /* 1.1.1 映射寄存器 */
    gpio_va = ioremap(0x56000000, 0x100000);
    if (!gpio_va) {
        return -EIO;
    }


    /* 1.1.2 注册字符设备，将主设备号与file_operations结构联系起来 */
    /* LED_MAJOR可以设为0，表示由内核自动分配主设备号 */
    ret = register_chrdev(LED_MAJOR, DEVICE_NAME, &led_drv_fops);
    if (ret < 0) {
        printk(DEVICE_NAME " can't register major number!!!
");
        return ret;
    }

    /* 1.1.3 设备类的创建 */
    leds_class = class_create(THIS_MODULE, "leds");
    if (IS_ERR(leds_class))
        return PTR_ERR(leds_class);

    /* 1.1.4 在leds类下面创建一个设备 */
    /* mdev 会自动创建一个/dev/leds 设备节点 */
    leds_class_devs[0] = class_device_create(leds_class, NULL, MKDEV(LED_MAJOR, 0), NULL, "leds");
    if (unlikely(IS_ERR(leds_class_devs[0])))
        return PTR_ERR(leds_class_devs[0]);
    for(minor = 1; minor < 4; minor++)
    {
        leds_class_devs[minor] = class_device_create(leds_class, NULL, MKDEV(LED_MAJOR, minor), NULL, "led%d", minor);
        if (unlikely(IS_ERR(leds_class_devs[minor])))
            return PTR_ERR(leds_class_devs[minor]);
    }

    printk(DEVICE_NAME " initialized
");
    return 0;
}

/* 1.2 模块退出函数 */
static void __exit led_exit(void)
{
    int minor;
    for(minor = 0; minor < 4; minor++)
    {
        class_device_unregister(leds_class_devs[minor]);
    }
    class_destroy(leds_class);
    unregister_chrdev(LED_MAJOR, DEVICE_NAME);//卸载
    iounmap(gpfcon);

    return 0;
}

module_init(led_init);//定义一个结构体，结构体内有一个函数指针，指向led_init这个入口函数
module_exit(led_exit);

MODULE_LICENSE("Dual BSD/GPL");