驱动开发作业2 —— ioctl

已于 2023-07-05 17:17:34 修改
阅读量519 收藏
点赞数
分类专栏： 华清远见 文章标签： 驱动开发
于 2023-07-05 17:12:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43921012/article/details/131559969
版权

通过ioctl函数选择不同硬件的控制，如实现对LED、蜂鸣器、马达、风扇的控制

1.将GPIO的相关寄存器封装成结构体  --------> gpio.h
2.LED相关驱动文件 --------> led.c
3.蜂鸣器相关驱动文件  --------> beep.c
4.风扇相关驱动文件 --------> fan.c
5.马达相关驱动文件  --------> motor.c

6.应用层测试文件  --------> test.c

 gpio.h

/*
 * Copyright (c) 2023 by Huijie Xia, All Rights Reserved.
 * @Author: Huijie Xia
 * @Date: 2023-07-05 16:21:43
 * @LastEditTime: 2023-07-05 16:47:21
 * @FilePath: /B_Drive/day3/led_beep_fan_motor/gpio.h
 * @version:
 * @Description:
 */
#ifndef __GPIO_H_
#define __GPIO_H_

typedef struct {
    volatile unsigned int MODER; // 0x00
    volatile unsigned int OTYPER; // 0x04
    volatile unsigned int OSPEEDR; // 0x08
    volatile unsigned int PUPDR; // 0x0C
    volatile unsigned int IDR; // 0x10
    volatile unsigned int ODR; // 0x14
    volatile unsigned int BSRR; // 0x18
    volatile unsigned int LCKR; // 0x1C
    volatile unsigned int AFRL; // 0x20
    volatile unsigned int AFRH; // 0x24
    volatile unsigned int BRR; // 0x28
    volatile unsigned int res;
    volatile unsigned int SECCFGR; // 0x30
} gpio_t;

#define PHY_RCC_GPIO 0x50000A28
#define PHY_GPIOB_BASE 0x50003000
#define PHY_GPIOE_BASE 0x50006000
#define PHY_GPIOF_BASE 0x50007000

#define LED1_ON _IO('l', 1)
#define LED1_OFF _IO('l', 0)
#define LED_ON _IOW('l', 1, int)
#define LED_OFF _IOW('l', 0, int)

#define FAN_ON _IO('f', 1)
#define FAN_OFF _IO('f', 0)

#define BEEP_ON _IO('b', 1)
#define BEEP_OFF _IO('b', 0)

#define MOTOR_ON _IO('m', 1)
#define MOTOR_OFF _IO('m', 0)

#endif

led.c

/*
 * Copyright (c) 2023 by Huijie Xia, All Rights Reserved.
 * @Author: Huijie Xia
 * @Date: 2023-06-29 08:56:26
 * @LastEditTime: 2023-07-05 16:24:06
 * @FilePath: /B_Drive/day3/led_beep_fan_motor/led.c
 * @version:
 * @Description: 驱动控制LED灯
 */
#include "gpio.h"
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/uaccess.h>

#define CNAME "myled"
struct class* cls;
struct device* dev;

int major;
char kbuf[128] = { 0 };
unsigned int* KERNEL_RCC_GPIO;
gpio_t* KERNEL_GPIOE_BASE;
gpio_t* KERNEL_GPIOF_BASE;

int mycdev_open(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    /* 地址映射 */
    KERNEL_RCC_GPIO = ioremap(PHY_RCC_GPIO, 4);
    if (KERNEL_RCC_GPIO == NULL) {
        printk("ioremap RCC error!\n");
        return -ENOMEM;
    }
    KERNEL_GPIOE_BASE = ioremap(PHY_GPIOE_BASE, sizeof(gpio_t));
    if (KERNEL_GPIOE_BASE == NULL) {
        printk("ioremap GPIOE BASE error!\n");
        return -ENOMEM;
    }
    KERNEL_GPIOF_BASE = ioremap(PHY_GPIOF_BASE, sizeof(gpio_t));
    if (KERNEL_GPIOF_BASE == NULL) {
        printk("ioremap GPIOF BASE error!\n");
        return -ENOMEM;
    }

    /* LED1(PE10)寄存器初始化(读,改,写) */
    writel(readl(KERNEL_RCC_GPIO) | (0x1 << 4), KERNEL_RCC_GPIO); /* GPIOE时钟使能 */
    writel(readl(&KERNEL_GPIOE_BASE->MODER) & (~(0x3 << 20)), &KERNEL_GPIOE_BASE->MODER); /* MODER寄存器21~20bit清零 */
    writel(readl(&KERNEL_GPIOE_BASE->MODER) | (0x1 << 20), &KERNEL_GPIOE_BASE->MODER); /* MODER寄存器设置为输出模式 */
    writel(readl(&KERNEL_GPIOE_BASE->ODR) & (~(0x1 << 10)), &KERNEL_GPIOE_BASE->ODR); /* LED1熄灭 */

    /* LED2(PF10)寄存器初始化(读,改,写) */
    writel(readl(KERNEL_RCC_GPIO) | (0x1 << 5), KERNEL_RCC_GPIO); /* GPIOF时钟使能 */
    writel(readl(&KERNEL_GPIOF_BASE->MODER) & (~(0x3 << 20)), &KERNEL_GPIOF_BASE->MODER); /* MODER寄存器21~20bit清零 */
    writel(readl(&KERNEL_GPIOF_BASE->MODER) | (0x1 << 20), &KERNEL_GPIOF_BASE->MODER); /* MODER寄存器设置为输出模式 */
    writel(readl(&KERNEL_GPIOF_BASE->ODR) & (~(0x1 << 10)), &KERNEL_GPIOF_BASE->ODR); /* LED2熄灭 */

    /* LED3(PE8)寄存器初始化(读,改,写) */
    writel(readl(KERNEL_RCC_GPIO) | (0x1 << 4), KERNEL_RCC_GPIO); /* GPIOE时钟使能 */
    writel(readl(&KERNEL_GPIOE_BASE->MODER) & (~(0x3 << 16)), &KERNEL_GPIOE_BASE->MODER); /* MODER寄存器21~20bit清零 */
    writel(readl(&KERNEL_GPIOE_BASE->MODER) | (0x1 << 16), &KERNEL_GPIOE_BASE->MODER); /* MODER寄存器设置为输出模式 */
    writel(readl(&KERNEL_GPIOE_BASE->ODR) & (~(0x1 << 8)), &KERNEL_GPIOE_BASE->ODR); /* LED3熄灭 */

    return 0;
}

ssize_t mycdev_read(struct file* file, char __user* ubuf,
    size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf)) {
        size = sizeof(kbuf);
    }
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret) {
        printk("copy data to user error!\n");
        return -EIO;
    }
    return size;
}
ssize_t mycdev_write(struct file* file, const char __user* ubuf,
    size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf)) {
        size = sizeof(kbuf);
    }
    ret = copy_from_user(kbuf, ubuf, size);

    if (ret) {
        printk("copy data from user error!\n");
        return -EIO;
    }

    // switch (kbuf[0]) {
    // case '1': /* LED1点亮 */
    //     writel(readl(&KERNEL_GPIOE_BASE->ODR) | (0x1 << 10), &KERNEL_GPIOE_BASE->ODR);
    //     break;

    // case '2': /* LED1熄灭 */
    //     writel(readl(&KERNEL_GPIOE_BASE->ODR) & (~(0x1 << 10)), &KERNEL_GPIOE_BASE->ODR);
    //     break;

    // case '3': /* LED2点亮 */
    //     writel(readl(&KERNEL_GPIOF_BASE->ODR) | (0x1 << 10), &KERNEL_GPIOF_BASE->ODR);
    //     break;

    // case '4': /* LED2熄灭 */
    //     writel(readl(&KERNEL_GPIOF_BASE->ODR) & (~(0x1 << 10)), &KERNEL_GPIOF_BASE->ODR);
    //     break;

    // case '5': /* LED3点亮 */
    //     writel(readl(&KERNEL_GPIOE_BASE->ODR) | (0x1 << 8), &KERNEL_GPIOE_BASE->ODR);
    //     break;

    // case '6': /* LED3熄灭 */
    //     writel(readl(&KERNEL_GPIOE_BASE->ODR) & (~(0x1 << 8)), &KERNEL_GPIOE_BASE->ODR);
    //     break;
    // }
    // kbuf[0] == 1 ? (writel(readl(&KERNEL_GPIOE_BASE->ODR) | ((1 << 10)), &KERNEL_GPIOE_BASE->ODR)) : (writel(readl(&KERNEL_GPIOE_BASE->ODR) & (~(1 << 10)), &KERNEL_GPIOE_BASE->ODR));
    return size;
}

long mycdev_ioctl(struct file* file, unsigned int cmd, unsigned long arg)
{
    switch (cmd) {
    case LED_ON:
        switch (arg) {
        case 1:
            writel(readl(&KERNEL_GPIOE_BASE->ODR) | (0x1 << 10), &KERNEL_GPIOE_BASE->ODR);
            break;

        case 2:
            writel(readl(&KERNEL_GPIOF_BASE->ODR) | (0x1 << 10), &KERNEL_GPIOF_BASE->ODR);
            break;

        case 3:
            writel(readl(&KERNEL_GPIOE_BASE->ODR) | (0x1 << 8), &KERNEL_GPIOE_BASE->ODR);
            break;

        default:
            break;
        }
        break;

    case LED_OFF:
        switch (arg) {
        case 1:
            writel(readl(&KERNEL_GPIOE_BASE->ODR) & (~(0x1 << 10)), &KERNEL_GPIOE_BASE->ODR);
            break;

        case 2:
            writel(readl(&KERNEL_GPIOF_BASE->ODR) & (~(0x1 << 10)), &KERNEL_GPIOF_BASE->ODR);
            break;

        case 3:
            writel(readl(&KERNEL_GPIOE_BASE->ODR) & (~(0x1 << 8)), &KERNEL_GPIOE_BASE->ODR);
            break;

        default:
            break;
        }
        break;

    default:
        break;
    }
    return 0;
}

int mycdev_close(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
    .unlocked_ioctl = mycdev_ioctl,
};

/**
 * @description: 入口：在安装驱动的时候入口函数执行,做资源申请的工作
 * demo_init:驱动入口的名字
 * __init:它是给编译器使用的,告诉编译器将这个函数放在.init.text段中
 * @return {*}
 */
static int __init demo_init(void)
{
    /* 1. 注册字符设备驱动 */
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0) {
        printk("register char device driver error errorcode = %d!\n", major);
        return major;
    }
    printk("create char device driver successful major = %d!\n", major);

    /* 2. 向上提交目录 */
    cls = class_create(THIS_MODULE, CNAME);
    if (IS_ERR(cls)) {
        printk("submit directory error\n");
        return -PTR_ERR(cls);
    }
    printk("submit directory ok\n");

    /* 3. 向上提交设备节点信息 */
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "myled");
    if (IS_ERR(dev)) {
        printk("submit device node information error\n");
        return -PTR_ERR(dev);
    }

    printk("submit device node information ok\n");

    // printk("init:%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

/**
 * @description: 出口：在卸载驱动的时候出口函数执行，做资源释放的工作
 * demo_exit:驱动出口的名字
 * __exit:它是给编译器使用的,告诉编译器将这个函数放在.exit.text段中
 * @return {*}
 */
static void __exit demo_exit(void)
{
    /* 取消地址映射 */
    iounmap(KERNEL_RCC_GPIO);
    iounmap(KERNEL_GPIOE_BASE);

    /* 1. 销毁提交设备节点信息 */
    device_destroy(cls, MKDEV(major, 0));

    /* 2. 销毁目录 */
    class_destroy(cls);
    /* 3. 注销字符设备驱动 */
    unregister_chrdev(major, CNAME);

    printk("exit:%s:%s:%d\n", __FILE__, __func__, __LINE__);
}

/* 告诉内核入口地址 */
module_init(demo_init);

/* 告诉内核出口地址 */
module_exit(demo_exit);

/* 许可证：遵从GPL协议 */
MODULE_LICENSE("GPL");
beep.c
/*
 * Copyright (c) 2023 by Huijie Xia, All Rights Reserved.
 * @Author: Huijie Xia
 * @Date: 2023-06-29 08:56:26
 * @LastEditTime: 2023-07-05 16:36:58
 * @FilePath: /B_Drive/day3/led_beep_fan_motor/beep.c
 * @version:
 * @Description: 驱动控制风扇
 */
#include "gpio.h"
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/uaccess.h>

#define CNAME "mybeep"
struct class* cls;
struct device* dev;

int major;
char kbuf[128] = { 0 };
unsigned int* KERNEL_RCC_GPIO;
gpio_t* KERNEL_GPIOB_BASE;

int mycdev_open(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    /* 地址映射 */
    KERNEL_RCC_GPIO = ioremap(PHY_RCC_GPIO, 4);
    if (KERNEL_RCC_GPIO == NULL) {
        printk("ioremap RCC error!\n");
        return -ENOMEM;
    }
    KERNEL_GPIOB_BASE = ioremap(PHY_GPIOB_BASE, sizeof(gpio_t));
    if (KERNEL_GPIOB_BASE == NULL) {
        printk("ioremap GPIOB BASE error!\n");
        return -ENOMEM;
    }

    /* 蜂鸣器(PB6)寄存器初始化(读,改,写) */
    writel(readl(KERNEL_RCC_GPIO) | (0x1 << 1), KERNEL_RCC_GPIO); /* GPIOB时钟使能 */
    writel(readl(&KERNEL_GPIOB_BASE->MODER) & (~(0x3 << 12)), &KERNEL_GPIOB_BASE->MODER); /* MODER寄存器13~12bit清零 */
    writel(readl(&KERNEL_GPIOB_BASE->MODER) | (0x1 << 12), &KERNEL_GPIOB_BASE->MODER); /* MODER寄存器设置为输出模式 */
    writel(readl(&KERNEL_GPIOB_BASE->ODR) & (~(0x1 << 6)), &KERNEL_GPIOB_BASE->ODR); /* 蜂鸣器熄灭 */

    return 0;
}

ssize_t mycdev_read(struct file* file, char __user* ubuf,
    size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf)) {
        size = sizeof(kbuf);
    }
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret) {
        printk("copy data to user error!\n");
        return -EIO;
    }
    return size;
}
ssize_t mycdev_write(struct file* file, const char __user* ubuf,
    size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf)) {
        size = sizeof(kbuf);
    }
    ret = copy_from_user(kbuf, ubuf, size);

    if (ret) {
        printk("copy data from user error!\n");
        return -EIO;
    }

    return size;
}

long mycdev_ioctl(struct file* file, unsigned int cmd, unsigned long arg)
{
    switch (cmd) {
    case BEEP_ON:
        writel(readl(&KERNEL_GPIOB_BASE->ODR) | (0x1 << 6), &KERNEL_GPIOB_BASE->ODR);
        break;

    case BEEP_OFF:
        writel(readl(&KERNEL_GPIOB_BASE->ODR) & (~(0x1 << 6)), &KERNEL_GPIOB_BASE->ODR);
        break;

    default:
        break;
    }
    return 0;
}

int mycdev_close(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
    .unlocked_ioctl = mycdev_ioctl,
};

/**
 * @description: 入口：在安装驱动的时候入口函数执行,做资源申请的工作
 * demo_init:驱动入口的名字
 * __init:它是给编译器使用的,告诉编译器将这个函数放在.init.text段中
 * @return {*}
 */
static int __init demo_init(void)
{
    /* 1. 注册字符设备驱动 */
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0) {
        printk("register char device driver error errorcode = %d!\n", major);
        return major;
    }
    printk("create char device driver successful major = %d!\n", major);

    /* 2. 向上提交目录 */
    cls = class_create(THIS_MODULE, CNAME);
    if (IS_ERR(cls)) {
        printk("submit directory error\n");
        return -PTR_ERR(cls);
    }
    printk("submit directory ok\n");

    /* 3. 向上提交设备节点信息 */
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, CNAME);
    if (IS_ERR(dev)) {
        printk("submit device node information error\n");
        return -PTR_ERR(dev);
    }

    printk("submit device node information ok\n");

    // printk("init:%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

/**
 * @description: 出口：在卸载驱动的时候出口函数执行，做资源释放的工作
 * demo_exit:驱动出口的名字
 * __exit:它是给编译器使用的,告诉编译器将这个函数放在.exit.text段中
 * @return {*}
 */
static void __exit demo_exit(void)
{
    /* 取消地址映射 */
    iounmap(KERNEL_RCC_GPIO);
    iounmap(KERNEL_GPIOB_BASE);

    /* 1. 销毁提交设备节点信息 */
    device_destroy(cls, MKDEV(major, 0));

    /* 2. 销毁目录 */
    class_destroy(cls);
    /* 3. 注销字符设备驱动 */
    unregister_chrdev(major, CNAME);

    printk("exit:%s:%s:%d\n", __FILE__, __func__, __LINE__);
}

/* 告诉内核入口地址 */
module_init(demo_init);

/* 告诉内核出口地址 */
module_exit(demo_exit);

/* 许可证：遵从GPL协议 */
MODULE_LICENSE("GPL");

fan.c

/*
 * Copyright (c) 2023 by Huijie Xia, All Rights Reserved.
 * @Author: Huijie Xia
 * @Date: 2023-06-29 08:56:26
 * @LastEditTime: 2023-07-05 16:59:43
 * @FilePath: /B_Drive/day3/led_beep_fan_motor/fan.c
 * @version:
 * @Description: 驱动控制风扇
 */
#include "gpio.h"
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/uaccess.h>

#define CNAME "myfan"
struct class* cls;
struct device* dev;

int major;
char kbuf[128] = { 0 };
unsigned int* KERNEL_RCC_GPIO;
gpio_t* KERNEL_GPIOE_BASE;
gpio_t* KERNEL_GPIOF_BASE;

int mycdev_open(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    /* 地址映射 */
    KERNEL_RCC_GPIO = ioremap(PHY_RCC_GPIO, 4);
    if (KERNEL_RCC_GPIO == NULL) {
        printk("ioremap RCC error!\n");
        return -ENOMEM;
    }
    KERNEL_GPIOE_BASE = ioremap(PHY_GPIOE_BASE, sizeof(gpio_t));
    if (KERNEL_GPIOE_BASE == NULL) {
        printk("ioremap GPIOE BASE error!\n");
        return -ENOMEM;
    }

    /* 风扇(PE9)寄存器初始化(读,改,写) */
    writel(readl(KERNEL_RCC_GPIO) | (0x1 << 4), KERNEL_RCC_GPIO); /* GPIOE时钟使能 */
    writel(readl(&KERNEL_GPIOE_BASE->MODER) & (~(0x3 << 18)), &KERNEL_GPIOE_BASE->MODER); /* MODER寄存器19~18bit清零 */
    writel(readl(&KERNEL_GPIOE_BASE->MODER) | (0x1 << 18), &KERNEL_GPIOE_BASE->MODER); /* MODER寄存器设置为输出模式 */
    writel(readl(&KERNEL_GPIOE_BASE->ODR) & (~(0x1 << 9)), &KERNEL_GPIOE_BASE->ODR); /* 风扇熄灭 */

    return 0;
}

ssize_t mycdev_read(struct file* file, char __user* ubuf,
    size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf)) {
        size = sizeof(kbuf);
    }
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret) {
        printk("copy data to user error!\n");
        return -EIO;
    }
    return size;
}
ssize_t mycdev_write(struct file* file, const char __user* ubuf,
    size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf)) {
        size = sizeof(kbuf);
    }
    ret = copy_from_user(kbuf, ubuf, size);

    if (ret) {
        printk("copy data from user error!\n");
        return -EIO;
    }

    return size;
}

long mycdev_ioctl(struct file* file, unsigned int cmd, unsigned long arg)
{
    switch (cmd) {
    case FAN_ON:
        writel(readl(&KERNEL_GPIOE_BASE->ODR) | (0x1 << 9), &KERNEL_GPIOE_BASE->ODR);
        break;

    case FAN_OFF:
        writel(readl(&KERNEL_GPIOE_BASE->ODR) & (~(0x1 << 9)), &KERNEL_GPIOE_BASE->ODR);
        break;

    default:
        break;
    }
    return 0;
}

int mycdev_close(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
    .unlocked_ioctl = mycdev_ioctl,
};

/**
 * @description: 入口：在安装驱动的时候入口函数执行,做资源申请的工作
 * demo_init:驱动入口的名字
 * __init:它是给编译器使用的,告诉编译器将这个函数放在.init.text段中
 * @return {*}
 */
static int __init demo_init(void)
{
    /* 1. 注册字符设备驱动 */
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0) {
        printk("register char device driver error errorcode = %d!\n", major);
        return major;
    }
    printk("create char device driver successful major = %d!\n", major);

    /* 2. 向上提交目录 */
    cls = class_create(THIS_MODULE, CNAME);
    if (IS_ERR(cls)) {
        printk("submit directory error\n");
        return -PTR_ERR(cls);
    }
    printk("submit directory ok\n");

    /* 3. 向上提交设备节点信息 */
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, CNAME);
    if (IS_ERR(dev)) {
        printk("submit device node information error\n");
        return -PTR_ERR(dev);
    }

    printk("submit device node information ok\n");

    // printk("init:%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

/**
 * @description: 出口：在卸载驱动的时候出口函数执行，做资源释放的工作
 * demo_exit:驱动出口的名字
 * __exit:它是给编译器使用的,告诉编译器将这个函数放在.exit.text段中
 * @return {*}
 */
static void __exit demo_exit(void)
{
    /* 取消地址映射 */
    iounmap(KERNEL_RCC_GPIO);
    iounmap(KERNEL_GPIOE_BASE);

    /* 1. 销毁提交设备节点信息 */
    device_destroy(cls, MKDEV(major, 0));

    /* 2. 销毁目录 */
    class_destroy(cls);
    /* 3. 注销字符设备驱动 */
    unregister_chrdev(major, CNAME);

    printk("exit:%s:%s:%d\n", __FILE__, __func__, __LINE__);
}

/* 告诉内核入口地址 */
module_init(demo_init);

/* 告诉内核出口地址 */
module_exit(demo_exit);

/* 许可证：遵从GPL协议 */
MODULE_LICENSE("GPL");

motor.c

/*
 * Copyright (c) 2023 by Huijie Xia, All Rights Reserved.
 * @Author: Huijie Xia
 * @Date: 2023-06-29 08:56:26
 * @LastEditTime: 2023-07-05 16:53:57
 * @FilePath: /B_Drive/day3/led_beep_fan_motor/motor.c
 * @version:
 * @Description: 驱动控制马达
 */
#include "gpio.h"
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/uaccess.h>

#define CNAME "mymotor"
struct class* cls;
struct device* dev;

int major;
char kbuf[128] = { 0 };
unsigned int* KERNEL_RCC_GPIO;
gpio_t* KERNEL_GPIOF_BASE;

int mycdev_open(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    /* 地址映射 */
    KERNEL_RCC_GPIO = ioremap(PHY_RCC_GPIO, 4);
    if (KERNEL_RCC_GPIO == NULL) {
        printk("ioremap RCC error!\n");
        return -ENOMEM;
    }
    KERNEL_GPIOF_BASE = ioremap(PHY_GPIOF_BASE, sizeof(gpio_t));
    if (KERNEL_GPIOF_BASE == NULL) {
        printk("ioremap GPIOB BASE error!\n");
        return -ENOMEM;
    }

    /* 马达(PF6)寄存器初始化(读,改,写) */
    writel(readl(KERNEL_RCC_GPIO) | (0x1 << 5), KERNEL_RCC_GPIO); /* GPIOB时钟使能 */
    writel(readl(&KERNEL_GPIOF_BASE->MODER) & (~(0x3 << 12)), &KERNEL_GPIOF_BASE->MODER); /* MODER寄存器13~12bit清零 */
    writel(readl(&KERNEL_GPIOF_BASE->MODER) | (0x1 << 12), &KERNEL_GPIOF_BASE->MODER); /* MODER寄存器设置为输出模式 */
    writel(readl(&KERNEL_GPIOF_BASE->ODR) & (~(0x1 << 6)), &KERNEL_GPIOF_BASE->ODR); /* 马达熄灭 */

    return 0;
}

ssize_t mycdev_read(struct file* file, char __user* ubuf,
    size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf)) {
        size = sizeof(kbuf);
    }
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret) {
        printk("copy data to user error!\n");
        return -EIO;
    }
    return size;
}
ssize_t mycdev_write(struct file* file, const char __user* ubuf,
    size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf)) {
        size = sizeof(kbuf);
    }
    ret = copy_from_user(kbuf, ubuf, size);

    if (ret) {
        printk("copy data from user error!\n");
        return -EIO;
    }

    return size;
}

long mycdev_ioctl(struct file* file, unsigned int cmd, unsigned long arg)
{
    switch (cmd) {
    case MOTOR_ON:
        writel(readl(&KERNEL_GPIOF_BASE->ODR) | (0x1 << 6), &KERNEL_GPIOF_BASE->ODR);
        break;

    case MOTOR_OFF:
        writel(readl(&KERNEL_GPIOF_BASE->ODR) & (~(0x1 << 6)), &KERNEL_GPIOF_BASE->ODR);
        break;

    default:
        break;
    }
    return 0;
}

int mycdev_close(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
    .unlocked_ioctl = mycdev_ioctl,
};

/**
 * @description: 入口：在安装驱动的时候入口函数执行,做资源申请的工作
 * demo_init:驱动入口的名字
 * __init:它是给编译器使用的,告诉编译器将这个函数放在.init.text段中
 * @return {*}
 */
static int __init demo_init(void)
{
    /* 1. 注册字符设备驱动 */
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0) {
        printk("register char device driver error errorcode = %d!\n", major);
        return major;
    }
    printk("create char device driver successful major = %d!\n", major);

    /* 2. 向上提交目录 */
    cls = class_create(THIS_MODULE, CNAME);
    if (IS_ERR(cls)) {
        printk("submit directory error\n");
        return -PTR_ERR(cls);
    }
    printk("submit directory ok\n");

    /* 3. 向上提交设备节点信息 */
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, CNAME);
    if (IS_ERR(dev)) {
        printk("submit device node information error\n");
        return -PTR_ERR(dev);
    }

    printk("submit device node information ok\n");

    // printk("init:%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

/**
 * @description: 出口：在卸载驱动的时候出口函数执行，做资源释放的工作
 * demo_exit:驱动出口的名字
 * __exit:它是给编译器使用的,告诉编译器将这个函数放在.exit.text段中
 * @return {*}
 */
static void __exit demo_exit(void)
{
    /* 取消地址映射 */
    iounmap(KERNEL_RCC_GPIO);
    iounmap(KERNEL_GPIOF_BASE);

    /* 1. 销毁提交设备节点信息 */
    device_destroy(cls, MKDEV(major, 0));

    /* 2. 销毁目录 */
    class_destroy(cls);
    /* 3. 注销字符设备驱动 */
    unregister_chrdev(major, CNAME);

    printk("exit:%s:%s:%d\n", __FILE__, __func__, __LINE__);
}

/* 告诉内核入口地址 */
module_init(demo_init);

/* 告诉内核出口地址 */
module_exit(demo_exit);

/* 许可证：遵从GPL协议 */
MODULE_LICENSE("GPL");
test.c
/*
 * Copyright (c) 2023 by Huijie Xia, All Rights Reserved.
 * @Author: Huijie Xia
 * @Date: 2023-07-03 14:44:33
 * @LastEditTime: 2023-07-05 16:59:23
 * @FilePath: /B_Drive/day3/led_beep_fan_motor/test.c
 * @version:
 * @Description: 驱动控制硬件的测试文件
 */

#include "gpio.h"
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#define ERR_MSG(msg)                              \
    do {                                          \
        fprintf(stderr, "line : %d\n", __LINE__); \
        perror(msg);                              \
    } while (0)

char buf[128] = { 0 };
int main(int argc, const char* argv[])
{
    int ledfd, beepfd, fanfd, motorfd; /* 文件描述符 */
    int hardware_which; /* 硬件设备选择 */
    int choice; /* 设备选择 */
    int whichled; /* LED选择 */

    /* 打开LED驱动文件 */
    if ((ledfd = open("/dev/myled", O_RDWR)) == -1)
        ERR_MSG("myled open error");

    /* 打开蜂鸣器驱动文件 */
    if ((beepfd = open("/dev/mybeep", O_RDWR)) == -1)
        ERR_MSG("mybeep open error");

    /* 打开风扇驱动文件 */
    if ((fanfd = open("/dev/myfan", O_RDWR)) == -1)
        ERR_MSG("myfan open error");

    /* 打开马达驱动文件 */
    if ((motorfd = open("/dev/mymotor", O_RDWR)) == -1)
        ERR_MSG("mymotor open error");

    while (1) {
        printf("请输入你要执行的硬件设备\n");
        printf("1(LED灯) 2(蜂鸣器) 3(风扇) 4(马达) > ");
        scanf("%d", &hardware_which);
        switch (hardware_which) {
        case 1:
            printf("请选择要控制的LED\n");
            printf("1(LED1) 2(LED2) 3(LED3) > ");
            scanf("%d", &whichled);
            printf("请选择要实现的功能\n");
            printf("0(关灯) 1(开灯) > ");
            scanf("%d", &choice);
            if (choice == 0) {
                ioctl(ledfd, LED_OFF, whichled);
            } else {
                ioctl(ledfd, LED_ON, whichled);
            }
            break;

        case 2:
            printf("请选择要实现的蜂鸣器功能\n");
            printf("0(不响) 1(响) > ");
            scanf("%d", &choice);
            if (choice == 0) {
                ioctl(beepfd, BEEP_OFF);
            } else {
                ioctl(beepfd, BEEP_ON);
            }
            break;

        case 3:
            printf("请选择要实现的风扇功能\n");
            printf("0(停止) 1(转动) > ");
            scanf("%d", &choice);
            if (choice == 0) {
                ioctl(fanfd, FAN_OFF);
            } else {
                ioctl(fanfd, FAN_ON);
            }
            break;

        case 4:
            printf("请选择要实现的马达功能\n");
            printf("0(停止) 1(振动) > ");
            scanf("%d", &choice);
            if (choice == 0) {
                ioctl(motorfd, MOTOR_OFF);
            } else {
                ioctl(motorfd, MOTOR_ON);
            }
            break;

        default:
            break;
        }
    }

    close(ledfd);
    close(beepfd);
    close(fanfd);
    close(motorfd);
    return 0;
}
效果如下图：

欲上层楼 再上层楼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux驱动开发相关资料
08-27
4. **驱动编程接口**：Linux提供了丰富的驱动开发接口，如ioctl、read、write、open、release等系统调用，以及注册/卸载驱动、设备探测、中断处理等函数。掌握这些接口的使用是驱动开发的关键。 5. **中断处理**：...
Linux下I2C设备驱动开发和实现
08-03
Linux下的I2C设备驱动开发涉及对I2C总线的理解和Linux内核中的I2C框架的交互。I2C（Inter-Integrated Circuit）总线是一种简单且高效的两线制串行通信协议，用于连接微控制器和其他外围设备。本文将深入探讨I2C总线...
驱动开发作业3——GPIO子系统
qq_43921012的博客
07-11 776
chrdevled.c(驱动文件)
驱动开发作业3——不同的设备文件控制不同的LED
qq_43921012的博客
07-06 536
【代码】驱动开发作业3——不同的设备文件控制不同的LED。
华清远见嵌入式学习——驱动开发——作业1
qq_54502935的博客
02-18 1939
通过字符设备驱动分步注册过程实现LED驱动的编写，编写应用程序测试，发布到CSDN 应用程序： 头文件：
Linux 设备驱动程序（三）
Liuqz2009的专栏
05-23 777
内核逻辑地址组成了内核的常规地址空间。在大多数体系架构中，逻辑地址和与其相关联的物理地址的不同，仅仅是在它们之间存在一个固定的偏多量。逻辑地址使用硬件内建的指针大小，因此在安装了大量内存的。内核虚拟地址和逻辑地址的相同之处在于，它们都将内核空间的地址映射到物理地址上。内核虚拟地址与物理地址的映射不必是线性的和一对一的，而这是逻辑地址空间的特点。所有的逻辑地址都是内核虚拟地址，但是许多内核虚拟地址不是逻辑地址。位的，这取决于硬件的体系架构。分配的内存具有一个虚拟地址（但并不存在直接的物理映射）。
驱动开发 作业3
cyan的博客
07-06 369
编写LED灯的驱动，创建三个设备文件，每个设备文件和一个LED灯绑定，当操作这个设备文件时只能控制设备文件对应的这盏灯。
程序人生大作业——hello的一生
Studying_wolf的博客
06-14 936
1.1.1 P2P（From Program to Process）过程：program指的是hello.c需要经过预处理器cpp的预处理变为hello.i，再经过编译器ccl将hello.i变为hello.s，再经过汇编器as将hello.s变为hello.o（可重定位目标程序（二进制）），最后由连接器ld将所有依赖的库进行链接获得hello这个可执行目标程序。而process指的是通过系统创建一个新进程并且把程序内容加载即shell通过fork产生子进程的过程。
华清远见嵌入式学习——驱动开发——day9
qq_54502935的博客
02-23 909
【代码】华清远见嵌入式学习——驱动开发——day9。
华清远见嵌入式学习——驱动开发——DAY8
qq_54502935的博客
02-22 579
1.使用GPIO子系统编写LED灯驱动，应用程序测试2.注册三个按键的中断，只需要写内核代码需要发布到CSDN 驱动程序：
哈工大计算机系统24年春csapp大作业——程序人生
winery_wanna的博客
06-14 321
计算机系统大作业题 目 程序人生-Hello’s P2P 专 业 人工智能 学　　 号 2022112612 班 级 2203602 学 生 陈思华 指 导 教 师 吴锐 计算机科学与技术学院2024年5月摘 要本文从c程序hello.c着手，详细介绍了hello程序在Linux系统下从源代码到执
IOCTL_Test.rar_IOCTL__USB 驱动开发 3.2_ioctl_ioctl u_usb ioctl
09-24
"IOCTL (Input/Output Control) Test.rar"这个压缩包文件显然包含了关于如何使用IOCTL进行USB驱动开发的相关资料，特别是针对"3.2 ioctl_ioctl u_usb ioctl"这个特定主题。以下是对这些知识点的详细阐述： **IOCTL ...
Linux设备驱动开发.ppt
11-15
Linux 设备驱动开发 Linux 设备驱动开发是指在 Linux 操作系统中，开发和管理设备驱动程序的过程。设备驱动程序是操作系统内核和机器硬件之间的接口，它为用户屏蔽了各种各样的设备。 Linux 设备驱动程序是一组由...
Linux设备驱动开发入门
06-08
Linux设备驱动开发是嵌入式系统领域中的一个重要环节，它涉及到操作系统与硬件之间的交互，使得硬件功能能够被操作系统和应用程序有效利用。本课程主要针对Linux系统，深入浅出地介绍了如何进行驱动程序的开发，包括...
windows USB 设备驱动开发-开发Type C接口的驱动程序(一)
苏洛的博客
07-20 934
如果 USB Type-C 系统未实现 PD 状态机，或者它实现了状态机，但不支持通过非 ACPI 传输 UCSI，则需要为连接器编写驱动程序。 如果存在，可以加载 Microsoft 提供的 UCSI 驱动程序。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第三十六章 Linux驱动初探
BeiJingXunWei的博客
07-19 875
Linux设备驱动会以内核模块的形式出现，因为linux内核的整体架构就非常庞大，包含的组件也非常多，如果把所有的功能都编译到linux内核中会使得内核非常臃肿，为了解决这个问题，更方便地新增和删除功能，linux提供了这样的机制，这种机制被称为模块。单片机开发包括：程序设计（PC端软件编程），程序送往执行（将编程好的软件下载到单片机，需要编程器或者下载线），单片机系统的设计（硬件上设计你需要的任务的执行机构，如控制开关，温度检测，红外传输等等，都是根据你的所需，然后在选择对应的硬件器件）。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第三十九章 Linux MISC驱动
最新发布
BeiJingXunWei的博客
07-22 264
misc 的意思是混合的杂项的，所以 misc 设备驱动也叫做杂项设备驱动，当我们板子上的某个设备没有办法分类时，就可以用 misc 设备驱动。设备号包含主设备号和次设备号，设备号是计算机识别设备的一种方式，主设备号相同的就被视为同一类设备，主设备号在Linux系统里面是唯一的，次设备号不一定唯一。所有的 misc 设备驱动的主设备号都为 10，不同的设备使用不同的从设备号。通过39.1章节的学习，我们已经把杂项设备的基本概念搞懂了，在本实验中，使用 misc 设备驱动的方式来编写最简单的杂项设备的驱动。
I2C总线二级外设驱动开发（函数和代码详解）
weixin_58809023的博客
07-22 677
I2C总线是一种广泛使用的串行通信总线，用于连接微控制器及其外围设备。在Linux内核中，I2C总线驱动开发包括I2C总线控制器驱动（也称为适配器驱动）和挂接在I2C总线上的二级外设驱动（也称为客户驱动或设备驱动）。疑惑1：二级外设驱动编写好，那总线上的那个iic驱动不需要编写吗当你为挂接在I2C总线上的二级外设编写驱动程序（也称为客户驱动或设备驱动）时，你通常不需要从头开始编写整个I2C总线（也称为I2C适配器）的驱动程序，除非该I2C总线控制器是全新的、且Linux内核中尚不支持的。
Windows CE设备驱动程序开发：IOCTL命令详解
"系统服务IOCTL命令用于设备驱动程序开发，包括IOCTL_SERVICE_START、IOCTL_SERVICE_STOP、IOCTL_SERVICE_REFRESH、IOCTL_SERVICE_INSTALL、IOCTL_SERVICE_STATUS和IOCTL_SERVICE_SUPPORTED_OPTIONS等关键命令，这些...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值