字符设备驱动（一）---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[];//在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 :
             GPFCON &= ~((0x3 << ( * )) | (0x3 << ( * )) | (0x3 << ( * )));
             GPFCON |= ((0x1 << ( * )) | (0x1 << ( * )) | (0x1 << ( * )));

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

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

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

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

             GPFDAT &= ~( << );

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

             GPFDAT &= ~( << );

             down(&leds_lock);
             leds_status &= ~( << );
             up(&leds_lock);
             break;
     }

     return ;
 }

 /* 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 :
             copy_to_user(buff, (const void *)&leds_status, );
             break;
         case :
             down(&leds_lock);
             val = leds_status & 0x1;
             up(&leds_lock);
             copy_to_user(buff, (const void *)&val, );
             break;
         case :
             down(&leds_lock);
             val = (leds_status>>) & 0x1;
             up(&leds_lock);
             copy_to_user(buff, (const void *)&val, );
             break;
         case :
             down(&leds_lock);
             val = (leds_status>>) & 0x1;
             up(&leds_lock);
             copy_to_user(buff, (const void *)&val, );
             break;
     }
     return ;
 }

 /* 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 :
             if ( == val) //亮灯
                 GPFDAT &= ~(( << ) | ( << ) | ( << ));
             else//灭灯
                 GPFDAT |= ( << ) | ( << ) | ( << );
             down(&leds_lock);
             leds_status = val;
             up(&leds_lock);
             break;
         case :
             if (val == )
             {
                 GPFDAT &= ~(<<);
                 down(&leds_lock);
                 leds_status &= ~(<<);
                 up(&leds_lock);
             }
             else
             {
                 GPFDAT |= ( << );
                 down(&leds_lock);
                 leds_status |= (<<);
                 up(&leds_lock);
             }
             break;
         case :
             if (val == )
             {
                 GPFDAT &= ~( << );
                 down(&leds_lock);
                 leds_status &= ~( << );
                 up(&leds_lock);
             }
             else
             {
                 GPFDAT |= ( << );
                 down(&leds_lock);
                 leds_status |= ( << );
                 up(&leds_lock);
             }
             break;
         case :
             if(val == )
             {
                 GPFDAT &= ~( << );
                 down(&leds_lock);
                 leds_status &= ~( << );
                 up(&leds_lock);
             }
             else
             {
                 GPFDAT |= ( << );
                 down(&leds_lock);
                 leds_status |= ( << );
                 up(&leds_lock);
             }
             break;
     }

     return ;
 }

 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 = ;

     /* 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 < ) {
         printk(DEVICE_NAME " can't register major number!!!\n");
         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[] = class_device_create(leds_class, NULL, MKDEV(LED_MAJOR, ), NULL, "leds");
     if (unlikely(IS_ERR(leds_class_devs[])))
         return PTR_ERR(leds_class_devs[]);
     for(minor = ; minor < ; 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\n");
     return ;
 }

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

     return ;
 }

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

 MODULE_LICENSE("Dual BSD/GPL");