linux 设备树下的led驱动(寄存器)

最新推荐文章于 2024-06-12 10:23:54 发布

东方欲晓w

最新推荐文章于 2024-06-12 10:23:54 发布

阅读量197

点赞数

分类专栏： Linux RAM 文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/weixin_45205160/article/details/130623419

版权

Linux RAM 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

设备树下的LED驱动

①、在 imx6ull-alientek-emmc.dts 文件中创建相应的设备节点。

②、编写驱动程序，获取设备树中的相关属性值。

③、使用获取到的有关属性值来初始化 LED 所使用的 GPIO。

修改设备树文件

修改设备树文件 imx6ull-alientek-emmc.dts 文件内容，增加一个自己的LED小灯子节点。

myled {
    #address-cells = <1>; /* reg 属性中起始地址占用一个字长 */
    #size-cells = <1>;	  /* 地址长度占用一个字长 */
    compatible = "my-led"; /* 属性 compatbile 设置节点兼容性为“my-led”*/
    status = "okay";		/* 属性 status 设置状态为“okay” */
    /* 驱动里面所要使用的寄存器物理地址 */
    reg = < 0X020C406C 0X04 	/* CCM_CCGR1_BASE */
    0X020E0068 0X04 			/* SW_MUX_GPIO1_IO03_BASE */
    0X020E02F4 0X04 			/* SW_PAD_GPIO1_IO03_BASE */
    0X0209C000 0X04 			/* GPIO1_DR_BASE */
    0X0209C004 0X04 >; 			/* GPIO1_GDIR_BASE */
};

重新编译设备树文件：make dtbs

LED 灯驱动程序编写

#include <linux/init.h>   // module_init、module_exit函数的头文件所在地
#include <linux/fs.h>     //添加文件描述符，设备注册注销头文件
#include <linux/module.h> // 添加module_XXX宏定义头文件
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <asm/io.h>   // 包含readl等IO操作函数
#include <linux/gpio.h>
#include <linux/errno.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/of_address.h>


#define NEW_CHAR_CNT 1   /*设备号数量*/
#define MY_NAME "dts_led" /*设备名字*/
#define LED_OFF     0   /* 关灯 */
#define LED_ON      1   /* 开灯 */

/* 映射后的虚拟地址 */
static void __iomem *IMX6U_CCM_CCGR1;   // 设置IO时钟虚拟地址
static void __iomem *SW_MUX_GPIO1_IO03; // 设置IO复用虚拟地址
static void __iomem *SW_PAD_GPIO1_IO03; // 设置IO属性虚拟地址
static void __iomem *GPIO1_DR;          // 设置IO输出功能虚拟地址
static void __iomem *GPIO1_GDIR;        // led虚拟地址

typedef struct my_dev{
    int major;  /*主设备号*/
	int minor;  /*次设备号*/
	dev_t dev;  /*设备号*/
	struct cdev cdev;  /* cdev */
	struct class *class; /*类*/
	struct device *device; /*设备*/
    struct device_node *nd; /* 设备树设备节点 */
}my_dev_t;

my_dev_t my_new_dev;  /*新设备*/


void led_switch(u8 sta)
{
    u32 val = 0;
    if(sta == LED_ON)  /*开灯*/
    {
        val = readl(GPIO1_DR);
        val &= ~(1 << 3); 
        writel(val, GPIO1_DR);
    }else if(sta == LED_OFF)  /*关灯*/
    {
        val = readl(GPIO1_DR);
        val|= (1 << 3);
        writel(val, GPIO1_DR);
    } 
}

/*打开设备*/
static int my_dev_open (struct inode *inode, struct file *file)
{
    file->private_data = &my_new_dev; /*设置私有数据*/
    return 0;
}
/*读设备*/
static ssize_t my_dev_read (struct file *file, char __user *buf, 
                            size_t cnt, loff_t * offt)
{
    return 0;
}
/*写设备*/
static ssize_t my_dev_write (struct file *file, const char __user *buf,
                         size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char data_buf[1];
    unsigned char led_stat;
    /*接收用户空间的数据*/
    ret = copy_from_user(data_buf,buf,cnt);
    if(ret < 0)
    {
        printk(KERN_INFO "write fail ...\n");
        return -EFAULT; 
    }

    led_stat = data_buf[0]; /* 获取状态值 */

    if(led_stat == LED_ON)
    {
        led_switch(LED_ON);
    }else if(led_stat == LED_OFF)
    {
        led_switch(LED_OFF);
    }

    return 0;
}
/*释放设备*/
static int my_dev_close (struct inode *inode, struct file *file)
{
    return 0;
}

static struct file_operations my_fops = {
    .owner		= THIS_MODULE,		// 惯例，直接写即可
	.open		= my_dev_open,		// 打开设备
    .read       = my_dev_read,		// 读设备
    .write		= my_dev_write,		// 写设备
	.release	= my_dev_close,		// 关闭设备
};

/*驱动入口函数 */
static int __init mydev_init(void)
{
    u32 val = 0;
    int ret;
    u32 reg_data[14];
    const char *str;
    struct property *proper;

    /* 获取设备树中的属性数据 */
    /* 1、获取设备节点：my_led */
    my_new_dev.nd = of_find_node_by_path("/myled");

    if(my_new_dev.nd == NULL) {
        printk("my_led node can not found!\r\n");
        return -EINVAL;
    } else {
        printk("my_led node has been found!\r\n");
    }

    /* 2、获取 compatible 属性内容 */
    proper = of_find_property(my_new_dev.nd, "compatible", NULL);

    if(proper == NULL) {
        printk("compatible property find failed\r\n");
    } else {
        printk("compatible = %s\r\n", (char*)proper->value);
    }

    /* 3、获取 status 属性内容 */
    ret = of_property_read_string(my_new_dev.nd, "status", &str);

    if(ret < 0){
        printk("status read failed!\r\n");
    } else {
        printk("status = %s\r\n",str);
    }

    /* 4、获取 reg 属性内容 */
    ret = of_property_read_u32_array(my_new_dev.nd, "reg", reg_data, 10);

    if(ret < 0) {
        printk("reg property read failed!\r\n");
    } else {
    u8 i = 0;
    printk("reg data:\r\n");
    for(i = 0; i < 10; i++)
        printk("%#X ", reg_data[i]);
        printk("\r\n");
    }

    /* 初始化 LED */
#if 0
    /* 1、寄存器地址映射 */
    IMX6U_CCM_CCGR1 = ioremap(reg_data[0], reg_data[1]);
    SW_MUX_GPIO1_IO03 = ioremap(reg_data[2], reg_data[3]);
    SW_PAD_GPIO1_IO03 = ioremap(reg_data[4], reg_data[5]);
    GPIO1_DR = ioremap(reg_data[6], reg_data[7]);
    GPIO1_GDIR = ioremap(reg_data[8], reg_data[9]);
#else
    IMX6U_CCM_CCGR1 = of_iomap(my_new_dev.nd, 0);
    SW_MUX_GPIO1_IO03 = of_iomap(my_new_dev.nd, 1);
    SW_PAD_GPIO1_IO03 = of_iomap(my_new_dev.nd, 2);
    GPIO1_DR = of_iomap(my_new_dev.nd, 3);
    GPIO1_GDIR = of_iomap(my_new_dev.nd, 4);
#endif

    /* 2、使能 GPIO1 时钟 */
    val = readl(IMX6U_CCM_CCGR1);
    val &= ~(3 << 26); /* 清除以前的设置 */
    val |= (3 << 26); /* 设置新值 */
    writel(val, IMX6U_CCM_CCGR1);

    /* 3、设置 GPIO1_IO03 的复用功能，将其复用为
    * GPIO1_IO03，最后设置 IO 属性。
    */
    writel(5, SW_MUX_GPIO1_IO03);

    /* 寄存器 SW_PAD_GPIO1_IO03 设置 IO 属性 */
    writel(0x10B0, SW_PAD_GPIO1_IO03);

    /* 4、设置 GPIO1_IO03 为输出功能 */
    val = readl(GPIO1_GDIR);
    val &= ~(1 << 3); /* 清除以前的设置 */
    val |= (1 << 3); /* 设置为输出 */
    writel(val, GPIO1_GDIR);

    /* 5、默认关闭 LED */
    val = readl(GPIO1_DR);
    val |= (1 << 3); 
    writel(val, GPIO1_DR);

    /*分配设备号*/
    if(my_new_dev.major) /*定义了主设备号*/
    {
        my_new_dev.dev = MKDEV(my_new_dev.major,0); /*次设备默认从0开始*/
        register_chrdev_region(my_new_dev.dev,NEW_CHAR_CNT,MY_NAME); /*静态申请设备号*/
    }else
    {
        alloc_chrdev_region(&my_new_dev.dev,0,NEW_CHAR_CNT,MY_NAME); /*动态申请设备号*/
        my_new_dev.major = MAJOR(my_new_dev.dev); /*主设备号*/
        my_new_dev.minor = MINOR(my_new_dev.dev); /*次设备号*/
    }
    /*注册设备号*/
    cdev_init(&my_new_dev.cdev,&my_fops); /*初始化cdev*/
    cdev_add(&my_new_dev.cdev,my_new_dev.dev,NEW_CHAR_CNT); /*添加一个dev*/
    /*创建类*/
	my_new_dev.class = class_create(THIS_MODULE,MY_NAME);
    if(IS_ERR(my_new_dev.class))
    {
        return PTR_ERR(my_new_dev.class);
    }
    /*创建设备*/
    my_new_dev.device = device_create(my_new_dev.class,NULL,my_new_dev.dev,NULL,MY_NAME);
    if(IS_ERR(my_new_dev.device))
    {
        return PTR_ERR(my_new_dev.device);
    }

    return 0;
}

/*驱动出口函数 */
static void __exit mydev_exit(void)
{
    /* 取消映射 */
    iounmap(IMX6U_CCM_CCGR1);
    iounmap(SW_MUX_GPIO1_IO03);
    iounmap(SW_PAD_GPIO1_IO03);
    iounmap(GPIO1_DR);
    iounmap(GPIO1_GDIR);

    /*注销字符设备*/
    cdev_del(&my_new_dev.cdev);
    unregister_chrdev_region(my_new_dev.dev, NEW_CHAR_CNT);

    /*注销掉类和设备*/
	device_destroy(my_new_dev.class,my_new_dev.dev);
    class_destroy(my_new_dev.class);
}

module_init(mydev_init); // 注册加载函数
module_exit(mydev_exit); // 注册卸载函数

// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL");             // 描述模块的许可证
MODULE_AUTHOR("dongfang");         // 描述模块的作者
MODULE_DESCRIPTION("module test"); // 描述模块的介绍信息
MODULE_ALIAS("------");            // 描述模块的别名信息

APP 应用程序

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

int main(int argc, char* argv[])
{
    int fd, ret;
    char* file_name;
    char data_buf[1];

    if(argc != 3)  // 命令行参数过少
    {
        printf("used error \n");
        return -1;
    }

    file_name = argv[1];  // 打开的设备名字 dts_led

    fd = open(file_name,O_RDWR);  // 打开设备文件

    data_buf[0] = atoi(argv[2]); /* 要执行的操作：打开或关闭 */

    ret = write(fd, data_buf, sizeof(data_buf));
    if(ret < 0)
    {
        printf("write error \n");
        close(fd);
        return -1;
    }

    ret = close(fd);
    if(ret < 0)
    {
        printf("close error\n");
        return -1;
    }
    return 0;
}

Makefile

KERNELDIR := /home/haitu/Desktop/Linux/NXP/NXP_linux
CURRENT_PATH := $(shell pwd)
obj-m := dts_led.o

build: kernel_modules
kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
	arm-linux-gnueabihf-gcc APP.c -o APP
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
	rm -rf APP

加载驱动：

depmod //第一次加载驱动的时候需要运行此命令
modprobe dtsled.ko //加载驱动
rmmod dtsled.ko // 卸载驱动

编译错误解决

错误：FATAL: section header offset=11259024840327220 in file 'vmlinux' is bigger than filesize=16740094 scripts/Makefile.modpost:90: recipe for target '__modpost' failed

解决方法：重新编译内核
还有一种错误：显示编译错误，但是没有显示任何代码上的错误可能是修改了设备树文件，但是并没有对设备树文件进行编译。