10月11日 驱动开发

最新推荐文章于 2023-09-11 22:50:37 发布
最新推荐文章于 2023-09-11 22:50:37 发布
阅读量64 收藏
点赞数
文章标签： 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56095954/article/details/127270534
版权

2.通过ioctl函数实现灯\蜂鸣器和风扇的工作选择

#ifndef __MYLED_H__
#define __MYLED_H__

typedef struct
{
    volatile unsigned int MODER;
    volatile unsigned int OTYPER;
    volatile unsigned int OSPEEDR;
    volatile unsigned int PUPDR;
    volatile unsigned int IDR;
    volatile unsigned int ODR;
    volatile unsigned int BSRR;
    volatile unsigned int LCKR;
    volatile unsigned int AFRL;
} gpio_t;
#define PHY_LED1_ADDR 0X50006000
#define PHY_LED2_ADDR 0X50007000
#define PHY_LED3_ADDR 0X50006000
#define PHY_RCC_ADDR 0X50000A28

//蜂鸣器 PB6
#define gpio_b 0X50003000
#define fengmingqi_rcc 0X50000A28

//马达 PF6
#define gpio_f 0X50007000
#define mada_rcc 0X50000A28

//风扇 PE9
#define gpio_e 0X50006000
#define fengshan_rcc 0X50000A28
enum LED
{
    LED1 = 1,
    LED2,
    LED3
};

#define LED_ON _IO('a', 1)
#define LED_OFF _IO('a', 0)
#define LedON _IOW('a', 1, int)
#define LedOFF _IOW('a', 0, int)
#define fengmingqiON _IOW('a', 1, int)
#define fengmingqiOFF _IOW('a', 0, int)
#define madaON _IOW('a', 1, int)
#define madaOFF _IOW('a', 0,int)
#define fengshanON _IOW('a', 1,int)
#define fengshanOFF _IOW('a', 0,int)

#endif

myled.c 

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/ioctl.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include"ctr.h"
#define CNAME  "myled"

int major;//定义变量接收主设备号
char kbuf[128]={};//定义数组用于存放和用户之间拷贝的数据
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
unsigned int *vir_rcc;
struct class *cls;//句柄
struct device *dev;
//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
      printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
      return 0;
}
//read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    //size参数是用户期待读到的字节长度
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_to_user(ubuf,kbuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
     
       return size;
}
//write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_from_user(kbuf,ubuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }

       return size;
}
//close()
 long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
    int ret,which;
    switch(cmd)
    {
        case LedON:
            ret=copy_from_user(&which,(void *)arg,sizeof(int));
            if(ret)
            {
                printk("用户向内核拷贝数据失败\n");
                return -EIO;
            }
            switch(which)
            {
                case LED1:
                 vir_led1->ODR |= (1<<10);
                 break;
                case LED2:
                 vir_led2->ODR |= (1<<10);
                 break;
                case LED3:
                 vir_led3->ODR |= (1<<8);
                 break;
            }
            break;
        case LedOFF:
            ret=copy_from_user(&which,(void *)arg,sizeof(int));
            if(ret)
            {
                printk("用户向内核拷贝数据失败\n");
                return -EIO;
            }
            switch(which)
            {
                case LED1:
                 vir_led1->ODR &= ~(1<<10);
                 break;
                case LED2:
                vir_led2->ODR &= ~(1<<10);
                 break;
                case LED3:
                 vir_led3->ODR &= ~(1<<8);
                 break;
            }
            break;
        default:
            printk("功能码错误\n");
            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,
    .unlocked_ioctl=ioctl,
    .release=mycdev_close,
};
int all_led_init(void)
{
    //进行物理地址的映射
    vir_led1=ioremap(PHY_LED1_ADDR,sizeof(gpio_t));
    if(vir_led1==NULL)
    {
        printk("vir_led1 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led1 映射成功\n");
   vir_led2=ioremap(PHY_LED2_ADDR,sizeof(gpio_t));
    if(vir_led2==NULL)
    {
        printk("vir_led2 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led2 映射成功\n");
    vir_led3=ioremap(PHY_LED3_ADDR,sizeof(gpio_t));
    if(vir_led3==NULL)
    {
        printk("vir_led3 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led3 映射成功\n");
    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");
    //寄存器的初始化
    //led1
    vir_led1->MODER &= ~(3<<20);
    vir_led1->MODER |= (1<<20);
    vir_led1->ODR &= ~(1<<10);

    //led2
    vir_led2->MODER &= ~(3<<20);
    vir_led2->MODER |= (1<<20);
    vir_led2->ODR &= ~(1<<10);

    //led3
   vir_led3->MODER &= ~(3<<16);
    vir_led3->MODER |= (1<<16);
    vir_led3->ODR &= ~(1<<8);

    (*vir_rcc) |= (3<<4);
    return 0;
}
//入口函数，当驱动安装的时候执行
static int __init demo_init(void)
{
    
    //动态注册字符设备驱动
    major=register_chrdev(0,CNAME,&fops);
    if(major<0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n",major);
    //向上提交节点目录
    cls=class_create(THIS_MODULE,"LED");
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return PTR_ERR(cls);
    }
     printk("向上提交目录成功\n");
     //创建设备节点
     dev=device_create(cls,NULL,MKDEV(major,0),NULL,"myled");
     if(IS_ERR(dev))
     {
        printk("创建节点失败\n");
        return PTR_ERR(dev);
     }
     printk("创建节点成功\n");
    //寄存器的初始化
    all_led_init();
   
    return 0;
}

//出口函数，卸载驱动的时候执行
static void __exit demo_exit(void)
{
    //销毁节点
    device_destroy(cls,MKDEV(major,0));
    //销毁目录
    class_destroy(cls);
    //取消映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_led3);
    iounmap(vir_rcc);

    //注销字符设备驱动
    unregister_chrdev(major,CNAME);
   
}
module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

 

myfengmingqi.c 

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/ioctl.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include"ctr.h"
#define CNAME  "myfengmingqi"
int major;//定义变量接收主设备号
char kbuf[128]={};//定义数组用于存放和用户之间拷贝的数据
gpio_t *vir_fengmingqi;
unsigned int *vir_rcc;
struct class *cls;//句柄
struct device *dev;
//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
      printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
      return 0;
}
//read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    //size参数是用户期待读到的字节长度
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_to_user(ubuf,kbuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
     
       return size;
}
//write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_from_user(kbuf,ubuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }

       return size;
}
//close()
 long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
    switch(cmd)
    {
        case fengmingqiON:
            vir_fengmingqi->ODR |= (1<<6);  
            break;
        case fengmingqiOFF:
            vir_fengmingqi->ODR &= ~(1<<6);  
            break;
        default:
            printk("功能码错误\n");
            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,
    .unlocked_ioctl=ioctl,
    .release=mycdev_close,
};
int all_led_init(void)
{
    //进行物理地址的映射
    vir_fengmingqi=ioremap(gpio_b,sizeof(gpio_t));
    if(vir_fengmingqi==NULL)
    {
        printk("vir_fengmingqi 映射失败\n");
        return -1;
    }
    printk("vir_fengmingqi 映射成功\n");
    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");
    //寄存器的初始化
    //fengmingqi
    vir_fengmingqi->MODER &= ~(3<<12);
    vir_fengmingqi->MODER |= (1<<12);
    vir_fengmingqi->ODR &= ~(1<<6);
    (*vir_rcc) |= (1<<1);
    return 0;
}
//入口函数，当驱动安装的时候执行
static int __init demo_init(void)
{
    
    //动态注册字符设备驱动
    major=register_chrdev(0,CNAME,&fops);
    if(major<0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n",major);
    //向上提交节点目录
    cls=class_create(THIS_MODULE,"FMQ");
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return PTR_ERR(cls);
    }
     printk("向上提交目录成功\n");
     //创建设备节点
     dev=device_create(cls,NULL,MKDEV(major,0),NULL,"myfengmingqi");
     if(IS_ERR(dev))
     {
        printk("创建节点失败\n");
        return PTR_ERR(dev);
     }
     printk("创建节点成功\n");
    //寄存器的初始化
    all_led_init();
   
    return 0;
}

//出口函数，卸载驱动的时候执行
static void __exit demo_exit(void)
{
    //销毁节点
    device_destroy(cls,MKDEV(major,0));
    //销毁目录
    class_destroy(cls);
    //取消映射
    iounmap(vir_fengmingqi);
    iounmap(vir_rcc);

    //注销字符设备驱动
    unregister_chrdev(major,CNAME);
   
}
module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

mymada.c 

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/ioctl.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include"ctr.h"
#define CNAME  "mada"
int major;//定义变量接收主设备号
char kbuf[128]={};//定义数组用于存放和用户之间拷贝的数据
gpio_t *vir_mada;
unsigned int *vir_rcc;
struct class *cls;//句柄
struct device *dev;
//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
      printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
      return 0;
}
//read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    //size参数是用户期待读到的字节长度
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_to_user(ubuf,kbuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
     
       return size;
}
//write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_from_user(kbuf,ubuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }

       return size;
}
//close()
 long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
    switch(cmd)
    {
        case madaON:
            vir_mada->ODR |= (1<<6);  
            break;
        case madaOFF:
            vir_mada->ODR &= ~(1<<6);  
            break;
        default:
            printk("功能码错误\n");
            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,
    .unlocked_ioctl=ioctl,
    .release=mycdev_close,
};
int all_led_init(void)
{
    //进行物理地址的映射
    vir_mada=ioremap(gpio_f,sizeof(gpio_t));
    if(vir_mada==NULL)
    {
        printk("vir_mada 映射失败\n");
        return -1;
    }
    printk("vir_mada 映射成功\n");
    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");
    //寄存器的初始化
    //fengmingqi
    vir_mada->MODER &= ~(3<<12);
    vir_mada->MODER |= (1<<12);
    vir_mada->ODR &= ~(1<<6);
    (*vir_rcc) |= (1<<5);
    return 0;
}
//入口函数，当驱动安装的时候执行
static int __init demo_init(void)
{
    
    //动态注册字符设备驱动
    major=register_chrdev(0,CNAME,&fops);
    if(major<0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n",major);
    //向上提交节点目录
    cls=class_create(THIS_MODULE,"MADA");
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return PTR_ERR(cls);
    }
     printk("向上提交目录成功\n");
     //创建设备节点
     dev=device_create(cls,NULL,MKDEV(major,0),NULL,"mymada");
     if(IS_ERR(dev))
     {
        printk("创建节点失败\n");
        return PTR_ERR(dev);
     }
     printk("创建节点成功\n");
    //寄存器的初始化
    all_led_init();
   
    return 0;
}

//出口函数，卸载驱动的时候执行
static void __exit demo_exit(void)
{
    //销毁节点
    device_destroy(cls,MKDEV(major,0));
    //销毁目录
    class_destroy(cls);
    //取消映射
    iounmap(vir_mada);
    iounmap(vir_rcc);

    //注销字符设备驱动
    unregister_chrdev(major,CNAME);
   
}
module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

myfengshan.c 

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/ioctl.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include"ctr.h"
#define CNAME  "myfengshan"
int major;//定义变量接收主设备号
char kbuf[128]={};//定义数组用于存放和用户之间拷贝的数据
gpio_t *vir_fengshan;
unsigned int *vir_rcc;
struct class *cls;//句柄
struct device *dev;
//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
      printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
      return 0;
}
//read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    //size参数是用户期待读到的字节长度
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_to_user(ubuf,kbuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
     
       return size;
}
//write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_from_user(kbuf,ubuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }

       return size;
}
//close()
 long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
    switch(cmd)
    {
        case fengshanON:
            vir_fengshan->ODR |= (1<<9);  
            break;
        case fengshanOFF:
            vir_fengshan->ODR &= ~(1<<9);  
            break;
        default:
            printk("功能码错误\n");
            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,
    .unlocked_ioctl=ioctl,
    .release=mycdev_close,
};
int all_led_init(void)
{
    //进行物理地址的映射
    vir_fengshan=ioremap(gpio_e,sizeof(gpio_t));
    if(vir_fengshan==NULL)
    {
        printk("vir_fengshan 映射失败\n");
        return -1;
    }
    printk("vir_fengshan 映射成功\n");
    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");
    //寄存器的初始化
    //fengmingqi
    vir_fengshan->MODER &= ~(3<<18);
    vir_fengshan->MODER |= (1<<18);
    vir_fengshan->ODR &= ~(1<<9);
    (*vir_rcc) |= (3<<4);
    return 0;
}
//入口函数，当驱动安装的时候执行
static int __init demo_init(void)
{
    
    //动态注册字符设备驱动
    major=register_chrdev(0,CNAME,&fops);
    if(major<0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n",major);
    //向上提交节点目录
    cls=class_create(THIS_MODULE,"FS");
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return PTR_ERR(cls);
    }
     printk("向上提交目录成功\n");
     //创建设备节点
     dev=device_create(cls,NULL,MKDEV(major,0),NULL,"myfengshan");
     if(IS_ERR(dev))
     {
        printk("创建节点失败\n");
        return PTR_ERR(dev);
     }
     printk("创建节点成功\n");
    //寄存器的初始化
    all_led_init();
   
    return 0;
}

//出口函数，卸载驱动的时候执行
static void __exit demo_exit(void)
{
    //销毁节点
    device_destroy(cls,MKDEV(major,0));
    //销毁目录
    class_destroy(cls);
    //取消映射
    iounmap(vir_fengshan);
    iounmap(vir_rcc);

    //注销字符设备驱动
    unregister_chrdev(major,CNAME);
   
}
module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

 

yonghu.c 

 

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include <sys/ioctl.h>
#include"ctr.h"
int main(int argc, char const *argv[])
{
    char buf[128]={};
    int fd1=open("/dev/myled",O_RDWR);
    int fd2=open("/dev/myfengmingqi",O_RDWR);
    int fd3=open("/dev/mymada",O_RDWR);
    int fd4=open("/dev/myfengshan",O_RDWR);
    int which;
    int a=1,b=2,c=3;
    if(fd1<0 | fd2<0 | fd3<0 | fd4<0)
    {

        printf("打开设备文件失败\n");
        exit(-1);
    }
    printf("设备文件打开成功\n");
    //在终端输入
    while(1)
    {
       printf("请输入控制命令1:开灯 2:打开蜂鸣器 3:打开马达 4:打开风扇 0:关灯/蜂鸣器/马达/风扇\n");
        fgets(buf,sizeof(buf),stdin);
        if(buf[0] == '1')
        {
            printf("请输入要操作的灯:1-》LED1  2->LED2 3->LED3\n");
            scanf("%d",&which);
            getchar();
        }
    //吃掉换行符
    buf[strlen(buf)-1]='\0';
    if(buf[0]=='1')
        ioctl(fd1,LedON,&which);
    else if(buf[0]=='2')
        ioctl(fd2,fengmingqiON);
    else if(buf[0]=='3')
        ioctl(fd3,madaON);
    else if(buf[0]=='4')
        ioctl(fd4,fengshanON);
    else
    {
        ioctl(fd1,LedOFF,&a);
        ioctl(fd1,LedOFF,&b);
        ioctl(fd1,LedOFF,&c);
        ioctl(fd2,fengmingqiOFF);
        ioctl(fd3,madaOFF);
        ioctl(fd4,fengshanOFF);
    }
    }
     close(fd1);
     close(fd2);
     close(fd3);
     close(fd4);
    return 0;
}

 

 

来日定方长
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux内核学习7：中断与中断处理(1)
不会写代码的程序猿专栏
09-23 666
为什么要引入中断这个概念
ch341驱动131211 USB驱动 for 17UC.rar
08-22
标题中的"ch341驱动131211 USB驱动 for 17UC.rar"指的是一款适用于17UC型号设备的CH341 USB转串口驱动程序的压缩包，发布日期为2013年12月11日。这个驱动主要用于解决在Windows 10操作系统上STM32微控制器通过USB...
树莓派——linux内核与驱动
NRWHF的博客
11-15 1408
树莓派——linux内核与驱动
Linux中内核与驱动程序
weixin_41544435的博客
07-06 3888
Linux设备驱动知识
Linux 驱动之内核相关基础知识学习
weixin_45767368的博客
03-21 1692
Linux 驱动之内核相关基础知识学习
linux 触摸屏驱动分析
杨德龙的专栏
04-23 2426
http://blog.csdn.net/funy_liu/archive/2010/03/04/5345589.aspxmini2440驱动分析系列之---------------------------------------Mini2440触摸屏程序分析By JeefJiang July，8th，2009这是mini2440驱动分析系列的第三篇文章，本文分为三个部分，第一部分
RTL8188EUS 驱动源码
最新发布
02-19
版本号表明这是2019年4月19日发布的一个修订版，可能包含了错误修复、性能提升或新的功能支持。 在研究或修改这个驱动源码时，开发人员需要了解以下关键知识点： 1. **Linux内核编程**：理解Linux内核接口，如设备...
2022年11月28日更新的cudnn 10.2
12-09
2022年11月28日发布的 CUDNN 10.2 是该库的一个重要更新版本，旨在提高性能、优化内存管理和提供对最新硬件的支持。 **GPU 在深度学习中的角色** 在深度学习领域，GPU（图形处理器）由于其并行计算能力而成为不可...
TL-WN821N_Mac10.X驱动.zip
11-19
"EUUS"可能代表该网卡适用于欧洲和美国市场，"V6"表示这是第六代版本，"191211"可能是开发或更新日期，即2019年12月11日，而"Mac10.15"则表明这个驱动程序是为MacOS Catalina（10.15版本）设计的。 总结这些信息，...
极速尊贵q5摄像头驱动
04-17
"301h_R1_multilanguage_SF_061103_delux"，这看起来像是一个驱动程序文件名，可能包含了型号（301h）、版本信息（R1）、多语言支持（multilanguage）、发布日期（SF_061103，可能是2006年11月3日的简写）以及制造商...
【嵌入式环境下linux内核及驱动学习笔记-（8-内核 I/O）-信号驱动】
weixin_45499326的博客
04-30 1110
信号是软中断,用于通知进程某个事件已经发生。进程可以选择如何响应信号:忽略、默认处理、自定义处理等。常见信号有:SIGINT(键盘中断)、SIGKILL(强制终止)、SIGSTOP(暂停进程)、SIGCONT(继续运行进程)等。信号值信号名说明1SIGHUP终端断线,用于进程与控制终端的连接2SIGINT键盘中断,用于进程的输入终端3SIGQUIT键盘的退出键(Ctrl+/)4SIGILL非法指令5SIGTRAP跟踪陷阱6SIGABRT。
AMD GPU 内核驱动分析(一)总览
tugouxp的专栏
09-11 3437
和CPU相比，GPU中包含了大量的并行计算单元，适合处理像素，矩阵，坐标等大量同类型的数据，因此，很多LINUX上的应用程序为了能够利用GPU的加速功能，都试图和GPU直接打交道，因此，系统中可能有多个组件或者程序同时使用GPU，比如桌面系统中OpenGL的实现MESA。
linux驱动开发(一)：一个最简单的内核驱动程序
baidu_38797690的博客
12-23 5482
编写一个最简单的Linux内核驱动程序，可以在加载和移除模块时打印字符串。
【Linux】内核驱动篇一--编译方法
修成真的博客
05-11 4026
内核驱动篇一--编译方法一、向内核添加新功能1.1 静态加载法1.2 动态加载法1.2.1 文件制作方法1.2.2 文件使用二、内核模块基础代码解析三、内核模块的多源文件编程四、 内核模块信息宏 注：关于驱动的编译环境，在系统移植篇已详细讲解与安装 一、向内核添加新功能 1.1 静态加载法 即新功能源码与内核其它代码一起编译进uImage文件内,下面举例说明。 新功能源码与Linux内核源码在同一目录结构下,在 linux-3.14/drivers/char/目录下编写myhello.c，文件.
驱动——ioctl数组及结构体传递
ww1106的博客
11-17 1118
2>在long mydev_ioctl (struct file *file, unsigned int cmd, unsigned long arg)接口函数内，使用copy_from_user接收用户空间拷贝过来的信息，并进行打印，再使用copy_to_user函数将修改后的结构体信息拷贝到用户空间。4>通过dmesg查看内核层的打印信息，结果如下所示，应用层传递的数组信息以及结构体信息成功传递到内核层。3>编写用户程序，通过ioctl函数传递信息给内核空间，从而达到想要的操作结果，并进行打印。
Linux内核驱动
ChrisKevin0221的博客
05-22 2533
最近一直在学习偏理论的东西，内核编译，文件管理系统，虚拟文件系统，感觉挺枯燥的，也没有写笔记来记录，估计也就听着了个耳熟，过后用到了不会，我再回头看看这些吧。 今天开始终于学到驱动部分了，开始好好记记笔记，总结一下。 文章目录内核驱动框架内核编译 内核驱动框架 #include <linux/fs.h> //file_operations声明 #include <linux/module.h> //module_init module_exit声明 #include &l
Linux内核网络设备驱动
金荣的个人技术博客
08-17 1897
本文首先从宏观上介绍数据包的接收过程，然后详细介绍了Linux网络设备驱动的工作过程，最后介绍网卡监控与调优，包括网络数据包总数、丢包、错包数量的相关统计。 1. 接收数据包过程概述 介绍数据包收包过程，有助于我们了解Linux内核网络设备在数据收包过程中的位置，下面从宏观的角度介绍数据包从被网卡接收到进入 socket 接收队列的整个过程： 加载网卡驱动，初始化 数据包从外部网络进入网卡 网卡（通过DMA）将包拷贝到内核内存中的ring buffer 产生硬件中断，通知系统收到了一个包 驱动调用 NAP
内核与驱动_00_内核编程基础知识
hskull的博客
02-02 819
内核编程环境 概述 在Windows下，32为系统中每个进程都有其自身享有的4GB内存空间，每个进程的内存空间都是相互隔离的。其中低2GB是用户空间，高2GB是内核空间。原则上，每个进程的高2GB内核空间内的数据是共享的，即绝大部分都是一样的。 而内核空间是受到硬件保护的，比如在x86架构下R0层（Ring0）的代码才可以访问内核空间，普通的应用程序编译出来后都运行在R3层，R3层程序要调用R0...
驱动认知-驱动代码编写与执行
cyh20001027的博客
03-25 2740
驱动的认知 应用层进行open，read，write驱动程序的时候，linux系统调用过程 基于驱动框架代码编写 寻找一个驱动参考（字符设备驱动） 作为初学者我们可以选择别人写好的驱动作为参考 #include <linux/fs.h> //file_operations声明 #include <linux/module.h> //module_init module_exit声明 #include <linux/init.h> //__init

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值