2023.2.7 作业-CSDN博客

本文链接：https://blog.csdn.net/zhang_c_x/article/details/128922643

一、编写LED灯的设备驱动及测试代码，实现终端控制输入LED灯的亮灭。

自定义头文件：led.h

#ifndef __LED_H__
#define __LED_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  GPIOA   (0x50002000)
#define  GPIOB   (0x50003000)
#define  GPIOC   (0x50004000)
#define  GPIOD   (0x50005000)
#define  GPIOE   (0x50006000)
#define  GPIOF   (0x50007000)
#define  GPIOG   (0x50008000)
#define  GPIOH   (0x50009000)
#define  GPIOI   (0x5000A000)
#define  GPIOJ   (0x5000B000)
#define  GPIOK   (0x5000C000)
#define  GPIOZ   (0x54004000)

#define RCC_MP_SETENR (0x50000A28)

#endif

LED灯的设备驱动文件：led_dev.c

#include <linux/init.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/module.h>
#include "led.h"

ssize_t led_dev_read(struct file *file, char __user *ubuf, size_t size, loff_t *off);
ssize_t led_dev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *off);
int led_dev_open(struct inode *inode, struct file *file);
int led_dev_close(struct inode *inode, struct file *file);

char kbuf[64] = {0};

struct char_dev {
    int major;
    char *dev_name;
    gpio_t *gpiof;
    gpio_t *gpioe;
    unsigned int *rcc;
    struct file_operations fops;
};

struct char_dev led_dev = {
    .dev_name="myled",
    .fops={
        .open=led_dev_open,
        .read=led_dev_read,
        .write=led_dev_write,
        .release=led_dev_close,
    }
};

static int __init led_dev_init(void)
{
    led_dev.major = register_chrdev(0,led_dev.dev_name,&led_dev.fops);
    if(led_dev.major<0){
        printk("字符设备注册失败\n");
        return led_dev.major;
    }
    printk("字符设备注册成功，主设备号=%d\n",led_dev.major);

    led_dev.gpioe = ioremap(GPIOE,sizeof(gpio_t));
    if(led_dev.gpioe==NULL){
        printk("ioremap gpioe failed\n");
        return -ENOMEM;
    }

    led_dev.gpiof = ioremap(GPIOF,sizeof(gpio_t));
    if(led_dev.gpiof==NULL){
        printk("ioremap gpiof failed\n");
        return -ENOMEM;
    }

    led_dev.rcc = ioremap(RCC_MP_SETENR,4);
    if(led_dev.rcc==NULL){
        printk("ioremap rcc failed\n");
        return -ENOMEM;
    }

    printk("寄存器映射成功\n");

    *led_dev.rcc |= (0x3 << 4);

    led_dev.gpioe->MODER &= (~(0x3 << 20));
    led_dev.gpioe->MODER |= (0x1 << 20);

    led_dev.gpioe->MODER &= (~(0x3 << 16));
    led_dev.gpioe->MODER |= (0x1 << 16);

    led_dev.gpiof->MODER &= (~(0x3 << 20));
    led_dev.gpiof->MODER |= (0x1 << 20);

    led_dev.gpioe->ODR &= (~(0x1 << 10));
    led_dev.gpioe->ODR &= (~(0x1 << 8));
    led_dev.gpiof->ODR &= (~(0x1 << 10));

    printk("寄存器初始化成功\n");

    return 0;
}

static void __exit led_dev_exit(void)
{
    led_dev.gpioe->ODR &= (~(0x1 << 10));
    led_dev.gpioe->ODR &= (~(0x1 << 8));
    led_dev.gpiof->ODR &= (~(0x1 << 10));
    iounmap(led_dev.gpioe);
    iounmap(led_dev.gpiof);
    iounmap(led_dev.rcc);
    unregister_chrdev(led_dev.major, led_dev.dev_name);
}

module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");

ssize_t led_dev_read(struct file *file, char __user *ubuf, size_t size, loff_t *off)
{
    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_to_user failed\n");
        return -EIO;
    }
    return 0;
}

ssize_t led_dev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *off)
{
    int ret;
    if(size>sizeof(kbuf))
        size=sizeof(kbuf);
    ret = copy_from_user(kbuf,ubuf,size);
    if(ret){
        printk("copy_from_user failed\n");
        return -EIO;
    }
    switch(kbuf[0]){
        case '0':
            led_dev.gpioe->ODR |= (0x1 << 10);
            break;
        case '1':
            led_dev.gpioe->ODR &= (~(0x1 << 10));
            break;
        case '2':
            led_dev.gpiof->ODR |= (0x1 << 10);
            break;
        case '3':
            led_dev.gpiof->ODR &= (~(0x1 << 10));
            break;
        case '4':
            led_dev.gpioe->ODR |= (0x1 << 8);
            break;
        case '5':
            led_dev.gpioe->ODR &= (~(0x1 << 8));
            break;
    }
    return 0;
}

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

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

LED灯的测试文件：test.c

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

#define PRINT_ERR(msg) \
    do                 \
    {                  \
        perror(msg);   \
        return -1;     \
    } while (0)

int main(int argc,const char * argv[])
{
    char buf[64]={0};
    int fd = open("/dev/chrdev", O_RDWR);
    if(fd<0){
        PRINT_ERR("open error");
    }
    while(1){
        printf("Please input ( LED_x_ON[x*2] LED_x_OFF[x*2+1] (x=0,1,2) ) >> ");
        memset(buf, 0, sizeof(buf));
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf) - 1] = '\0';
        write(fd,buf,sizeof(buf));
    }
    close(fd);
    return 0;
}

将编译生成的led_dev.ko文件和a.out文件，拷贝到nfs服务器目录下的根文件系统目录下，并启动开发板。

测试流程：