FL2440开发板LEd驱动及其应用程序

最新推荐文章于 2020-04-24 01:35:14 发布
最新推荐文章于 2020-04-24 01:35:14 发布
阅读量508 收藏 1
点赞数
分类专栏： driver
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KarinaCristall/article/details/51896566
版权

LED驱动：

#include <linux/module.h>   /* Every Linux kernel module must include this head */
#include <linux/init.h>     /* Every Linux kernel module must include this head */
#include <linux/kernel.h>   /* printk() */
#include <linux/fs.h>       /* struct fops */
#include <linux/errno.h>    /* error codes */
#include <linux/cdev.h>     /* cdev_alloc()  */
#include <asm/io.h>         /* ioremap()  */
#include <linux/ioport.h>   /* request_mem_region() */

#include <asm/ioctl.h>      /* Linux kernel space head file for macro _IO() to generate ioctl command  */
#ifndef __KERNEL__
#include <sys/ioctl.h>      /* User space head file for macro _IO() to generate ioctl command */
#endif
//#include <linux/printk.h> /* Define log level KERN_DEBUG, no need include here */


#define DRV_AUTHOR                "Guo Wenxue <guowenxue@gmail.com>"		//作者信息
#define DRV_DESC                  "S3C24XX LED driver"				//驱动信息

#define DEV_NAME                  "led"						//驱动名
#define LED_NUM                   4						

/* Set the LED dev major number */
#ifndef LED_MAJOR
#define LED_MAJOR                 0			//主设备号相关宏
#endif

#define DRV_MAJOR_VER             1		
#define DRV_MINOR_VER             0
#define DRV_REVER_VER             0

#define DISABLE                   0
#define ENABLE                    1

#define GPIO_INPUT                0x00
#define GPIO_OUTPUT               0x01


#define PLATDRV_MAGIC             0x60					//魔术字
#define LED_OFF                   _IO (PLATDRV_MAGIC, 0x18)
#define LED_ON                    _IO (PLATDRV_MAGIC, 0x19)

#define S3C_GPB_BASE              0x56000010				//GPB基地址及偏移地址
#define GPBCON_OFFSET             0
#define GPBDAT_OFFSET             4
#define GPBUP_OFFSET              8
#define S3C_GPB_LEN               0x10        /* 0x56000010~0x56000020  */

int led[LED_NUM] = {5,6,8,10};  /* Four LEDs use GPB5,GPB6,GPB8,GPB10 */

static void __iomem *s3c_gpb_membase;					//定义iomem*类型变量


#define s3c_gpio_write(val, reg) __raw_writel((val), (reg)+s3c_gpb_membase) //虚拟地址读写到物理地址
#define s3c_gpio_read(reg)       __raw_readl((reg)+s3c_gpb_membase)

int dev_count = ARRAY_SIZE(led); //设备总数
int dev_major = LED_MAJOR;	//主设备
int dev_minor = 0;		//次设备
int debug = DISABLE;

static struct cdev      *led_cdev; //定义结构体指针

static int s3c_hw_init(void)		//初始化函数
{
    int          i;
    volatile unsigned long  gpb_con, gpb_dat, gpb_up;

    if(!request_mem_region(S3C_GPB_BASE, S3C_GPB_LEN, "s3c2440 led")) //判断是否成功申请一段内存空间
    {
        return -EBUSY;
    }

    if( !(s3c_gpb_membase=ioremap(S3C_GPB_BASE, S3C_GPB_LEN)) )		//判断虚拟地址到物理地址的映射
    {
        release_mem_region(S3C_GPB_BASE, S3C_GPB_LEN);
        return -ENOMEM;
    }

    for(i=0; i<dev_count; i++)
    {
        /* Set GPBCON register, set correspond GPIO port as input or output mode  */
        gpb_con = s3c_gpio_read(GPBCON_OFFSET);
        gpb_con &= ~(0x3<<(2*led[i]));   /* Clear the currespond LED GPIO configure register */
        gpb_con |= GPIO_OUTPUT<<(2*led[i]); /* Set the currespond LED GPIO as output mode */
        s3c_gpio_write(gpb_con, GPBCON_OFFSET);

        /* Set GPBUP register, set correspond GPIO port pull up resister as enable or disable  */
        gpb_up = s3c_gpio_read(GPBUP_OFFSET);
        gpb_up |= (0x1<<led[i]);  /* Disable pull up resister */
        s3c_gpio_write(gpb_up, GPBUP_OFFSET);

        /* Set GPBDAT register, set correspond GPIO port power level as high level or low level */
        gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);
        gpb_dat |= (0x1<<led[i]);  /* This port set to high level, then turn LED off */
        s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);
    }

    return 0;
}


static void turn_led(int which, unsigned int cmd)		//led函数的操作
{
    volatile unsigned long  gpb_dat;

    gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);

    if(LED_ON == cmd)						
    {
        gpb_dat &= ~(0x1<<led[which]); /*  Turn LED On */
    }
    else if(LED_OFF == cmd)
    {
        gpb_dat |= (0x1<<led[which]);  /*  Turn LED off */
    }

    s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);
}

static void s3c_hw_term(void)					//清除led操作函数
{
    int                     i;
    volatile unsigned long  gpb_dat;

    for(i=0; i<dev_count; i++)
    {
        gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);
        gpb_dat |= (0x1<<led[i]);  /* Turn LED off */
        s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);
    }

    release_mem_region(S3C_GPB_BASE, S3C_GPB_LEN);		//释放I/O内存
    iounmap(s3c_gpb_membase);					//iounmap函数取消iounmap()做的映射
}


static int led_open(struct inode *inode, struct file *file)	//LED开启函数
{
    int minor = iminor(inode);					//获取次设备号

    file->private_data = (void *)minor;				//保存到一个全局变量

    printk(KERN_DEBUG "/dev/led%d opened.\n", minor);
    return 0;

static int led_release(struct inode *inode, struct file *file)	//LED关闭函数
{
    printk(KERN_DEBUG "/dev/led%d closed.\n", iminor(inode));

    return 0;
}

static void print_help(void)							//帮助信息
{
    printk("Follow is the ioctl() commands for %s driver:\n", DEV_NAME);
    printk("Turn LED on command  : %u\n", LED_ON);
    printk("Turn LED off command : %u\n", LED_OFF);

    return;
}

static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)	//ioctl函数
{
    int which = (int)file->private_data;					//接收次设备号

    switch (cmd)								//判断LED开关
    {
        case LED_ON:

            turn_led(which, LED_ON);
            break;

        case LED_OFF:
            turn_led(which, LED_OFF);
            break;
    
        default:
            printk(KERN_ERR "%s driver don't support ioctl command=%d\n", DEV_NAME, cmd);
            print_help();
            break;
    }

    return 0;
}


static struct file_operations led_fops = 				//fops函数
{
    .owner = THIS_MODULE,
    .open = led_open,
    .release = led_release,
    .unlocked_ioctl = led_ioctl,
};

static int __init s3c_led_init(void)					//init函数
{
    int                    result;
    dev_t                  devno;

    if( 0 != s3c_hw_init() )						//做初始化的判断
    {
        printk(KERN_ERR "s3c2440 LED hardware initialize failure.\n");
        return -ENODEV;
    }

    /*  Alloc the device for driver */
    if (0 != dev_major) /*  Static */					//静态分配主，次设备号转化为dev_t设备编号
    {
        devno = MKDEV(dev_major, 0);
        result = register_chrdev_region (devno, dev_count, DEV_NAME);
    }
    else
    {
        result = alloc_chrdev_region(&devno, dev_minor, dev_count, DEV_NAME);//动态分配主，次设备号
        dev_major = MAJOR(devno);
    }

    /*  Alloc for device major failure */
    if (result < 0)					//分配失败则打印
    {
        printk(KERN_ERR "S3C %s driver can't use major %d\n", DEV_NAME, dev_major);
        return -ENODEV;
    } 
    printk(KERN_DEBUG "S3C %s driver use major %d\n", DEV_NAME, dev_major);

    if(NULL == (led_cdev=cdev_alloc()) )   //led_cdev分配失败打印
    {
        printk(KERN_ERR "S3C %s driver can't alloc for the cdev.\n", DEV_NAME);
        unregister_chrdev_region(devno, dev_count);
        return -ENOMEM;
    }
    
    led_cdev->owner = THIS_MODULE;  //分配成功，进行参数定义
    cdev_init(led_cdev, &led_fops); //链接led_cdev和led_fops

    result = cdev_add(led_cdev, devno, dev_count);	//添加内存
    if (0 != result)					//出错打印
    {   
        printk(KERN_INFO "S3C %s driver can't reigster cdev: result=%d\n", DEV_NAME, result); 
        goto ERROR;
    }

            
    printk(KERN_ERR "S3C %s driver[major=%d] version %d.%d.%d installed successfully!\n", 	
            DEV_NAME, dev_major, DRV_MAJOR_VER, DRV_MINOR_VER,DRV_REVER_VER);			//打印成功
    return 0;


ERROR:										//内存出错执行
    printk(KERN_ERR "S3C %s driver installed failure.\n", DEV_NAME);				
    cdev_del(led_cdev);
    unregister_chrdev_region(devno, dev_count);
    return result;
}

static void __exit s3c_led_exit(void)				//led退出函数
{
    dev_t devno = MKDEV(dev_major, dev_minor);

    s3c_hw_term();					//调用清除LED操作函数

    cdev_del(led_cdev);					//撤销
    unregister_chrdev_region(devno, dev_count);

    printk(KERN_ERR "S3C %s driver version %d.%d.%d removed!\n", 
            DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER,DRV_REVER_VER);

    return ;
}



/* These two functions defined in <linux/init.h> */
module_init(s3c_led_init);
module_exit(s3c_led_exit);

module_param(debug, int, S_IRUGO);
module_param(dev_major, int, S_IRUGO);

MODULE_AUTHOR(DRV_AUTHOR);
MODULE_DESCRIPTION(DRV_DESC);
MODULE_LICENSE("GPL");
以上就是我们的LED相关驱动模块函数。

先是调用module_init函数，在调用s3c_led_init函数，这个函数会调用 s3c_hw_init进行初始化；接着s3c_led_init函数会进行分配主次设备号，按照传入的参数判断是动态分配或者是静态分配；再者是分配结构体，如果链接owner成功就可接着连接fops；然后是ON 和OFF的实现功能，使用ioctl与装入卸载次设备号驱动以及模块信息和fops中与主次设备号结构体链接，ioctl通过传参来实现相应的功能；最后进行撤销。

Makefile编写：
CC=/opt/buildroot-2012.08/arm920t/usr/bin/arm-linux-gcc
KDIR?=/home/Ciel/fl2440/kernel/linux-3.0
obj-m:=s3c_led.o
default:
      $(MAKE) -C $(KDIR) M=`pwd` modules
      make clean
  
clean:
      rm -f *.ko.* *.o *mod.c *.order *.symvers

make会生   .ko  文件 这就是我们所需要加载的驱动模块。

应用程序：

#include <stdio.h>
   #include <sys/ioctl.h>
   #include <sys/stat.h>
   #include <unistd.h>
    #include <stdarg.h>
   #include <errno.h>
   #include <sys/types.h>
   #include <fcntl.h>
  #include <string.h>
 
#define LED_NUM         4
#define DEVNAME_LEN     10
  

 #define PLATDRV_MAGIC             0x60
 #define LED_OFF                   _IO (PLATDRV_MAGIC, 0x18)
 #define LED_ON                    _IO (PLATDRV_MAGIC, 0x19

 int main(int argc, char **argv)
 {
     int fd[LED_NUM];

int   i;

int   j ;

     char devname[DEVNAME_LEN] = {0};
 
     for(i = 0; i < LED_NUM; i++)
    {
         snprintf(devname, sizeof(devname), "/dev/led%i",i);
          fd[i] = open(devname, O_RDWR,755);
         if(fd[i] < 0)
         {
             printf("Can not open %s: %s", devname, strerror(errno));
             for(j = 0; j < i; j++)
              {
                  if(fd[j] > 0)
                      close(fd[j]);
              }
              return -1;
          }
      }
  
     while(1)
      {
          for(i = 0; i < LED_NUM; i++)
          {
              ioctl(fd[i], LED_ON);
              sleep(1);
              ioctl(fd[i], LED_OFF);
          }
      }
  
      for(i = 0; i < LED_NUM; i++)
      {
          close(fd[i]);
      }
     return 0;
}

应用程序使用交叉编译器编译得到a.out。

在我们的开发板上将  .ko文件和 a.out 文件 tftp 过去。这是板子上会有我们这两个文件，注意这两个文件的权限需要改成可执行。

insmod 文件名.ko  就可以看到我们的主设备号。  如major=251  。

接着我们要手动创建结点：

mknod  /dev/led0 c 251 0

mknod /dev/led1 c 251 1

mknod /dev/led2 c 251 2

mknod /dev/led3 c 251 3

这时我们可以查看我们的设备

ls -l  dev/led*

最后 ./a.out   LED灯就能在开发板上跑起来，这就可以称为跑马灯了吧！

KarinaCristall
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符驱动入门，FL2440-LED驱动
WuYujun's blog
05-04 384
Linux内核里，绝大部分的设备都是字符设备，所写的驱动99%也都是处理字符设备。 一、字符设备驱动 字符设备的驱动大致步骤： 1、相应的设备初始化(根据开发板的原理图以及芯片datasheet配置引脚等)--> 2、注册字符设备主次设备号[register_chrdev_region()或alloc_chrdev_region()]--> 3、分配字符结构体[struc...
fl2440字符设备led驱动
weixin_34348111的博客
05-10 92
首先要明白字符设备驱动注册的基本流程 当我们调用insomd命令加载驱动后，驱动程序从module_init函数开始执行：硬件初始化 -> 申请主次设备号-> 定义fops(file_operations)结构体 -> 申请cdev结构体并把fops结构体嵌入cdev结构体中与之绑定 -> cdev字符设备的注册。 有一点需要明确的是，在Linux内核中，所有的设备都...
fl2440led驱动
konjikinoyami的博客
11-14 515
先看代码吧 #include // 固定格式 #include //固定格式 #include // printk() #include //struct fops #include // error codes #include // cdev_alloc() #include // ioremap()
fl2440——驱动学习-LED驱动程序代码分析
C_Aya的博客
03-27 812
1、驱动入口函数接下来从Linux驱动的入口函数module_init(s3c_led_init);开始学习。可以看到这是由s3c_led_init开始。函数如下：static int __init s3c_led_init(void) /*一般用__init修饰的变量或者函数会编译到专门的一个段里面去，这个段的数据和函数只有在kernel初始化的时候会被调用，以后一定不会被使用，kernel可
linux驱动开发fl2440开发板按键驱动
LYX_WIN
07-30 956
linux驱动开发fl2440开发板按键驱动 [leiyuxing@centos6 input_kbd]$ ls kbd_device.c kbd_driver.c event_button.c kbd_driver.h Makefile 驱动相关头文件kbd_driver.h: /************************************************
FL2440开发板LED实验演示
09-12
根据给定的信息，本文将对“FL2440开发板LED实验演示”进行详细的解析，包括实验背景、实现原理、代码解读以及实验环境搭建等内容。 ### 实验背景 本次实验的目标是在FL2440开发板上实现四个LED灯的交替闪烁功能。...
基于fl2440 的led驱动
12-08
在本文中，我们将深入探讨如何在基于FL2440微控制器的系统上实现LED驱动程序，以及如何进行测试和调试。FL2440是一款常见的S3C2440 ARM9微处理器，常用于嵌入式系统设计，如开发板。在Linux 3.0环境下，LED驱动的...
led驱动FL2440开发板
07-08
点灯的驱动程序，可以用键盘的数字键0 1 2 3控制开发板的四展灯 //on 表示灯亮，off表示灯亮，2.6.12内核制作
FL2440开发板准备实验
03-26
本实验旨在帮助学习者理解并掌握基于FL2440开发板的基本硬件连接、驱动安装和软件配置等关键步骤，为后续更深入的学习和项目开发奠定坚实的基础。 ### 1.1 实验一：硬件连接 #### 1.1.1 实验目的 - 建立开发环境...
LED驱动的简单实现（fl2440)
zhangqiao336的专栏
03-18 532
本片文章教大家如何入门一个简单的驱动程序。我们都知道驱动程序是用来操作设备来完成相应的功能的，所以它应该是由内核来调用的。 我们先看如何从用户空间来调用一个驱动程序，它的具体流程是怎样的? Created with Raphaël 2.1.2应用程序系统调用接口内核设备操作yes驱动代码部分我们先来认识一下这两个函数： module_init(s3c_led_init); module_exi
TQ210开发板-led驱动
fengfengzhi的专栏
08-01 1726
TQ210的led驱动 在天嵌的TQ210开发板上按照天嵌提供的说明书把uboot，内核，文件系统都做好后，今天尝试写一个led的驱动， 1、看电路图，找到led连接哪个引脚。由图可见，开发板上的两个led分别连接在GPC0_3和GPC0_4的两个引脚上。 2、打开s5pv210的芯片手册，搜索一下GPC0CON[4]在2-48页找到GPC0CON的地址为 ：Address = 0xE0
FL2440开发板 platform_led驱动及应用程序
KarinaCristall的博客
07-15 495
这是我们的驱动程序 #include "s3c_driver.h" #define DRV_AUTHOR                "Guo Wenxue " //作者信息 #define DRV_DESC                  "S3C24XX LED driver" //驱动信息 /* Driver version*/ #define DRV_MA
S3C2440开发板LED驱动——ioremap 映射
kulala082的专栏
11-30 374
刚开始学字符设备驱动，感觉最难的是驱动和底层硬件的连接。Linux上的驱动程序，是基于操作系统之上的，他并不直接和底层的硬件打交道，但是我们写的驱动必须能使硬件“跑”起来，即与硬件紧密相连。 就拿最简单的LED驱动来说，我们的驱动程序是在虚拟的内存上面跑的，但是最终，LED的点亮还是必须靠GPIO管脚的高低电平来控制。那么，我们的虚拟的内存怎么才能和实际的硬件上面的寄存器对应起来呢？
fl2440LED驱动程序总结
tongsean的专栏
09-16 657
上篇文章写的是2440的应用程序，这篇文章总结下学习2440LED驱动程序的经验吧。 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Linux下fl2440之led驱动编写以及测试
qicheng777的博客
04-06 1004
=============================================== 操作系统：center os 平台：fl2440 内核版本：linux 3.0.54 交叉编译器版本：2012.08 =============================================== 驱动：        程序即添加到操作系统中的一小块代码，其中包含有关硬件设
在Android开发板跑一个LED驱动的历程(个人笔记)
手中沙的博客
04-24 1537
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） 在Android开发板跑一个LED驱动的历程(个人笔记) 1. 板子端, 放置驱动程序 1.1 编写一个驱动程序 驱动程序的编写上, 与Linux是一致的, 无需关心任何Android相关的事物. 代码如下: #include <linux/init.h> #include <linux/module.h&g...
我的led驱动OK6410 飞凌开发板
道亦无名
05-23 3220
是个典型的字符设备驱动
fl2440驱动学习——LED驱动代码分析
萬象森羅，能者獨秀！
03-23 531
前两天对helloworld驱动进行了学习，现在正式进入到FL2440驱动的学习。还是按照程序入门的步骤，现在对led驱动做一个分析总结。Led设备属于字符设备，字符设备驱动程序适合于大多数简单的硬件设备，因此作为驱动入门学习起来更容易理解和掌握。 1.s3c_led_init()函数 分析一个驱动代码，首先应该找到驱动初始化函数，在helloworld驱动中即hello_in
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值