2023-3-22作业

已于 2023-03-22 20:27:30 修改
阅读量121 收藏
点赞数
文章标签： linux arm开发 嵌入式硬件 驱动开发
于 2023-03-22 19:21:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63506558/article/details/129717273
版权

任务：

1.通过字符设备驱动分步操作进行6个灯的操作（ioctl）(CSDN)

2.拓展6灯，通过指定的设备文件控制指定的灯，不能控制其他灯

1.通过字符设备驱动分步操作进行6个灯的操作（ioctl）(CSDN) 

mycdev.h:

#ifndef __MYCDEV_H__
#define __MYCDEV_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 0x50000A28
#define PHY_RCC2 0x54000210
#define PHY_GPIOE 0x50006000
#define PHY_GPIOF 0x50007000
#define PHY_GPIOZ 0x54004000

#define LED_ON _IOW('a',1,int)
#define LED_OFF _IOW('a',0,int)

enum{
	LED1_1,
	LED1_2,
	LED1_3,
	LED2_1,
	LED2_2,
	LED2_3,
};

#endif

mycdev.c:

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/device.h>
#include "mycdev.h"
#include <linux/uaccess.h>
#include <linux/io.h>

#define CNAME "myled"  //驱动的名字


#if 1
unsigned int major = 0; // 动态申请主设备号
#else
unsigned int major = 500; // 静态申请主设备号
#endif

struct cdev *my_cdev;
dev_t dev_number;           // 设备号(主设备号/次设备号)
unsigned int baseminor = 0; // 次设备号起始值
unsigned int minor = 0;     // 次设备号
struct class *cls;
struct device *dev;

unsigned int* virt_rcc;
unsigned int* virt_rcc2;
gpio_t* virt_gpioe;
gpio_t* virt_gpiof;
gpio_t* virt_gpioz;

#define LED1_1_ON (virt_gpioe->ODR |= (0x1 << 10))
#define LED1_1_OFF (virt_gpioe->ODR &= (~(0x1 << 10)))
#define LED1_2_ON (virt_gpiof->ODR |= (0x1 << 10))
#define LED1_2_OFF (virt_gpiof->ODR &= (~(0x1 << 10)))
#define LED1_3_ON (virt_gpioe->ODR |= (0x1 << 8))
#define LED1_3_OFF (virt_gpioe->ODR &= (~(0x1 << 8)))

#define LED2_1_ON (virt_gpioz->ODR |= (0x1 << 5))
#define LED2_1_OFF (virt_gpioz->ODR &= (~(0x1 << 5)))
#define LED2_2_ON (virt_gpioz->ODR |= (0x1 << 6))
#define LED2_2_OFF (virt_gpioz->ODR &= (~(0x1 << 6)))
#define LED2_3_ON (virt_gpioz->ODR |= (0x1 << 7))
#define LED2_3_OFF (virt_gpioz->ODR &= (~(0x1 << 7)))

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

long myled_ioctl(struct file *file, unsigned int cmd, unsigned long args)
{
    //判断应用层传递过来的命令码 cmd
    //判断操作哪盏灯进行点亮 copy_from_user
    int whitch;
    int res;
    switch(cmd)
    {
    case LED_ON:
        res = copy_from_user(&whitch,(void*)args,sizeof(args));
        if(res)
        {
            printk("copy from user is error\n");
            return  -EIO;
        }
        switch(whitch)
        {
        case LED1_1:
            LED1_1_ON;
            break;
        case LED1_2:
            LED1_2_ON;
            break;
        case LED1_3:
            LED1_3_ON;
            break; 
        case LED2_1:
            LED2_1_ON;
            break;
        case LED2_2:
            LED2_2_ON;
            break;
        case LED2_3:
            LED2_3_ON;
            break;
        }
        break;

    case LED_OFF:
        res = copy_from_user(&whitch,(void*)args,sizeof(args));
        if(res)
        {
            printk("copy from user is error\n");
            return  -EIO;
        }
        switch(whitch)
        {
        case LED1_1:
            LED1_1_OFF;
            break;
        case LED1_2:
            LED1_2_OFF;
            break;
        case LED1_3:
            LED1_3_OFF;
            break; 
        case LED2_1:
            LED2_1_OFF;
            break;
        case LED2_2:
            LED2_2_OFF;
            break; 
        case LED2_3:
            LED2_3_OFF;
            break; 
        }
        break;
    }
    return 0;
}

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

const struct file_operations fops = {
    .open = myled_open,
    .unlocked_ioctl = myled_ioctl,
    .release = myled_close,
};

static int __init mycdev_init(void)
{
    int ret, i;

    // 1.分配字符设备驱动对象空间
    my_cdev = cdev_alloc();
    if (NULL == my_cdev)
    {
        printk("1.分配字符设备驱动对象空间失败\n");
        ret = -ENOMEM;
        goto ERR1;
    }
    printk("1.分配字符设备驱动对象空间成功\n");
    // 2.初始化驱动对象结构体
    cdev_init(my_cdev, &fops);

    // 3.动态申请设备号
    if (major == 0)  //动态
    {
        ret = alloc_chrdev_region(&dev_number, baseminor, 6, CNAME);
        if (ret)
        {
            printk("2.动态申请设备号失败\n");
            goto ERR2;
        }
        major = MAJOR(dev_number);
        minor = MINOR(dev_number);
        printk("2.动态申请设备号成功\n");
    }
    else if (major > 0)  //静态
    {
        ret = register_chrdev_region(MKDEV(major, minor), 6, CNAME);
        if (ret)
        {
            printk("2.静态申请设备号失败\n");
            goto ERR2;
        }
        printk("2.静态申请设备号成功\n");
    }

    // 4.注册字符设备驱动对象
    ret = cdev_add(my_cdev, MKDEV(major, minor), 6);
    if (ret)
    {
        printk("3.注册字符驱动设备对象失败\n");
        goto ERR3;
    }
    printk("3.注册字符驱动设备对象成功\n");

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

    // 6.向上提交字符设备信息
    for (i = 0; i < 6; i++)
    {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
        if (IS_ERR(dev))
        {
            printk("5.向上提交节点信息失败\n");
            ret = PTR_ERR(dev);
            goto ERR5;
        }
    }
    printk("5.向上提交设备节点成功\n");

    //将物理地址映射为虚拟地址
    //映射RCC地址
    virt_rcc = ioremap(PHY_RCC,4);
    if(NULL == virt_rcc)
    {
        printk("rcc ioremap error\n");
        return -ENOMEM;
    }
    virt_rcc2 = ioremap(PHY_RCC2,4);
    if(NULL == virt_rcc2)
    {
        printk("rcc2 ioremap error\n");
        return -ENOMEM;
    }
    //映射GPIOE地址
    virt_gpioe = ioremap(PHY_GPIOE,4);
    if(NULL == virt_gpioe)
    {
        printk("gpioe ioremap error\n");
        return -ENOMEM;
    }
    //映射GPIOF地址
    virt_gpiof = ioremap(PHY_GPIOF,4);
    if(virt_gpiof == NULL)
    {
        printk("gpiof ioremap is error\n");
        return -ENOMEM;
    }
    //映射GPIOZ地址
    virt_gpioz = ioremap(PHY_GPIOZ,4);
    if(virt_gpioz == NULL)
    {
        printk("gpioz ioremap is error\n");
        return -ENOMEM;
    }

    //RCC初始化
    *virt_rcc |= (0x1 << 4);
    *virt_rcc |= (0x1 << 5);
    *virt_rcc2 |= (0x1 << 0);

    //对LED1_1初始化，设置引脚功能
    virt_gpioe->MODER &= (~(0x3 << 20));
    virt_gpioe->MODER |= (0x1 << 20);
    virt_gpioe->ODR &= (~(0x1 << 10));
    //对LED1_2初始化，设置引脚功能
    virt_gpiof->MODER &= (~(0x3<<20));
    virt_gpiof->MODER |= (0x1<<20);
    virt_gpiof->ODR &= (~(0x1<<10));
    //对LED1_3初始化，设置引脚功能
    virt_gpioe->MODER &= (~(0x3<<16));
    virt_gpioe->MODER |= (0x1<<16);
    virt_gpioe->ODR &= (~(0x1<<8));

    //对LED2_1初始化，设置引脚功能
    virt_gpioz->MODER &= (~(0x3 << 10));
    virt_gpioz->MODER |= (0x1 << 10);
    virt_gpioz->ODR &= (~(0x1 << 5));
    //对LED2_2初始化，设置引脚功能
    virt_gpioz->MODER &= (~(0x3 << 12));
    virt_gpioz->MODER |= (0x1 << 12);
    virt_gpioz->ODR &= (~(0x1 << 6));
    //对LED2_3初始化，设置引脚功能
    virt_gpioz->MODER &= (~(0x3 << 14));
    virt_gpioz->MODER |= (0x1 << 14);
    virt_gpioz->ODR &= (~(0x1 << 7));

    return 0;
ERR5:
    // 将前面提交成功的设备信息销毁
    for (--i; i >= 0; i--)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    // 销毁目录
    class_destroy(cls);

ERR4:
    cdev_del(my_cdev);
ERR3:
    unregister_chrdev_region(MKDEV(major, minor), 6);
ERR2:
    kfree(my_cdev);
ERR1:
    return ret;
}

static void __exit mycdev_exit(void)
{
    int i;

    //取消映射
    iounmap(virt_rcc);
    iounmap(virt_rcc2);
    iounmap(virt_gpioe);
    iounmap(virt_gpiof);
    iounmap(virt_gpioz);

    // 1.注销向上提交的字符设备信息
    for (i = 0; i < 6; i++)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    printk("1.注销向上提交的字符设备信息成功\n");

    // 2.注销向上提交的目录信息
    class_destroy(cls);
    printk("2.注销向上提交的目录信息成功\n");

    // 3.注销字符设备驱动对象
    cdev_del(my_cdev);
    printk("3.注销字符设备驱动对象成功\n");

    // 4.释放申请到的设备号
    unregister_chrdev_region(MKDEV(major, minor), 3);
    printk("4.释放申请到的设备号成功\n");

    // 5.释放申请到的字符设备驱动对象空间
    kfree(my_cdev);
    printk("5.释放申请到的字符设备驱动对象空间成功\n");
}

module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

text.c:

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

int main(int argc,const char * argv[])
{
    char buf[128] = {0};
    int fd = -1;
    int whitch;
    fd = open("/dev/myled0", O_RDWR);
    if(-1 == fd)
    {
        perror("open is error\n");
        return -1;
    }

    while(1)
    {
        whitch = LED1_1;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);

        whitch = LED1_2;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);

        whitch = LED1_3;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);

        whitch = LED2_1;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);

        whitch = LED2_2;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);

        whitch = LED2_3;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);
    }
    
    close(fd);

    return 0;
}

2.拓展6灯，通过指定的设备文件控制指定的灯，不能控制其他灯

mycdev.h:

#ifndef __MYCDEV_H__
#define __MYCDEV_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 0x50000A28
#define PHY_RCC2 0x54000210
#define PHY_GPIOE 0x50006000
#define PHY_GPIOF 0x50007000
#define PHY_GPIOZ 0x54004000

#define LED_ON _IOW('a',1,int)
#define LED_OFF _IOW('a',0,int)

#endif

mycdev.c:

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/device.h>
#include "mycdev.h"
#include <linux/uaccess.h>
#include <linux/io.h>

#define CNAME "myled"  //驱动的名字
#define COUNT 6        //设备的数量

#if 1
unsigned int major = 0; // 动态申请主设备号
#else
unsigned int major = 500; // 静态申请主设备号
#endif

struct cdev *my_cdev;
dev_t dev_number;           // 设备号(主设备号/次设备号)
unsigned int baseminor = 0; // 次设备号起始值
unsigned int minor = 0;     // 次设备号
struct class *cls;
struct device *dev;
int flag = -1;

unsigned int* virt_rcc;
unsigned int* virt_rcc2;
gpio_t* virt_gpioe;
gpio_t* virt_gpiof;
gpio_t* virt_gpioz;

#define LED1_1_ON (virt_gpioe->ODR |= (0x1 << 10))
#define LED1_1_OFF (virt_gpioe->ODR &= (~(0x1 << 10)))
#define LED1_2_ON (virt_gpiof->ODR |= (0x1 << 10))
#define LED1_2_OFF (virt_gpiof->ODR &= (~(0x1 << 10)))
#define LED1_3_ON (virt_gpioe->ODR |= (0x1 << 8))
#define LED1_3_OFF (virt_gpioe->ODR &= (~(0x1 << 8)))

#define LED2_1_ON (virt_gpioz->ODR |= (0x1 << 5))
#define LED2_1_OFF (virt_gpioz->ODR &= (~(0x1 << 5)))
#define LED2_2_ON (virt_gpioz->ODR |= (0x1 << 6))
#define LED2_2_OFF (virt_gpioz->ODR &= (~(0x1 << 6)))
#define LED2_3_ON (virt_gpioz->ODR |= (0x1 << 7))
#define LED2_3_OFF (virt_gpioz->ODR &= (~(0x1 << 7)))

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

long myled_ioctl(struct file *file, unsigned int cmd, unsigned long args)
{
    //判断应用层传递过来的命令码 cmd
    //判断操作哪盏灯进行点亮 copy_from_user
    
    switch (MINOR(file->f_inode->i_rdev))   //判断次设备号
    {
    case 0:                 //规定次设备号为0的设备文件只能控制LED1_1
        if(cmd == LED_ON)
            LED1_1_ON;
        else if(cmd == LED_OFF)
            LED1_1_OFF;
        break;
    case 1:                 //规定次设备号为1的设备文件只能控制LED1_2
        if(cmd == LED_ON)
            LED1_2_ON;
        else if(cmd == LED_OFF)
            LED1_2_OFF;
        break;
    case 2:                 //规定次设备号为2的设备文件只能控制LED1_3  
        if(cmd == LED_ON)
            LED1_3_ON;
        else if(cmd == LED_OFF)
            LED1_3_OFF;
        break;
    case 3:                 //规定次设备号为3的设备文件只能控制LED2_1
        if(cmd == LED_ON)
            LED2_1_ON;
        else if(cmd == LED_OFF)
            LED2_1_OFF;
        break;
    case 4:                 //规定次设备号为4的设备文件只能控制LED2_2
        if(cmd == LED_ON)
            LED2_2_ON;
        else if(cmd == LED_OFF)
            LED2_2_OFF;
        break;
    case 5:                 //规定次设备号为5的设备文件只能控制LED2_3
        if(cmd == LED_ON)
            LED2_3_ON;
        else if(cmd == LED_OFF)
            LED2_3_OFF;
        break;
    }
    return 0;
}

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

const struct file_operations fops = {
    .open = myled_open,
    .unlocked_ioctl = myled_ioctl,
    .release = myled_close,
};

static int __init mycdev_init(void)
{
    int ret, i;

    // 1.分配字符设备驱动对象空间
    my_cdev = cdev_alloc();
    if (NULL == my_cdev)
    {
        printk("1.分配字符设备驱动对象空间失败\n");
        ret = -ENOMEM;
        goto ERR1;
    }
    printk("1.分配字符设备驱动对象空间成功\n");
    // 2.初始化驱动对象结构体
    cdev_init(my_cdev, &fops);

    // 3.动态申请设备号
    if (major == 0)  //动态
    {
        ret = alloc_chrdev_region(&dev_number, baseminor, COUNT, CNAME);
        if (ret)
        {
            printk("2.动态申请设备号失败\n");
            goto ERR2;
        }
        major = MAJOR(dev_number);
        minor = MINOR(dev_number);
        printk("2.动态申请设备号成功\n");
    }
    else if (major > 0)  //静态
    {
        ret = register_chrdev_region(MKDEV(major, minor), COUNT, CNAME);
        if (ret)
        {
            printk("2.静态申请设备号失败\n");
            goto ERR2;
        }
        printk("2.静态申请设备号成功\n");
    }

    // 4.注册字符设备驱动对象
    ret = cdev_add(my_cdev, MKDEV(major, minor), COUNT);
    if (ret)
    {
        printk("3.注册字符驱动设备对象失败\n");
        goto ERR3;
    }
    printk("3.注册字符驱动设备对象成功\n");

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

    // 6.向上提交字符设备信息
    for (i = 0; i < COUNT; i++)
    {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
        if (IS_ERR(dev))
        {
            printk("5.向上提交节点信息失败\n");
            ret = PTR_ERR(dev);
            goto ERR5;
        }
    }
    printk("5.向上提交设备节点成功\n");

    //将物理地址映射为虚拟地址
    //映射RCC地址
    virt_rcc = ioremap(PHY_RCC,4);
    if(NULL == virt_rcc)
    {
        printk("rcc ioremap error\n");
        return -ENOMEM;
    }
    virt_rcc2 = ioremap(PHY_RCC2,4);
    if(NULL == virt_rcc2)
    {
        printk("rcc2 ioremap error\n");
        return -ENOMEM;
    }
    //映射GPIOE地址
    virt_gpioe = ioremap(PHY_GPIOE,4);
    if(NULL == virt_gpioe)
    {
        printk("gpioe ioremap error\n");
        return -ENOMEM;
    }
    //映射GPIOF地址
    virt_gpiof = ioremap(PHY_GPIOF,4);
    if(virt_gpiof == NULL)
    {
        printk("gpiof ioremap is error\n");
        return -ENOMEM;
    }
    //映射GPIOZ地址
    virt_gpioz = ioremap(PHY_GPIOZ,4);
    if(virt_gpioz == NULL)
    {
        printk("gpioz ioremap is error\n");
        return -ENOMEM;
    }

    //RCC初始化
    *virt_rcc |= (0x1 << 4);
    *virt_rcc |= (0x1 << 5);
    *virt_rcc2 |= (0x1 << 0);

    //对LED1_1初始化，设置引脚功能
    virt_gpioe->MODER &= (~(0x3 << 20));
    virt_gpioe->MODER |= (0x1 << 20);
    virt_gpioe->ODR &= (~(0x1 << 10));
    //对LED1_2初始化，设置引脚功能
    virt_gpiof->MODER &= (~(0x3<<20));
    virt_gpiof->MODER |= (0x1<<20);
    virt_gpiof->ODR &= (~(0x1<<10));
    //对LED1_3初始化，设置引脚功能
    virt_gpioe->MODER &= (~(0x3<<16));
    virt_gpioe->MODER |= (0x1<<16);
    virt_gpioe->ODR &= (~(0x1<<8));

    //对LED2_1初始化，设置引脚功能
    virt_gpioz->MODER &= (~(0x3 << 10));
    virt_gpioz->MODER |= (0x1 << 10);
    virt_gpioz->ODR &= (~(0x1 << 5));
    //对LED2_2初始化，设置引脚功能
    virt_gpioz->MODER &= (~(0x3 << 12));
    virt_gpioz->MODER |= (0x1 << 12);
    virt_gpioz->ODR &= (~(0x1 << 6));
    //对LED2_3初始化，设置引脚功能
    virt_gpioz->MODER &= (~(0x3 << 14));
    virt_gpioz->MODER |= (0x1 << 14);
    virt_gpioz->ODR &= (~(0x1 << 7));

    return 0;
ERR5:
    // 将前面提交成功的设备信息销毁
    for (--i; i >= 0; i--)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    // 销毁目录
    class_destroy(cls);

ERR4:
    cdev_del(my_cdev);
ERR3:
    unregister_chrdev_region(MKDEV(major, minor), COUNT);
ERR2:
    kfree(my_cdev);
ERR1:
    return ret;
}

static void __exit mycdev_exit(void)
{
    int i;

    //取消映射
    iounmap(virt_rcc);
    iounmap(virt_rcc2);
    iounmap(virt_gpioe);
    iounmap(virt_gpiof);
    iounmap(virt_gpioz);

    // 1.注销向上提交的字符设备信息
    for (i = 0; i < COUNT; i++)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    printk("1.注销向上提交的字符设备信息成功\n");

    // 2.注销向上提交的目录信息
    class_destroy(cls);
    printk("2.注销向上提交的目录信息成功\n");

    // 3.注销字符设备驱动对象
    cdev_del(my_cdev);
    printk("3.注销字符设备驱动对象成功\n");

    // 4.释放申请到的设备号
    unregister_chrdev_region(MKDEV(major, minor), COUNT);
    printk("4.释放申请到的设备号成功\n");

    // 5.释放申请到的字符设备驱动对象空间
    kfree(my_cdev);
    printk("5.释放申请到的字符设备驱动对象空间成功\n");
}

module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

text.c:

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

int main(int argc, const char *argv[])
{
    char buf[128] = {0};
    int fd[6] = {0};
    char *dir[6] = {"/dev/myled0","/dev/myled1","/dev/myled2","/dev/myled3","/dev/myled4","/dev/myled5"};
    for (int i = 0; i < 6; i++)
    {
        fd[i] = open(dir[i], O_RDWR);
        if (-1 == fd[i])
        {
            perror("open is error\n");
            return -1;
        }
    }

    while (1)
    {
        for (int i = 0; i < 6; i++)
        {
            ioctl(fd[i], LED_ON);
            sleep(1);
            ioctl(fd[i], LED_OFF);
            sleep(1);
        }
    }

    for (int i = 0; i < 6; i++)
        close(fd[i]);

    return 0;
}

无限复读叽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
操作系统习题 2023-6-22 143525 12_-1755972427(1).zip
06-23
3. **文件系统**：文件系统是操作系统用于组织和管理磁盘上数据的一种方式。它定义了文件的命名规则、存储结构、访问权限和存取方法。常见的文件系统有FAT、NTFS、EXT系列等。 4. **I/O管理**：输入/输出管理负责...
2023-04-06-项目笔记 - 第八十阶段 - 4.4.2.78全局变量的作用域-78 -2024.03.22
03-22
作业中提交代码 小分享3.写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.78全局变量的作用域_78 - 2024-03-22
2023-04-06-项目笔记 - 第五十一阶段 - 4.4.2.49全局变量的作用域-49 -2024.02.22
03-01
作业中提交代码 小分享3.写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.49全局变量的作用域_49 - 2024-02-22
Linux shell编程学习笔记68： curl 命令行网络数据传输工具 选项数量雷人（上）
Purpleendurer@CSDN
08-04 1089
在网络时代，有经常需要在网络上传输数据，时我们需要通过网络下载文件，为了满足这种时代需要，Linux提供了众多网络命令，我们今天先研究curl命令。例如，我们可以使用curl从 URL 下载文件，或将文件上传到服务器。
在Linux中宏观的看待线程
2301_77479435的博客
08-07 375
在Linux中宏观的看待线程
linux 上源码编译安装 PolarDB-X
寂夜了无痕的博客
08-03 1018
linux上源码编译安装 PolarDB-X
Linux5：Shell编程——函数、重定向
纸上得来终觉浅
08-05 1481
Shell编程——函数、重定向
【Linux 从基础到进阶】进程管理与性能调优
weixin_39372311的博客
08-08 342
通过本文的介绍，您已经了解了 Linux 系统中进程管理和性能调优的基本概念和操作方法。本文提供了适用于 CentOS 和 Ubuntu 系统的具体命令和示例，涵盖了 CPU、内存、I/O 和网络的性能调优策略。合理的进程管理和性能调优可以显著提升系统的稳定性和运行效率。如有任何问题或需要进一步的帮助，请参考CentOS 官方文档和Ubuntu 官方文档或在 CSDN 博客中查阅相关内容。
Linux Java服务管理脚本（启动、停止、查看状态）
程序员阿华的博客
08-08 103
Linux Java服务管理脚本（启动、停止、查看状态）
Linux 调试之动态打印
最新发布
Teminator_的博客
08-08 1581
在 kernel 驱动代码中，使用动态输出是系统内核调试的重要手段之一，printk打印是全局的，只能设置输出等级，而且使用printk每次都要重新编译内核，很不方便。。而动态输出可以在不需要重新编译内核的情况下，方便的打印出内核的 debug 信息。动态输出可以动态选择打开某个内核子系统的输出，可以有选择性地打开某些模块的输出，printk被dev_infodev_dbgdev_err之类的函数代替，dev_xxx函数的本质还是使用printk打印的，只是对printk进行了一层包装。
linux下常用java、nginx部署命令
hazhanglvfang的专栏
08-05 478
6.nohup java -jar -Dserver.port=8087 XXXX-web.jar spring.config.location=/home/XXXXXX/application.yml > uni.log & 指定外部文件部署且指定固定端口。24.修改nginx文件后 ，nginx -s reload 成功后没生效,这种情况下需要把nginx手动杀掉后 在启动。找到目前的文件，清空文件 ，有可能删除不管用rm-rf 文件名 ，需要清空文件 echo >文件名。
Linux查看系统线程数
csdn565973850的博客
08-07 611
Linux查看系统线程数
Linux 进程优先级、程序地址空间、进程控制
敲代码嘞~的博客
08-04 1005
进程获取某种资源（cpu）的先后顺序。task_struct 进程控制块 -> int prio；Linux中优先级数字越小，优先级越高。优先级是能执行，表示执行的顺序；而权限是能不能执行的问题。
正点原子imx6ull-mini-Linux驱动之Linux SPI 驱动实验（22）
NEWEVA__zzera22的博客
08-05 643
SPI 驱动框架和 I2C 很类似，都分为主机控制器驱动和设备驱动，主机控制器也就是 SOC 的 SPI 控制器接口。比如在裸机篇中的《第二十七章 SPI 实验》，我们编写了 bsp_spi.c 和 bsp_spi.h 这两个文件，这两个文件是 I.MX6U 的 SPI 控制器驱动，我们编写好 SPI 控制器驱动以后就可 以直接使用了，不管是什么 SPI 设备，SPI 控制器部分的驱动都是一样，我们的重点就落在了 种类繁多的 SPI 设备驱动。
Linux 下 perf 的使用
Teminator_的博客
08-05 4261
perf 是一个性能分析工具（基于 Linux 内核提供的性能事件perf_event口），用于对 Linux 系统进行性能调优和性能分析。它可以通过收集硬件性能计数器、跟踪系统事件和采样程序调用栈等方式来提供详细的性能统计信息。perf 依赖事件进行统计，这里的事件是通过采样机制，并不是 clock 级别的统计；根据使用 perf 工具的不同按测量事件的类型进行统计。
Linux中的无人值守安装脚本Kickstart
weixin_72104132的博客
08-05 975
所谓的init进程，它是一个由内核启动的用户级进程。内核自行启动（已经被载入内存，开始运行，并已初始化所有的设备驱动程序和数据结构等）之后，就通过启动一个用户级程序init的方式，完成引导进程。所以,init始终是第一个进程（其进程编号始终为1）。内核会在过去曾使用过init的几个地方查找它，它的正确位置（对Linux系统来说是/sbin/init。如果内核找不到init，它就会试着运行/bin/sh，如果运行失败，系统的启动也会失败。
【Gold菜鸟】Linux知识回忆（8）——进程和计划任务
geekgold的博客
08-03 914
​ 这部分让我们来继续了解Linux中进程和计划任务的相关知识吧~ ​
Linux学习第57天：Linux PWM驱动实验
08-05 786
Linux---PWM驱动开发
Linux 的 Port Knocking 端口碰撞（端口敲门）
Reset
08-05 408
端口碰撞是一种通过在一组预先指定的关闭端口上产生连接请求，从外部打开防火墙上的端口的方法。一旦收到正确的连接请求序列，防火墙规则就会被动态修改，以允许发送连接请求的主机通过特定端口进行连接。在Linux中称为 Knockd服务，该服务通过动态的添加iptables规则来隐藏系统开启的端口，使用自定义的一系列序列号来“敲门”，使系统开启需要访问的服务端口，才能对外访问。不使用时，再使用自定义的序列号来“关门”，将端口关闭，不对外监听。进一步提升了服务和系统的安全性。
Control-M作业配置详解：从入门到实战
3. **作业定义**： - 作业是Control-M的核心组件，代表一组相关的任务或流程。作业定义包括SMARTTable、SubTable和Job的创建。SMARTTable存储元数据，SubTable用于细化任务逻辑，Job则是实际执行单元。 4. **定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值