当前位置：首页 > 芯闻号 > 充电吧

字符设备驱动-LED驱动

时间：2019-10-01 16:46:01
关键字： 框架    驱动开发   
手机看文章

扫描二维码
随时随地手机看文章

[导读]写一个LED点灯驱动： ①框架(在Linux字符设备驱动开发基础已经搭建好) ②完善：硬件的操作 a.看原理图-确定引脚 b.看2440数据手册 c.写代码 写代码注意：裸机

写一个LED点灯驱动： ①框架(在Linux字符设备驱动开发基础已经搭建好) ②完善：硬件的操作

a.看原理图-确定引脚
b.看2440数据手册
c.写代码

写代码注意：裸机代码用的是物理地址PA，驱动代码用的是虚拟地址VA<虚拟地址需要用ioremap函数映射>

驱动程序first_drv.c

#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include 

static struct class *firstdrv_class;
static struct class_device *firstdrv_class_dev;
/*第一步 根据原理图定义操作寄存器*/
volatile unsigned long *gpfcon = NULL;
volatile unsigned long *gpfdat = NULL;

static int first_drv_open(struct inode *inode,struct file *file)
{
    printk("first_drv_openn");
    //配置GPF456为输出引脚
    /*第四步 配置Open函数 将引脚配置为输出模式*/
    *gpfcon &= ~((0x3<<4*2) | (0x3<<5*2) | (0x3<<6*2));
    *gpfcon |=  ((1<<4*2) | (1<<5*2) | (1<<6*2));
    return 0;
}

static ssize_t first_drv_write(struct file *file,const char __user *buf, size_t count,loff_t *ppos)
{
    int val;
    printk("first_drv_writen");
    /*第五步 将用户空间的操作内容传给内核*/
    copy_from_user(&val,buf,count);
    if(1 == val)
    {
        *gpfdat &= ~((1<<4) | (1<<5) | (1<<6));
    }
    else
    {
        *gpfdat |= ((1<<4) | (1<<5) | (1<<6));
    }
    return 0;
}

static struct file_operations first_drv_fops = {
    .owner = THIS_MODULE,   /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open  = first_drv_open,
    .write = first_drv_write,
};

int major;
static int first_drv_init(void)
{
    major = register_chrdev(0,"first_drv",&first_drv_fops);// 注册，告诉内核
    //printk("first_drv_initn");
    firstdrv_class = class_create(THIS_MODULE, "firstdrv");
    firstdrv_class_dev = class_device_create(firstdrv_class, NULL, MKDEV(major, 0), NULL, "xyz"); /* /dev/xyz */
    /*第二步 根据数据手册 入口函数映射VA*/
    gpfcon = (volatile unsigned long *)ioremap(0x56000050,16);
    gpfdat = gpfcon + 1;
    return 0;
}

static void first_drv_exit(void)
{
    unregister_chrdev(major,"first_drv");//卸载

    class_device_unregister(firstdrv_class_dev);
    class_destroy(firstdrv_class);
    /*第三步 出口函数去掉映射*/
    iounmap(gpfcon);
}

module_init(first_drv_init);
module_exit(first_drv_exit);

MODULE_LICENSE("GPL");

驱动测试程序firstdrvtest.c

#include   
#include   
#include   
#include   

/* firstdrvtest on 
 * firstdrvtest off 
 */

int main(int argc, char **argv)
{
    int fd;
    int val = 1;
    fd = open("/dev/xyz",O_RDWR);
    if(fd < 0)
    {
        printf("can't open!n");
    }
    if (argc != 2)
    {
        printf("Usage : n");
        printf("%s n", argv[0] );
        return 0;
    }
    if (strcmp(argv[1],"on") == 0)
    {
        val = 1 ;
    }
    else
    {
        val = 0 ;
    }
    write(fd,&val,4);
    return 0;
}
测试：

①make -编译驱动程序
②arm-linux-gcc -o firstdrvtest firstdrvtest.c -编译驱动测试程序
③cp first_drv.ko /work/nfs_root/czg -拷贝至nfs文件夹
④cp firstdrvtest /work/nfs_root/czg -拷贝至nfs文件夹
⑤rmmod first_drv -卸载先前驱动//cat proc/devices 查看
⑥insmod first_drv.ko -加载驱动
⑦./firstdrvtest -测试驱动

实现对硬件的多种情况操作时：

（1）根据修改传入参数，执行多种操作
（2）通过此设备号的不同来实现，执行不同的硬件操作

驱动程序myleds.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

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


static struct class *leds_class;
static struct class_device  *leds_class_devs[4];


/* bit0<=>D10, 0:亮, 1:灭 
 *  bit1<=>D11, 0:亮, 1:灭 
 *  bit2<=>D12, 0:亮, 1:灭 
 */ 
static char leds_status = 0x0;  
static DECLARE_MUTEX(leds_lock); // 定义赋值

//static int minor;
static unsigned long gpio_va;

#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)))


/* 应用程序对设备文件/dev/leds执行open(...)时，
 * 就会调用s3c24xx_leds_open函数
 */
static int s3c24xx_leds_open(struct inode *inode, struct file *file)
{
    int minor = MINOR(inode->i_rdev); //MINOR(inode->i_cdev);

    switch(minor)
    {
        case 0: /* /dev/leds */
        {
            // 配置3引脚为输出
            //s3c2410_gpio_cfgpin(S3C2410_GPF4, S3C2410_GPF4_OUTP);
            GPFCON &= ~(0x3<<(4*2));
            GPFCON |= (1<<(4*2));

            //s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
            GPFCON &= ~(0x3<<(5*2));
            GPFCON |= (1<<(5*2));

            //s3c2410_gpio_cfgpin(S3C2410_GPF6, S3C2410_GPF6_OUTP);
            GPFCON &= ~(0x3<<(6*2));
            GPFCON |= (1<<(6*2));

            // 都输出0
            //s3c2410_gpio_setpin(S3C2410_GPF4, 0);
            GPFDAT &= ~(1<<4);

            //s3c2410_gpio_setpin(S3C2410_GPF5, 0);
            GPFDAT &= ~(1<<5);
            //s3c2410_gpio_setpin(S3C2410_GPF6, 0);
            GPFDAT &= ~(1<<6);

            down(&leds_lock);
            leds_status = 0x0;
            up(&leds_lock);

            break;
        }

        case 1: /* /dev/led1 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPF4, S3C2410_GPF4_OUTP);
            s3c2410_gpio_setpin(S3C2410_GPF4, 0);

            down(&leds_lock);
            leds_status &= ~(1<<0);
            up(&leds_lock);

            break;
        }

        case 2: /* /dev/led2 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
            s3c2410_gpio_setpin(S3C2410_GPF5, 0);
            leds_status &= ~(1<<1);
            break;
        }

        case 3: /* /dev/led3 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPF6, S3C2410_GPF6_OUTP);
            s3c2410_gpio_setpin(S3C2410_GPF6, 0);

            down(&leds_lock);
            leds_status &= ~(1<<2);
            up(&leds_lock);

            break;
        }

    }

    return 0;
}



static int s3c24xx_leds_read(struct file *filp, char __user *buff, 
                                         size_t count, loff_t *offp)
{
    int minor = MINOR(filp->f_dentry->d_inode->i_rdev);
    char val;

    switch (minor)
    {
        case 0: /* /dev/leds */
        {

            copy_to_user(buff, (const void *)&leds_status, 1);                    
            break;
        }

        case 1: /* /dev/led1 */
        {
            down(&leds_lock);
            val = leds_status & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }

        case 2: /* /dev/led2 */
        {
            down(&leds_lock);
            val = (leds_status>>1) & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }

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

    }

    return 1;
}




static ssize_t s3c24xx_leds_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
    //int minor = MINOR(inode->i_rdev); //MINOR(inode->i_cdev);
    int minor = MINOR(file->f_dentry->d_inode->i_rdev);
    char val;

    copy_from_user(&val, buf, 1);

    switch (minor)
    {
        case 0: /* /dev/leds */
        {            
            s3c2410_gpio_setpin(S3C2410_GPF4, (val & 0x1));
            s3c2410_gpio_setpin(S3C2410_GPF5, (val & 0x1));
            s3c2410_gpio_setpin(S3C2410_GPF6, (val & 0x1));
            down(&leds_lock);
            leds_status = val;
            up(&leds_lock);
            break;
        }

        case 1: /* /dev/led1 */
        {
            s3c2410_gpio_setpin(S3C2410_GPF4, val);

            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<0);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<0);                
                up(&leds_lock);
            }
            break;
        }

        case 2: /* /dev/led2 */
        {
            s3c2410_gpio_setpin(S3C2410_GPF5, val);
            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<1);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<1);                
                up(&leds_lock);
            }
            break;
        }

        case 3: /* /dev/led3 */
        {
            s3c2410_gpio_setpin(S3C2410_GPF6, val);
            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<2);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<2);                
                up(&leds_lock);
            }
            break;
        }

    }

    return 1;
}



/* 这个结构是字符设备驱动程序的核心
 * 当应用程序操作设备文件时所调用的open、read、write等函数，
 * 最终会调用这个结构中指定的对应函数
 */
static struct file_operations s3c24xx_leds_fops = {
    .owner  =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open   =   s3c24xx_leds_open,     
    .read   =   s3c24xx_leds_read,     
    .write  =   s3c24xx_leds_write,    
};

/*
 * 执行insmod命令时就会调用这个函数 
 */
static int __init s3c24xx_leds_init(void)
//static int __init init_module(void)

{
    int ret;
    int minor = 0;

    gpio_va = ioremap(0x56000000, 0x100000);
    if (!gpio_va) {
        return -EIO;
    }

    /* 注册字符设备
     * 参数为主设备号、设备名字、file_operations结构；
     * 这样，主设备号就和具体的file_operations结构联系起来了，
     * 操作主设备为LED_MAJOR的设备文件时，就会调用s3c24xx_leds_fops中的相关成员函数
     * LED_MAJOR可以设为0，表示由内核自动分配主设备号
     */
    ret = register_chrdev(LED_MAJOR, DEVICE_NAME, &s3c24xx_leds_fops);
    if (ret < 0) {
      printk(DEVICE_NAME " can't register major numbern");
      return ret;
    }

    leds_class = class_create(THIS_MODULE, "leds");
    if (IS_ERR(leds_class))
        return PTR_ERR(leds_class);



    leds_class_devs[0] = class_device_create(leds_class, NULL, MKDEV(LED_MAJOR, 0), NULL, "leds"); /* /dev/leds */

    for (minor = 1; minor < 4; minor++)  /* /dev/led1,2,3 */
    {
        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 " initializedn");
    return 0;
}

/*
 * 执行rmmod命令时就会调用这个函数 
 */
static void __exit s3c24xx_leds_exit(void)
{
    int minor;
    /* 卸载驱动程序 */
    unregister_chrdev(LED_MAJOR, DEVICE_NAME);

    for (minor = 0; minor < 4; minor++)
    {
        class_device_unregister(leds_class_devs[minor]);
    }
    class_destroy(leds_class);
    iounmap(gpio_va);
}

/* 这两行指定驱动程序的初始化函数和卸载函数 */
module_init(s3c24xx_leds_init);
module_exit(s3c24xx_leds_exit);

/* 描述驱动程序的一些信息，不是必须的 */
MODULE_AUTHOR("http://www.100ask.net");
MODULE_VERSION("0.1.0");
MODULE_DESCRIPTION("S3C2410/S3C2440 LED Driver");
MODULE_LICENSE("GPL");

驱动测试程序ledtest.c

#include 
#include 
#include 
#include 

/*
  *  ledtest  
  */

void print_usage(char *file)
{
    printf("Usage:n");
    printf("%s  n",file);
    printf("eg. n");
    printf("%s /dev/leds onn", file);
    printf("%s /dev/leds offn", file);
    printf("%s /dev/led1 onn", file);
    printf("%s /dev/led1 offn", file);
}

int main(int argc, char **argv)
{
    int fd;
    char* filename;
    char val;

    if (argc != 3)
    {
        print_usage(argv[0]);
        return 0;
    }

    filename = argv[1];

    fd = open(filename, O_RDWR);
    if (fd < 0)
    {
        printf("error, can't open %sn", filename);
        return 0;
    }

    if (!strcmp("on", argv[2]))
    {
        // 亮灯
        val = 0;
        write(fd, &val, 1);
    }
    else if (!strcmp("off", argv[2]))
    {
        // 灭灯
        val = 1;
        write(fd, &val, 1);
    }
    else
    {
        print_usage(argv[0]);
        return 0;
    }


    return 0;
}

Makefile

KERN_DIR = /work/system/linux-2.6.22.6

all:
    make -C $(KERN_DIR) M=`pwd` modules 

clean:
    make -C $(KERN_DIR) M=`pwd` modules clean
    rm -rf modules.order

obj-m   += myleds.o

本站声明： 本文章由作者或相关机构授权发布，目的在于传递更多信息，并不代表本站赞同其观点，本站亦不保证或承诺内容真实性等。需要转载请联系该专栏作者，如若文章内容侵犯您的权益，请及时联系本站删除。
换一批
延伸阅读
[Linux阅码场]

史胜辉：USB工程师技术路线分析（附图书推荐）

史胜辉，在MTK工作了11年，一直在基带芯片的USB驱动领域做开发和验证。从最开始做USB2.0/3.0 IP验证和驱动开发到后面带领团队做上层协议驱动开发，以及跟硬件设计部门合作开发全新的USB硬件加速器。

关键字： 基带芯片 驱动领域 驱动开发
[程序员鱼皮]

这是用框架的通病么？

前端传递：表名 user，字段 username 字符串、age 数字、is_ikun 布尔，并且把这些值封装为了一个对象

关键字： 框架 前端
[《物联网技术》杂志]

轻量级J2EE中SSH框架的研究及其应用

摘要：J2EE是目前企业开发的主流Java开发应用平台，文章主要介绍了轻量级J2EE中流行的Struts2、Spring和Hibernate三种框架。具体阐述了SSH框架的基本特征、优点以及SSH的无缝集成，并结合病房信...

关键字： 轻量级J2EE SSH 框架 无缝集成 病房信息管理系统
[朱老师IT充电站]

【09.03】深圳明日实业 linux驱动开发工程师  30k月薪 岗位内推

点击上方名片关注我们朱老师推荐语：此岗位为AIoT终身成长大会员同学提供的自己公司的岗位内推，总部在深圳，是一家专业从事闭路电视监控设备、会议摄像机的研发、制造、销售的高科技企业，有学过嵌入式课程或者海思项目的同学，想换...

关键字： 开发工程师 linux驱动 驱动开发
[嵌入式云IOT技术圈]

Linux MIPI DSI LCD设备驱动开发调试细节学习笔记(一)

最近在学习MIPI接口的LCD驱动开发与调试，这里我主要用的是MIPI-DSI接口，它学习起来真的是太复杂了，特别是对于我这种很久都没写驱动来说更是头疼，但是头疼归头疼，工作咱们还是要完成的，那就只能硬着头皮往下肝吧！首...

关键字： MIPI 驱动开发 调试
[嵌入式云IOT技术圈]

linux驱动开发中与设备树相关的6种debug方法

关注、星标嵌入式云IOT技术圈，精彩及时送达来源|  Linux与SoC整理出了6种驱动开发时与设备注册、设备树相关的调试方法，彼此间没有优先级之分，每种方法不一定是最优解，但可以作为一种debug查找问题的手段，快速定...

关键字： 驱动开发
[嵌入式云IOT技术圈]

Linux MIPI DSI LCD设备驱动开发调试细节学习笔记(一)

最近在学习MIPI接口的LCD驱动开发与调试，这里我主要用的是MIPI-DSI接口，它学习起来真的是太复杂了，特别是对于我这种很久都没写驱动来说更是头疼，但是头疼归头疼，工作咱们还是要完成的，那就只能硬着头皮往下肝吧！首...

关键字： MIPI 驱动开发 调试
[松哥电源]

Linux 驱动开发 / gpio子系统 / 快速入门

哈喽，我是老吴，我来继续分享我的学习心得啦。gpio和pinctrl子系统在内核里的使用率非常高，和嵌入式产品的关联非常大。从这两个子系统开始学习驱动开发是个不错的入门选择。本文目录：一、gpio 与 pinctrl二、...

关键字： gp pi 驱动开发
[架构师社区]

架构设计的真谛：系统与子系统、模块与组件、框架与架构

在软件研发这个领域，程序员的终极目标都是想成为一名合格的架构师。

关键字： 架构 框架 软件研发
[嵌入式微处理器]

最佳入门教程！嵌入式必会的Linux驱动开发之IIO子系统

前阵子工作上做了一些关于 ADC 的支持，由于现在 ADC 相关的支持都被移动到了 IIO (Industrial I/O) 子系统下，我查阅了一些关于 IIO 资料，包括书籍、文章、内核文档和代码。个人感觉最好的入门文...

关键字： IO 驱动开发 嵌入式
关闭
关闭