Linux学习笔记（15.3）——LED设备驱动之面向对象演进3

于 2021-12-25 07:11:51 发布
阅读量179 收藏
点赞数
分类专栏： Linux 文章标签： linux 单片机 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/glen_cao/article/details/122138931
版权
  1. 在Linux学习笔记（15.2）中，将LED字符设备驱动程序分为led_drv和led_dev两个文件，其中led_drv提供led_drv_open、led_drv_write、led_drv_release等与应用程序对应的函数，而这些函数在实际执行时要通过函数指针调用底层的led_init、led_exit、led_ctrl等函数完成对LED的控制；而led_dev文件则提供LED的资源和实际对LED操作的函数。
    为提升程序的可移植性，可进一步将led_dev文件中LED资源和实际对LED操作的函数分成两个文件——与芯片相关的IO控制文件和LED资源文件，前者提供与芯片相关的LED的控制函数，即某款芯片对IO口的操作，后者只提供LED资源信息。这样，如果更换了芯片，led_drv文件无需更改，需要将与芯片相关的IO控制文件和LED资源文件替换成适合变更芯片的目标板即可；如果只是目前板的LED控制引脚或LED数量发生了变化，则只需要将LED资源文件做相应的调整即可。
    本文的LED驱动分别提供了led_drv、imx6_gpio_drv和atk_board_led源文件。
  2. led_drv文件如下
/**
 * @file led_drv.c
 * @author glen (glen_cao@126.com)
 * @brief 
 * @version 0.1
 * @date 2021-12-24
 * 
 * @copyright Copyright (c) 2021
 * 
 */
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#include "led_dev.h"

/* LED驱动结构体 */
struct gled_driver {
    struct class *drv_class;
    char *name;
    dev_t major;

    struct led_ops *ops;
};

/* gled驱动 */
static struct gled_driver gled_drv = {
    .name  = "gled_drv",
    .major = 0,
    .ops = NULL,
};

/**
 * @brief 
 */
void led_ops_register(struct led_ops *p_ops)
{
    if (p_ops) 
        gled_drv.ops = p_ops;
}

void led_device_create(int minor)
{
    /* 创建设备 */
    device_create(gled_drv.drv_class, NULL, MKDEV(gled_drv.major, minor), NULL, "gled%d", minor);
}

void led_device_destroy(int minor)
{
    /* 销毁设备 */
    device_destroy(gled_drv.drv_class, MKDEV(gled_drv.major, minor));
}

EXPORT_SYMBOL(led_ops_register);
EXPORT_SYMBOL(led_device_create);
EXPORT_SYMBOL(led_device_destroy);

/**
 * @brief   : 打开设备 
 * @par     : inode 传递给驱动的inode
 *            filp  设备文件, file结构体有个private_data的成员变量, 一般
 *            在open的时候将private_data指向设备结构体
 * @retval  : 0 成功, 其它 失败
 */
static int led_drv_open(struct inode *inode, struct file *filp)
{
    int minor = iminor(inode);
    struct led_ops *ops = gled_drv.ops;

    if (ops == NULL) {
        printk("Please register led_ops instance! \n");
        return 0;
    }

    if (ops->led_init)
        if (ops->led_init(minor) == 0) 
            printk("The led%d has openned successfully! \n", minor);
        else 
            printk("The led%d has openned failure! \n", minor);
    else 
        printk("Please register led_ops instance! \n");
    return 0;
}

/**
 * @brief   : 从设备读取数据 
 * @par     : filp  要打开的设备文件(文件描述符)
 *            buf   返回给用户空间的数据缓冲区
 *            cnt   要读取的数据长度
 *            offt  相对于文件首地址的偏移
 * @retval  : 读取数据长度, 若为负值则表示读取失败
 */
static ssize_t led_drv_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    return 0;
}

/**
 * @brief   : 向字符设备写入数据 
 * @par     : filp  设备文件, 表示打开的文件描述符
 *            buf   要写给设备的数据
 *            cnt   要写入的数据长度
 *            offt  相对于文件首地址的偏移
 * @retval  : 写入数据长度, 若为负值则表示读取失败
 */
static ssize_t led_drv_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    u8 data_buf[1];
    u8 led_sta;
    int minor;
    struct inode *inode = file_inode(filp);
    struct led_ops *ops = gled_drv.ops;

    if (ops == NULL) {
        printk("Please register led_ops instance! \n");
        return 0;
    }
    minor = iminor(inode);
    ret = copy_from_user(data_buf, buf, 1);

    if (ret < 0) {
        printk("kenel recive data: %s\r\n", buf);
        return -EFAULT;
    }

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

    if (ops->led_ctrl) 
        ops->led_ctrl(minor, led_sta);

    return 0;

}

/**
 * @brief   : 打开设备 
 * @par     : inode 传递给驱动的inode
 *            filp  要关闭的设备文件(文件描述符)
 * @retval  : 0 成功, 其它 失败
 */
static int led_drv_release(struct inode *inode, struct file *filp)
{
    u8 minor = iminor(inode);
    struct led_ops *ops = gled_drv.ops;

    if (ops == NULL) {
        printk("Please register led_ops instance! \n");
        return 0;
    }

    if (minor >= ops->num)
        return -EINVAL;

    /* 虚拟地址映射销 */
    if (ops->led_exit)
        ops->led_exit(minor);

    printk("The led driver is closed! %s, %s, line %d\n", __FILE__, __FUNCTION__, __LINE__);

    return 0;
}

static struct file_operations led_drv_fops = {
    .owner = THIS_MODULE,
    .open = led_drv_open,
    .read = led_drv_read,
    .write = led_drv_write,
    .release = led_drv_release,
};

/**
 * @brief   : 驱动初始化函数 
 * @par     : 无
 * @retval  : 无
 */
static int __init led_drv_init(void)
{
    u8 err = 0;

    /* register char device driver */
    gled_drv.major = register_chrdev(gled_drv.major, gled_drv.name, &led_drv_fops);
    if (gled_drv.major == 0) {
        printk("gled driver: Unable to register driver!\n");
        return -EIO;
    }
    printk("gled driver: Register driver successfully!\n");

    gled_drv.drv_class = class_create(THIS_MODULE, "gled");
    if (IS_ERR(gled_drv.drv_class)) {
        err = PTR_ERR(gled_drv.drv_class);
        goto out_chrdev;
    }
    return 0;

out_chrdev:
    unregister_chrdev(gled_drv.major, gled_drv.name);
    return err;
}

/**
 * @brief   : 驱动退出函数 
 * @par     : 无
 * @retval  : 无
 */
static void __exit led_drv_exit(void)
{
    class_destroy(gled_drv.drv_class);
    /* 注销字符设备驱动 */
    unregister_chrdev(gled_drv.major, gled_drv.name);
}

/* assign the functions as driver's import function and export function*/
module_init(led_drv_init);
module_exit(led_drv_exit);

/* 模块的许可证声明 */
MODULE_LICENSE("GPL");
/* 模块的作者声明 */
MODULE_AUTHOR("glen");
  1. imx6_gpio_drv文件如下
/**
 * @file imx6_gpio_drv.c
 * @author glen (glen_cao@126.com)
 * @brief 
 * @version 0.1
 * @date 2021-12-24
 * 
 * @copyright Copyright (c) 2021
 * 
 */

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#include "led_dev.h"

static struct gled_device gled[16];

static void imx6_gled_ctrl(u8 idx, u8 status);
static int imx6_gled_init(u8 idx);
static int imx6_gled_exit(u8 idx);

static struct led_ops imx6_gpio_led_ops = {
    .num = 0,
    .led_init = imx6_gled_init,
    .led_exit = imx6_gled_exit, 
    .led_ctrl = imx6_gled_ctrl,
};

/**
 * @brief   : 打开/关闭LED 
 * @par     : status    LEDON('O') 打开LED, LEDOFF('C') 关闭LED
 * @retval  : 无
 */
static void imx6_gled_ctrl(u8 idx, u8 status)
{
    u32 val = 0;

    if (gled[idx].vir_io.ccgr == NULL) 
        return;

    if (status == ON) {
        val = readl(gled[idx].vir_io.dr);
        if (gled[idx].on_level == HIGH) {
            val |= (1 << (gled[idx].pin));
        } else if (gled[idx].on_level == LOW) {
            val &= ~(1 << gled[idx].pin);
        }
        writel(val, gled[idx].vir_io.dr);
        printk("The led%d is openned!\r\n", idx);
    } else if (status == OFF) {
        val = readl(gled[idx].vir_io.dr);
        if (gled[idx].on_level == HIGH) {
            val &= ~(1 << gled[idx].pin);
        } else if (gled[idx].on_level == LOW) {
            val |= (1 << (gled[idx].pin));
        }
        writel(val, gled[idx].vir_io.dr);
        printk("The led%d is closed!\r\n", idx);
    } else {
        printk("Recived parameter is error!\r\n");
    }
}

/**
 * @brief LED状态初始化
 * @param idx LED
 */
static int imx6_gled_init(u8 idx)
{
    u32 val;

    if (idx >= imx6_gpio_led_ops.num) {
        return -EIO;
    }

    /* 寄存器地址映射 */
    gled[idx].vir_io.ccgr    = ioremap(gled[idx].phy_io.ccgr  ,  4);
    gled[idx].vir_io.sw_mux  = ioremap(gled[idx].phy_io.sw_mux,  4);
    gled[idx].vir_io.sw_pad  = ioremap(gled[idx].phy_io.sw_pad,  4);
    gled[idx].vir_io.dr      = ioremap(gled[idx].phy_io.dr    ,  4);
    gled[idx].vir_io.dir     = ioremap(gled[idx].phy_io.dir   ,  4);

    /* 使能GPIO时钟 */
    val = readl(gled[idx].vir_io.ccgr);
    val |= (3 << gled[idx].clk_shft_bits);
    writel(val, gled[idx].vir_io.ccgr);

    /* 设置gpio1_io03的复用功能 */
    writel(5, gled[idx].vir_io.sw_mux);

    /* 寄存器sw_mux1_io03设置IO属性 */
    writel(0x10B0, gled[idx].vir_io.sw_pad);

    /* 设置gpio1_gdir为输出功能 */
    val = readl(gled[idx].vir_io.dir);
    val |= (1 << gled[idx].pin);
    writel(val, gled[idx].vir_io.dir);

    /* 设置led为默认状态 */
    val = readl(gled[idx].vir_io.dr);
    if (gled[idx].dft_status == ON) {
        if (gled[idx].on_level == HIGH) {
            val |= (1 << gled[idx].pin);
        } else if (gled[idx].on_level == LOW) {
            val &= ~(1 << gled[idx].pin);
        }
    } else if (gled[idx].dft_status == OFF) {
        if (gled[idx].on_level == HIGH) {
            val &= ~(1 << gled[idx].pin);
        } else if (gled[idx].on_level == LOW) {
            val |= (1 << gled[idx].pin);
        }
    }
    writel(val, gled[idx].vir_io.dr);

    return 0;
}

/**
 * @brief LED状态解初始化
 * @param idx LED
 */
static int imx6_gled_exit(u8 idx)
{
    if (idx >= imx6_gpio_led_ops.num) {
        return -EIO;
    }
    iounmap(gled[idx].vir_io.ccgr);
    iounmap(gled[idx].vir_io.sw_mux);
    iounmap(gled[idx].vir_io.sw_pad);
    iounmap(gled[idx].vir_io.dr);
    iounmap(gled[idx].vir_io.dir);

    return 0;
}

/**
 * @brief 
 */
static int imx6_gpio_probe(struct platform_device *pdev)
{
    struct resource *res = NULL;
    u8 i = 0;

    while (1) {
        res = platform_get_resource(pdev, IORESOURCE_IRQ, i);
        if (res == NULL) {
            break;
        }

        /* 如果将gled定义为指针数组, 则不需要复制, 将地址赋给对应指针即可 */
        memcpy(&gled[i], (const void *)(res->start), sizeof(struct gled_device));

        /* 创建设备节点 */
        led_device_create(i);
        i++;
    }
    imx6_gpio_led_ops.num = i;
    
    return 0;
}

static int imx6_gpio_remove(struct platform_device *pdev)
{
    u8 i;

    /* 销毁设备节点 */
    for (i = 0; i < imx6_gpio_led_ops.num; i++) {
        led_device_destroy(i);
    }
    imx6_gpio_led_ops.num = 0;

    return 0;
}

static struct platform_driver imx6_gpio_driver = {
    .driver = {
        .name = "gled",
    },
    .probe = imx6_gpio_probe,
    .remove = imx6_gpio_remove,
};

static int __init imx6_gpio_drv_init(void)
{
    int ret;

    ret = platform_driver_register(&imx6_gpio_driver);
    if (ret)
        pr_err("Unable to initialize imx6 gpio driver\n");
    else
        pr_info("The imx6 gpio driver is registered.\n");
    
    led_ops_register(&imx6_gpio_led_ops);

    return ret;
}

static void __exit imx6_gpio_drv_exit(void)
{
    platform_driver_unregister(&imx6_gpio_driver);
}
module_init(imx6_gpio_drv_init);
module_exit(imx6_gpio_drv_exit);

/* insert license for module */
MODULE_LICENSE("GPL");

/* insert author information for module */
MODULE_AUTHOR("glen");
  1. atk_board_led文件如下
/**
 * @file atk_board_led.c
 * @author glen (glen_cao@126.com)
 * @brief 
 * @version 0.1
 * @date 2021-12-24
 * 
 * @copyright Copyright (c) 2021
 * 
 */
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#include "led_dev.h"

/* gled设备 */
static struct gled_device gled_dev[] = {
    {
        .dft_status = OFF,
        .on_level = LOW,
        .clk_shft_bits = 26, 
        .pin = 3,
        .phy_io = {
            /* IO物理地址 */
            .ccgr   = 0x020C406C, 
            .sw_mux = 0x020E0068,
            .sw_pad = 0x020E02F4,
            .dr     = 0x0209C000,
            .dir    = 0x0209C004
        },
    }, {
        .dft_status = ON,
        .on_level = LOW,
        .clk_shft_bits = 30,
        .pin = 1,
        .phy_io = {
            .ccgr   = 0x020C406C, 
            .sw_mux = 0x0229000C,
            .sw_pad = 0x02290050,
            .dr     = 0x020AC000,
            .dir    = 0x020AC004
        },
    }
};

static struct resource led_res[] = {
    {
        .start = (resource_size_t)&gled_dev[0],
        .flags = IORESOURCE_IRQ,
        .name = "atk_led_pin",
    }, {
        .start = (resource_size_t)&gled_dev[1],
        .flags = IORESOURCE_IRQ,
        .name = "atk_led_pin",
    },
};

/**
 * 怎么写程序
 * 分配/设置/注册platform_device结构体
 * 在里面定义所用资源，指定设备名字。
 */

static struct platform_device led_dev = {
    .name = "gled",
    .num_resources = ARRAY_SIZE(led_res),
    .resource = led_res,
};

static int __init led_dev_init(void)
{
	return platform_device_register(&led_dev);
}
module_init(led_dev_init);

static void __exit led_dev_exit(void)
{
    platform_device_unregister(&led_dev);
}
module_exit(led_dev_exit);

/* 模块的许可证声明 */
MODULE_LICENSE("GPL");
/* 模块的作者声明 */
MODULE_AUTHOR("glen");
  1. led_dev头文件
/**
 * @file led_dev.h 
 * @author glen (glen_cao@126.com)
 * @brief 
 * @version 0.1
 * @date 2021-12-17
 * 
 * @copyright Copyright (c) 2021
 */

#ifndef __LED_DEV_H__
#define __LED_DEV_H__

#include <linux/types.h>

#define HIGH  1
#define LOW   0

#define OFF         'C' /* 关灯 */
#define ON          'O' /* 开灯 */

struct led_ops {
    u8 num;             /* LED数量 */
    int (* led_init)(u8 idx);
    int (* led_exit)(u8 idx);
    void (* led_ctrl)(u8 idx, u8 status);
};

struct phy_regs {
    phys_addr_t ccgr;
    phys_addr_t sw_mux;
    phys_addr_t sw_pad;
    phys_addr_t dr;
    phys_addr_t dir;
};

struct vir_regs {
    void __iomem *ccgr;
    void __iomem *sw_mux;
    void __iomem *sw_pad;
    void __iomem *dr;
    void __iomem *dir;
};

/* LED设备结构体 */
struct gled_device {
    u8 dft_status; /* 默认状态: 打开或关闭 */
    u8 on_level;   /* 打开时电平: 高或低 */
    u8 clk_shft_bits;
    u32 pin;       /* led引脚信息 */
    struct vir_regs vir_io;
    struct phy_regs phy_io;
};

void led_ops_register(struct led_ops *p_ops);
void led_device_create(int minor);
void led_device_destroy(int minor);

#endif // !__LED_DEV_H__
  1. Makefile文件稍作更改，将三个源文件编译成独立的模块
KERNELDIR	:= /home/glen/linux/imx6ull/linux/glen_linux
CURRENT_PATH	:= $(shell pwd)
#led_driver-y	:= led_drv.o led_dev.o
obj-m	+= led_drv.o atk_board_led.o imx6_gpio_drv.o
build:	kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules

clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
  1. 测试程序不做更改，验证参考Linux学习笔记（15）——LED设备驱动
glen_cao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符设备驱动——LED
keep coding
03-11 311
编写驱动程序的步骤: 写出框架 a. 构造file_operatinon结构体。 b. 写入口函数（register）、出口函数（unregister） c. 创建设备节点 硬件操作 a. 看原理图 b. 看芯片手册 c. 编程（用虚拟地址，需地址映射） 过程分析: file_operatinon的作用就是联系内核与驱动程序。 当在应用程序中调用open、read函数时,设备驱动程序中的fil...
LED 设备驱动
YH_24H的博客
03-28 180
LED 设备驱动 目的是熟悉内存映射 一、地址映射 裸机LED灯实验就是操作6ULL的寄存器。 Linux驱动开发也可以操作寄存器，Linux不能直接对寄存器物理地址进行读写操作，比如寄存器A物理地址为0X01010101。裸机的时候可以直接对0X01010101这个物理地址进行操作，但是linux下不行，因为linux会使能MMU。 在linux里面操作的都是虚拟地址，所以需要先得到0X01010101这个物理地址对应的虚拟地址。linux初始化MMU后，就会设置好内存映射，设置好之后cpu访
led设备驱动
朝辞暮见的博客
06-30 749
Led设备驱动基于字符设备框架，并且用到硬件知识比如EXYNOS中的控制led寄存器地址。还有几个重要函数比如ioremap、ioctl函数会在其他博客中贴出。这里直接贴出代码。Led.c文件内容/*6- 包含内核头文件*/#include &lt;linux/init.h&gt;#include &lt;linux/kernel.h&gt;#include &lt;linux/module.h&...
LED设备驱动
u011615512的专栏
09-13 545
去年开的博客，到今天只有两篇文章，再看看同学的博客，惭愧啊。 写博客虽然额外多花了些时间，不过对自学知识有复习与总结的作用，还能提高语言组织能力，而且，如果有朋友能从我的博客中获益那就再好不过了。希望自己养成写博客的习惯，就从这一篇开始吧。LED驱动是最简单的字符设备，可以说是Linux设备驱动程序里的HelloWorld，适合用来熟悉字符设备驱动程序开发的基本流程 笔者使用的是JZ2440开发
驱动程序实例（一）：LED设备驱动程序（ platform + cdev）
weixin_30602505的博客
07-31 390
结合之前对Linux内核的platform总线 ，以及对字符设备的cdev接口的分析，本文将编写基于platform总线与cdev接口的LED设备的实例代码并对其进行分析。 platform总线分析，详见Linux platform驱动模型。 字符设备的cdev接口分析，详见Linux字符设备驱动（一）：cdev接口。 硬件接口： 　　CPU：s5pv210； 　　LED的GPIO：GP...
Linux内核与设备驱动程序学习笔记及源码.zip
01-05
Linux内核与设备驱动程序学习笔记及源码.zip Linux内核与设备驱动程序学习笔记及源码.zip Linux内核与设备驱动程序学习笔记及源码.zip Linux内核与设备驱动程序学习笔记及源码.zip Linux内核与设备驱动程序学习笔记...
Linux内核与设备驱动程序学习资料笔记+源码.zip
最新发布
01-30
Linux内核与设备驱动程序学习资料笔记+源码.zipLinux内核与设备驱动程序学习资料笔记+源码.zipLinux内核与设备驱动程序学习资料笔记+源码.zipLinux内核与设备驱动程序学习资料笔记+源码.zipLinux内核与设备驱动程序...
读书笔记-LINUX设备驱动程序(第3版).pdf
05-04
《Linux 设备驱动程序》第三版是一本面向Linux驱动开发的经典教程，内容非常全面，非常适合没有接触过Linux驱动开发的新手。本人通过阅读本书，对其内容进行了梳理总结，分为两大部分：1.驱动代码分析 2.知识点总结...
linux驱动开发学习笔记十一：初识设备树
01-06
在Linux3.x之前的内核源码中，存在大量对板级细节信息描述的代码。这些代码充斥在/arch/arm/plat-xxx和/arch/arm/mach-xxx目录中。每年新出的 ARM 架构芯片少说都有数十、数百款，每一款芯片又会有很多款基于该芯片...
Java面向对象编程学习笔记.pdf
12-01
"Java面向对象编程学习笔记.pdf" Java面向对象编程学习笔记是Java程序设计语言中面向对象编程（Object-Oriented Programming，OOP）的一份学习笔记。面向对象编程是一种软件设计方法，它强调使用对象和类来模拟现实...
D1_Tina_Linux_LEDC_开发指南1
08-04
介绍全志LEDC驱动的使用方法，方便LEDC驱动维护和应用开发。1.2 适用范围表 1-1: 适用产品列表产品名称内核版本驱动文件1.3 相关人员LEDC 驱动
led字符设备驱动
森子格
05-10 371
#include <linux/init.h> #include <linux/module.h> #include <linux/fs.h> //for MKDEV register_chrdev_region #include <linux/cdev.h> //字符设备头文件 #include <asm/io.h> #def...
呼吸灯代码linux,ESP32 开发笔记(三）源码示例 3_LEDC_PWM 使用LEDC实现LED呼吸灯
weixin_35426913的博客
05-12 740
开发板购买链接开发板简介开发环境搭建 windows源码示例：0_Hello Bug (ESP_LOGX与printf) 工程模板/打印调试输出1_LED LED亮灭控制2_LED_Task 使用任务方式控制L...
字符设备驱动（四）-led实例
倾斜的正弦波
07-25 534
前面已经讲解了字符设备驱动的基本框架，接下来我们就写一个led的驱动程序，一步步的了解字符设备驱动。我们还是先从应用程序开始。 #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <stdio.h> /* firstdrvtest on *
linux设备驱动程序之低级led驱动
心.跳的博客
05-18 972
首先，内核开发人员需要明白的是，我们要做的是在内核里写一些函数，这些函数是在内核中，所以它不能用到应用程序空间的所提供的一些函数，如printf()等；其次，这些设备驱动函数，目的是提供一种为底层的物理设备（如led，按键等）实现某种操作的策略，注意，是策略而不是机制，如果想要实现某种机制，请把实现这种机制的方法放到应用程序空间；同时，设备驱动函数也向上一层提供了一些系统调用接口供应用程序空间使用...
LEDs STM32版
我思故我在！
09-13 193
1. Start.S .global _start /* 全局标号 */ /* * 描述： _start函数，程序从此函数开始执行，此函数主要功能是设置C * 运行环境。 */ _start: /* 进入SVC模式 */ mrs r0, cpsr bic r0, r0, #0x1f /* 将r0寄存器中的低5位清零，也就是cpsr的M0~M4 */ orr r0, r0, #0x13 /* r0或上0x13,表示使用SVC模式 */ msr cpsr, r0
嵌入式Linux学习历程 — C语言LED灯
08-16 490
C语言LED灯 1、汇编文件：C语言环境构建 2、C语言文件：完成工程需要的功能 一、C语言运行环境构建 一、 设置处理器模式 设置6ULL处于SVC模式下，设置CPSR寄存器的bit4-0，即M[4：0]为10011 = 0X13。 读写状态寄存器需要用到MRS和MSR指令。MRS将CPSR寄存器数据读出到通用寄存器，MSR指令将通用寄存器的数据写入到CPSR寄存器中。 二、 设置 SP 指针 SP指针可以指向内部RAM，也可以指向DDR，我们将其指向DDR。 SP指针设置到哪里？DDR内存 512MB
面向对象方法学之COM组件
不当初
03-25 798
软件复用的关键因素       前提：必须有可以复用的对象；所复用的对象必须是有用的；服用者需要知道如何去使用被复用的对象 COM组建标准的目标：       易于动态组装（复用和集成）       组件的实现与语言无关，对使用者（客户）透明。约束松       可以以二进制的形式发布 组件的升级不影响驶入继续使用它的老客户 组件可以透明地在网络上
Linux设备驱动学习笔记：字符设备驱动实战
“Linux设备驱动程序的学习笔记，涵盖了字符设备驱动的编写，包括NFS挂载、字符设备驱动的基本操作如open、write、close的实现，以及file_operations结构体的使用和驱动注册。” 在Linux操作系统中，设备驱动是操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值