驱动开发作业2 —— ioctl

news2024/11/24 18:43:35

通过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;
}
效果如下图：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/721419.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Ubuntu/Debian等Linux系统安装微信客户端

Ubuntu/Debian等Linux系统安装微信客户端

【写在前面】 由于本人的工作环境基本是在ubuntu下&#xff0c;而ubuntu使用网页版微信常常会出现无法登陆的现象&#xff0c;为了能够在linux系统用上微信&#xff0c;于是在网上找了找办法&#xff0c;没想到还真有大神做了&#xff0c;特此分享出来。 【安装步骤】 其实只…
阅读更多...
UNIX网络编程卷一 学习笔记 第二十二章 高级UDP套接字编程

UNIX网络编程卷一 学习笔记 第二十二章 高级UDP套接字编程

TCP是一个字节流协议&#xff0c;又使用滑动窗口&#xff0c;因此没有记录边界或发送者数据发送能力超过接收者接受能力之类的事情&#xff0c;但对于UDP&#xff0c;每个输入操作对应一个UDP数据报&#xff08;一个记录&#xff09;&#xff0c;因此当收取的数据报大于引用的输…
阅读更多...
软件测试--Fiddler的使用(持续更新)

软件测试--Fiddler的使用(持续更新)

1.工具界面介绍 2.抓取请求 打开Fiddler,随便访问一些网址,左边便会抓取到很多请求 3.删除请求(Remove all或者输入命令) 4.过滤请求 ps: 5.打开抓HTTPS设置 6.界面熟悉 7.抓包图标说明
阅读更多...
MPC vs Multi-sig——误解及重点关注

MPC vs Multi-sig——误解及重点关注

1. 引言 资金托管的2大主流方案为&#xff1a; MPC&#xff1a;MPC钱包——对应EOA账号。用于高信任企业场景。Multi-sig&#xff1a;多签钱包——对应智能合约钱包。用于个人场景&#xff0c;可强化安全性并易于恢复。 不过V神认为&#xff0c;基于MPC的EOA账号存在根本性缺…
阅读更多...
不变的誓言 字符串常量

不变的誓言 字符串常量

## 不变的誓言 字符串常量字符串常量&#xff0c;这节课的主题、 水帘洞一直都没有变1.什么是字符串呢&#xff1f; 就是一个一个字符连起来就是字符串&#xff0c;qq聊天 都是字符串。 字符串常量&#xff0c;“”1.什么是字符串呢&#xff1f; 就是一个一个字符连起来就是字…
阅读更多...
sqlserver收缩数据库

sqlserver收缩数据库

1.收缩数据库 首先收缩的前提是需要有可用空间如下图&#xff0c;没有可用空间无法收缩数据库 2.减小数据库大小 通过链接: 查询数据库中各表的大小 如果查询的比较大而且无用的数据可以直接把表结构给拿出来&#xff0c;然后删除该表空间就直接释放出来了 3.收缩文件 我…
阅读更多...
SpringBoot项目打包部署后页面无法访问问题定位处理记录

SpringBoot项目打包部署后页面无法访问问题定位处理记录

问题描述 项目在idea中可以正常访问&#xff0c;但是达成jar包后访问时候访问异常&#xff0c;并报错&#xff0c;部分异常栈如下: org.thymeleaf.exceptions.TemplateInputException: Error resolving template [/views/login], template might not exist or might not be a…
阅读更多...
插入排序（直接插入排序 折半插入排序）

插入排序（直接插入排序 折半插入排序）

直接插入排序 void InsertSort(ElemType A[],int n) {int i,j;for(i2;i<n;i)if(A[i]<A[i-1]){A[0]A[i];for(ji-1;A[0]<A[j];--j)A[j1]A[j];A[j1]A[0];} }折半插入排序 void BinInsertSort(int A[],int n) {int i,j,low,high,mid;for(i2;i<n;i){A[0]A[i];low1;high…
阅读更多...
【MySQL】基本查询之表的增删改查

【MySQL】基本查询之表的增删改查

【MySQL】表的增删改查 一、插入操作----insert1.1 简单插入1.2 插入时是否更新----ON DUPLICATE KEY UPDATE1.3 插入时替换----REPLACE 二、查询----select2.1 简单查询与去重2.2 基本查询----where条件2.2.3 案列演示 2.4 排序----order by 三、修改操作----update四、删除--…
阅读更多...
产品经理有效管理项目进度的5个关键方法

产品经理有效管理项目进度的5个关键方法

作为产品经理&#xff0c;管理项目进度是确保产品开发成功的关键组成部分。产品经理负责推动产品开发过程&#xff0c;并确保团队在最后期限前完成并保持在正轨上。以下是产品经理有效管理项目进度的一些关键方法。 1、创建详细的项目进度表 这个时间表应该包括开发过程的所有任…
阅读更多...
java业务开发经典常见错误例子

java业务开发经典常见错误例子

java业务开发经典常见错误例子 文章目录 java业务开发经典常见错误例子1.ThreadLocal线程重用导致用户信息错乱的 Bug2.使用了线程安全的并发工具&#xff0c;并不代表解决了所有线程安全问题3.没有认清并发工具的使用场景&#xff0c;导致性能问题4.加锁前要清楚锁和被保护的对…
阅读更多...
DM8:达梦数据库数据文件与日志文件介绍

DM8:达梦数据库数据文件与日志文件介绍

DM8:达梦数据库数据文件与日志文件介绍 环境介绍1 表空间中的数据文件1.1 表空间1.2 数据文件1.3 系统自带的表空间1.3.1 SYSTEM 表空间1.3.2 ROLL 表空间1.3.3 TEMP 表空间1.3.4 MAIN 表空间1.3.5 用户自定义表空间1.3.6 DM数据库的表空间和数据文件分布 2 日志文件2.1 重做日…
阅读更多...
Redis 数据库的概念、常用命令

Redis 数据库的概念、常用命令

Redis数据库 一、关系数据库与非关系型数据库概述1、关系型数据库2、非关系型数据库3、关系数据库与非关系型数据库区别&#xff08;1&#xff09;数据存储方式不同&#xff08;2&#xff09;扩展方式不同&#xff08;3&#xff09;对事务性的支持不同 4、非关系型数据库产生背…
阅读更多...
【数据结构课程设计系列】完全二叉树操作演示

【数据结构课程设计系列】完全二叉树操作演示

完全二叉数操作演示 1.完全二叉树操作演示要求&#xff1a; &#xff08;1&#xff09;创建完全二叉树(用顺序方式存储) &#xff08;2&#xff09;求二叉树的深度和叶子结点数 &#xff08;3&#xff09;实现二叉树的前序、中序、后序和层次遍历。 &#xff08;4&#xff09;…
阅读更多...
基于ubuntu的驱动开发

基于ubuntu的驱动开发

一般的linux驱动开发都是基于交叉编译来进行的&#xff0c;本文尝试着从另一个角度&#xff1a;基于ubuntu的本地驱动开发来学习一下驱动的开发 一、驱动的开发与编译 1.1、编写驱动文件 #include <linux/init.h> #include <linux/module.h> static int hello_i…
阅读更多...
FL Studio中文版21最新免费音乐编曲软件制作工具

FL Studio中文版21最新免费音乐编曲软件制作工具

FL Studio较为适合专业的音乐制作者&#xff0c;操作难度较大&#xff0c;学习门槛也较高&#xff1b;Studio One则主打一站式的音乐制作&#xff0c;从编曲到录音到后期的专辑制作都可以在其中实现&#xff0c;同时操作难度不大&#xff0c;对初学者和业余爱好者都较为友好。 …
阅读更多...
【NX】NX二次开发中自动选择当前实体和方向

【NX】NX二次开发中自动选择当前实体和方向

在NX的二次开发中&#xff0c;我们经常需要选择实体和方向&#xff0c;如果每次手动选择&#xff0c;势必会影响调试的效率&#xff0c;那么有没有办法&#xff0c;让程序一启动就自动选择当前实体和方向呢&#xff0c;自然是有的。 经过我一番研究&#xff0c;因为可能有多个实…
阅读更多...
Apikit 自学日记：团队管理

Apikit 自学日记：团队管理

团队管理 一、工作空间管理 工作空间类似于部门或公司的概念&#xff0c;能帮助您更好地管理团队。 1.1 创建空间 点击页面左上角功能菜单&#xff0c;在下拉菜单中选择要切换的工作空间。 点击创建/加入&#xff0c;在引导页面中选择创建工作空间&#xff0c;填写工作空间…
阅读更多...
JavaWeb HttpServletRequest

JavaWeb HttpServletRequest

1.HttpServletRequest HttpServletRequest是Java Servlet API中的一个接口&#xff0c;用于表示HTTP请求的对象。 它提供了访问HTTP请求的各种信息和功能&#xff0c;包括请求方法、请求URL、请求头、请求参数、请求体等。 HttpServletRequest是由Servlet容器&#xff08;如…
阅读更多...
利用PPT制作简单的矢量图

利用PPT制作简单的矢量图

1.用PPT画一个图形&#xff08;可以多个图&#xff09; 2.鼠标圈住图形 3.利用 Ctrl G 组合图形&#xff0c;再用 Ctrl C 复制 4.打开word—粘贴—选择性粘贴—图片&#xff08;增强性图元文件&#xff09; 确认即可。
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023