2023.2.8 作业

已于 2023-02-14 19:28:23 修改
阅读量212 收藏
点赞数 1
CC 4.0 BY-SA版权
文章标签： 嵌入式硬件
于 2023-02-08 19:34:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhang_c_x/article/details/128942049
该文章展示了如何利用ioctl函数在Linux内核中编写驱动程序，控制开发板上的6个LED灯、有源蜂鸣器和震动马达。通过定义自定义命令，实现对GPIO端口的操作，以开关设备。代码包括了设备注册、初始化、打开、关闭以及读写和ioctl接口的实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、使用ioctl函数驱动控制开发板上6个LED灯的亮灭，以及有源蜂鸣器和有源震动马达。

驱动文件：chrdev.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"

enum{
    LED1,
    LED2,
    LED3,
    LED4,
    LED5,
    LED6,
    BEEP,
    MOTOR
};

#define ON _IOW('l', 1, int)
#define OFF _IOW('l',0,int)

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);
long led_dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

char kbuf[64] = {0};

struct char_dev {
    int major;
    char *dev_name;
    struct class *cls;
    struct device *dev;
    gpio_t *gpiob;
    gpio_t *gpioe;
    gpio_t *gpiof;
    gpio_t *gpioz;
    unsigned int *rcc;
    unsigned int *rcc_z;
    struct file_operations fops;
};

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

void all_device_init(void)
{
    *led_dev.rcc |= (0x3 << 4);
    *led_dev.rcc |= (0x1 << 1);
    *led_dev.rcc_z |= 0x1;

    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.gpiof->MODER &= (~(0x3 << 12));
    led_dev.gpiof->MODER |= (0x1 << 12);

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

    led_dev.gpioz->MODER &= (~(0x3f << 10));
    led_dev.gpioz->MODER |= (0x15 << 10);

    led_dev.gpioe->ODR &= (~(0x1 << 10));
    led_dev.gpioe->ODR &= (~(0x1 << 8));
    led_dev.gpiof->ODR &= (~(0x1 << 10));
    led_dev.gpiof->ODR &= (~(0x1 << 6));
    led_dev.gpiob->ODR &= (~(0x1 << 6));
    led_dev.gpioz->ODR &= (~(0x7 << 5));
}

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

    ///向上提交目录
    led_dev.cls = class_create(THIS_MODULE,led_dev.dev_name);
    if(IS_ERR(led_dev.cls)){
        printk("向上提交目录失败\n");
        ret = PTR_ERR(led_dev.cls);
        goto ERR2;
    }
    printk("向上提交目录成功\n");

    //向上提交节点信息
    led_dev.dev = device_create(led_dev.cls, NULL, MKDEV(led_dev.major, 0), NULL,"mychrdev");
    if(IS_ERR(led_dev.dev)){
        printk("向上提交节点信息失败\n");
        ret=PTR_ERR(led_dev.dev);
        goto ERR3;
    }
    printk("向上提交节点信息成功\n");

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

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

    led_dev.rcc = ioremap(RCC_MP_AHB4ENSETR,4);
    if(led_dev.rcc==NULL){
        printk("ioremap rcc failed\n");
        ret=-ENOMEM;
        goto ERR6;
    }

    led_dev.gpioz = ioremap(GPIOZ,sizeof(gpio_t));
    if(led_dev.gpioz==NULL){
        printk("ioremap gpioz failed\n");
        ret=-ENOMEM;
        goto ERR7;
    }

    led_dev.gpiob = ioremap(GPIOB,sizeof(gpio_t));
    if(led_dev.gpiob==NULL){
        printk("ioremap gpiob failed\n");
        ret=-ENOMEM;
        goto ERR8;
    }

    led_dev.rcc_z = ioremap(RCC_MC_AHB5ENSETR,4);
    if(led_dev.rcc_z==NULL){
        printk("ioremap rcc_z failed\n");
        ret=-ENOMEM;
        goto ERR9;
    }
    printk("寄存器映射成功\n");

    all_device_init();

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

ERR9:
    iounmap(led_dev.gpiob);
ERR8:
    iounmap(led_dev.gpioz);
ERR7:
    iounmap(led_dev.rcc);
ERR6:
    iounmap(led_dev.gpiof);
ERR5:
    iounmap(led_dev.gpioe);
ERR4:
    device_destroy(led_dev.cls, MKDEV(led_dev.major, 0));
ERR3:
    class_destroy(led_dev.cls);
ERR2:
    unregister_chrdev(led_dev.major, led_dev.dev_name);
ERR1:
    return ret;
}

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));
    led_dev.gpioz->ODR &= (~(0x1 << 5));
    led_dev.gpioz->ODR &= (~(0x1 << 6));
    led_dev.gpioz->ODR &= (~(0x1 << 7));
    led_dev.gpiob->ODR &= (~(0x1 << 6));
    led_dev.gpiof->ODR &= (~(0x1 << 6));

    iounmap(led_dev.rcc_z);
    iounmap(led_dev.gpiob);
    iounmap(led_dev.gpioz);
    iounmap(led_dev.rcc);
    iounmap(led_dev.gpioe);
    iounmap(led_dev.gpiof);

    device_destroy(led_dev.cls, MKDEV(led_dev.major, 0));
    class_destroy(led_dev.cls);
    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;
    }
    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;
}

long led_dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int ret,value;
    ret = copy_from_user(&value,(void *)arg,sizeof(int));
    if(ret){
        printk("copy_from_user failed\n");
        return -EINVAL;
    }
    switch (cmd)
    {
        case ON:
            switch(value){
                case LED1:
                    led_dev.gpioe->ODR |= (0x1 << 10);
                    break;
                case LED2:
                    led_dev.gpiof->ODR |= (0x1 << 10);
                    break;
                case LED3:
                    led_dev.gpioe->ODR |= (0x1 << 8);
                    break;
                case LED4:
                    led_dev.gpioz->ODR |= (0x1 << 5);
                    break;
                case LED5:
                    led_dev.gpioz->ODR |= (0x1 << 6);
                    break;
                case LED6:
                    led_dev.gpioz->ODR |= (0x1 << 7);
                    break;
                case BEEP:
                    printk("beep on\n");
                    led_dev.gpiob->ODR |= (0x1 << 6);
                    break;
                case MOTOR:
                    printk("motor on\n");
                    led_dev.gpiof->ODR |= (0x1 << 6);
                    break;
            }
            break;
        case OFF:
            switch(value){
                case LED1:
                    led_dev.gpioe->ODR &= (~(0x1 << 10));
                    break;
                case LED2:
                    led_dev.gpiof->ODR &= (~(0x1 << 10));
                    break;
                case LED3:
                    led_dev.gpioe->ODR &= (~(0x1 << 8));
                    break;
                case LED4:
                    led_dev.gpioz->ODR &= (~(0x1 << 5));
                    break;
                case LED5:
                    led_dev.gpioz->ODR &= (~(0x1 << 6));
                    break;
                case LED6:
                    led_dev.gpioz->ODR &= (~(0x1 << 7));
                    break;
                case BEEP:
                    printk("beep off\n");
                    led_dev.gpiob->ODR &= (~(0x1 << 6));
                    break;
                case MOTOR:
                    printk("motor off\n");
                    led_dev.gpiof->ODR &= (~(0x1 << 6));
                    break;
            }
            break;
    }
    return 0;
}

自定义头文件：head.h

#ifndef __HEAD_H__
#define __HEAD_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_AHB4ENSETR (0x50000A28)
#define RCC_MC_AHB5ENSETR (0x50000290)

#endif

测试文件：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)

enum{
    LED1,
    LED2,
    LED3,
    LED4,
    LED5,
    LED6,
    BEEP,
    MOTOR
};

#define ON _IOW('l', 1, int)
#define OFF _IOW('l',0,int)

typedef struct {
    char *cmd;
    unsigned long type;
    int devno;
} cmd_t;

cmd_t opt[16] = {
    [0]={"LED1ON",ON,LED1},
    [1]={"LED1OFF",OFF,LED1},
    [2]={"LED2ON",ON,LED2},
    [3]={"LED2OFF",OFF,LED2},
    [4]={"LED3ON",ON,LED3},
    [5]={"LED3OFF",OFF,LED3},
    [6]={"LED4ON",ON,LED4},
    [7]={"LED4OFF",OFF,LED4},
    [8]={"LED5ON",ON,LED5},
    [9]={"LED5OFF",OFF,LED5},
    [10]={"LED6ON",ON,LED6},
    [11]={"LED6OFF",OFF,LED6},
    [12]={"BEEPON",ON,BEEP},
    [13]={"BEEPOFF",OFF,BEEP},
    [14]={"MOTORON",ON,MOTOR},
    [15]={"MOTOROFF",OFF,MOTOR},
};

int find_command(const char *str,unsigned long *which,int *dev)
{
    int i;
    for (i = 0; i < 16; i++)
    {
        if(strcmp(opt[i].cmd,str)==0){
            *which = opt[i].type;
            *dev = opt[i].devno;
            return 0;
        }
    }
    return -1;
}

int main(int argc,const char * argv[])
{
    int ret;
    char buf[64] = {0};
    int devno=0;
    unsigned long which=0;
    int fd = open("/dev/mychrdev", O_RDWR);
    if(fd<0){
        PRINT_ERR("open error");
    }
    while(1){
        printf("Please input ( LEDxON / LEDxOFF )[x=1,2,...] >> ");
        memset(buf, 0, sizeof(buf));
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf) - 1] = '\0';
        ret=find_command(buf,&which, &devno);
        if(ret<0){
            continue;
        }
        ret=ioctl(fd, which, &devno);
        if(ret<0){
            PRINT_ERR("ioctl error");
            return -1;
        }
        which = devno = 0;
    }
    close(fd);
    return 0;
}

zhang_c_x
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值