字符设备驱动模型

最新推荐文章于 2022-08-23 18:42:18 发布
最新推荐文章于 2022-08-23 18:42:18 发布
阅读量730 收藏
点赞数
分类专栏： linux 设备驱动


#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>

#define GLOBALMEM_SIZE 0x1000 /*全局内存最大4K字节*/
#define MEM_CLEAR 0x1  /*清0全局内存*/不推荐使用0x01 会导致不同设备的驱动拥有相同的命令号，命令号不能重复
#define GLOBALMEM_MAJOR 254    /*预设的globalmem的主设备号*/
#define GLOBALMEM_MAGIC 'm'定义幻数 正好8位
static int globalmem_major = GLOBALMEM_MAJOR;
static int count=0; //用于定义文件打开的次数，
spinlock_t lock;
/*globalmem设备结构体*/
struct globalmem_dev                                    
{                                                       
  struct cdev cdev; /*cdev结构体*/                      
  unsigned char mem[GLOBALMEM_SIZE]; /*全局内存,此驱动可以被两个进程同时访问，也是一种两进程通讯的手段*/       
    struct semaphore sem; /*并发控制用的信号量*/ 
};

struct globalmem_dev *globalmem_devp; /*设备结构体指针*/
/*文件打开函数*/
int globalmem_open(struct inode *inode, struct file *filp)
{
  /*将设备结构体指针赋值给文件私有数据指针*/
  filp->private_data = globalmem_devp;
 
  或者：如果不只包含一个设备，而是同时包含两个以上的设备时：采用以下写法：
  struct globalmem_dev *dev;
  //通过结构体成员的指针找到对应结构体的指针
  dev=container_of(inode->i_cdev,struct globalmem_dev,cdev);
  filp->private_data=dev;
  spinlock(&lock); //加锁
  if(count)//已经打开，只能被一个进程打开
   {
    spin_unlock(&lock);
    return -BUSY;
   }
   count++;
   spin_unlock(&lock);//解锁
  return 0;
}
/*文件释放函数*/
int globalmem_release(struct inode *inode, struct file *filp)
{
 spinlock(&lock);
 count--;
 spin_unlock(&lock);
  return 0;
}

/* ioctl设备控制函数 */
static int globalmem_ioctl(struct inode *inodep, struct file *filp, unsigned //inodep 表示物理上的信息。filp 打开的设备文件
  int cmd, unsigned long arg) //arg 可选的参数
{
  struct globalmem_dev *dev = filp->private_data;/*获得设备结构体指针*/
  if(_IOC_TYPE(cmd)!=GLOBALMEM_MAGIC)
   return -EINVAL;
  if(_IOC_NR(cmd)>MAX)
   return -EINVAL;
  if(_IOC_DIR(cmd)&_IOC_READ)
   err=!access_ok()
  switch (cmd)
  {
    case MEM_CLEAR:
     //LINUX 建议统一采用 ioctl()命令生成方式 命令由 设备类型(8bit)序列号也叫命令的编号(8bit)参数传递方向即是读写数据方向(2bit)用户数据大小(13bit)
     在ioctl.h中使用宏来辅助生成命令
     #define _IO(type,nr)  _IOC(_IOC_NONE,(type),(nr),0) _IOC_NONE 无数据传输
   #define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size)) _IOC_READ 读 type 设备类型 nr序列号 sizeof(size) 数据尺寸
  #define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
   #define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
   由此 可以定义MEM_CLEAR _IO(GLOBALMEM_MAGIC,0)
    内核中也会预定义一些命令，当用户命令与它冲突时，被当成内核命令例如：
    #define FIOCLEX  _IO('f', 1)  通知内核当exec调用结束时自动关闭打开的文件
    #define FIONCLEX _IO('f', 2)
    #define FIOASYNC _IOW('f', 125, int)
    #define FIONBIO  _IOW('f', 126, int)
      if (down_interruptible(&dev->sem))//获得信号量
  {
    return  - ERESTARTSYS;
  }
      memset(dev->mem, 0, GLOBALMEM_SIZE);      //除读写之外，这里对mem的操作也会引起混乱。
      up(&dev->sem); //释放信号量
      printk(KERN_INFO "globalmem is set to zero\n");
      break;

    default:
      return  - EINVAL;//对于不支持的命令，应该返回-EINVAL
  }
  return 0;
}

/*读函数*/
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size,
  loff_t *ppos)
{
  unsigned long p =  *ppos;
  unsigned int count = size;
  int ret = 0;
  struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针，读也是读private_data*/

  /*分析和获取有效的写长度*/
  if (p >= GLOBALMEM_SIZE)
    return count ?  - ENXIO: 0;
  if (count > GLOBALMEM_SIZE - p)
    count = GLOBALMEM_SIZE - p;
  if (down_interruptible(&dev->sem))//获得信号量。对并发控制后的驱动读写控制。如果非0 down_interruptible立即返回，意味着在其获得信号量之前已被打断。
  {
    return  - ERESTARTSYS;
  }
  /*内核空间->用户空间*/
  if (copy_to_user(buf, (void*)(dev->mem + p), count))
  {
    ret =  - EFAULT;
  }
  else
  {
    *ppos += count;
    ret = count;
   
    printk(KERN_INFO "read %d bytes(s) from %d\n", count, p);
  }
 up(&dev->sem); //释放信号量
  return ret;
}

/*写设备函数*/
static ssize_t globalmem_write(struct file *filp, const char __user *buf,
  size_t size, loff_t *ppos)//ppos 相对于文件开头的偏移
{
  unsigned long p =  *ppos;
  unsigned int count = size;
  int ret = 0;
  struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针，
  一般规则是 将文件的私有数据指向设备结构体即通过private_data访问设备结构体*/
 
  /*分析和获取有效的写长度*/
  if (p >= GLOBALMEM_SIZE)
    return count ?  - ENXIO: 0;
  if (count > GLOBALMEM_SIZE - p)
    count = GLOBALMEM_SIZE - p;
  if (down_interruptible(&dev->sem))//获得信号量
  {
    return  - ERESTARTSYS;
  }
  /*用户空间->内核空间*/
  if (copy_from_user(dev->mem + p, buf, count))
    ret =  - EFAULT;
  else
  {
    *ppos += count;//指针移动
    ret = count;
   
    printk(KERN_INFO "written %d bytes(s) from %d\n", count, p);
  }
up(&dev->sem); //释放信号量
  return ret;
}

/* seek文件定位函数 */
static loff_t globalmem_llseek(struct file *filp, loff_t offset, int orig)
{
  loff_t ret = 0;
  switch (orig)//主要移动f_pos
  {
    case 0:   /*相对文件开始位置偏移*/
      if (offset < 0)
      {
        ret =  - EINVAL;
        break;
      }
      if ((unsigned int)offset > GLOBALMEM_SIZE)
      {
        ret =  - EINVAL;
        break;
      }
      filp->f_pos = (unsigned int)offset;
      ret = filp->f_pos;
      break;
    case 1:   /*相对文件当前位置偏移*/
      if ((filp->f_pos + offset) > GLOBALMEM_SIZE)
      {
        ret =  - EINVAL;
        break;
      }
      if ((filp->f_pos + offset) < 0)
      {
        ret =  - EINVAL;
        break;
      }
      filp->f_pos += offset;
      ret = filp->f_pos;
      break;
    default:
      ret =  - EINVAL;
      break;
  }
  return ret;
}

/*文件操作结构体*/块设备驱动将看不到他的存在
static const struct file_operations globalmem_fops =
{
  .owner = THIS_MODULE,
  .llseek = globalmem_llseek,
  .read = globalmem_read,
  .write = globalmem_write,
  .ioctl = globalmem_ioctl,
  .open = globalmem_open,
  .release = globalmem_release,
};

/*初始化并注册cdev：struct cdev {
 struct kobject kobj;
 struct module *owner;
 const struct file_operations *ops;
 struct list_head list;
 dev_t dev;
 unsigned int count;
}; 用于描述一个设备*/
static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
{
  int err, devno = MKDEV(globalmem_major, index);

  cdev_init(&dev->cdev, &globalmem_fops);
            /* void cdev_init(struct cdev *cdev, const struct file_operations *fops)
       {
 memset(cdev, 0, sizeof *cdev);
 INIT_LIST_HEAD(&cdev->list);
 kobject_init(&cdev->kobj, &ktype_cdev_default);
 cdev->ops = fops;   建立globalmem_fops和cdev联系
}*/
  dev->cdev.owner = THIS_MODULE;
  dev->cdev.ops = &globalmem_fops;//建立起file_operations和cdev之间的联系
  err = cdev_add(&dev->cdev, devno, 1);//向系统添加一个cdev
  if (err)
    printk(KERN_NOTICE "Error %d adding LED%d", err, index);
}

/*设备驱动模块加载函数*/
int globalmem_init(void)
{
  int result;
  //通过主设备号globalmem_major 和次设备号0生成dev_t ,主设备号：用于连接设备文件和设备驱动，次设备号：用于多个设备区分是哪个设备
  dev_t devno = MKDEV(globalmem_major, 0);
  MAJOR(dev_t devno)//获得主设备号
  MINOR(dev_t devno) //获取次设备号
  /* 申请设备号  register_chrdev_region 用于已知设备号的情况下*/
  if (globalmem_major)
    result = register_chrdev_region(devno, 1, "globalmem");
  else  /* 动态申请设备号 alloc_chrdev_region 用于未知设备号，避开冲突*/
  {
    result = alloc_chrdev_region(&devno, 0, 1, "globalmem");
    globalmem_major = MAJOR(devno);
  } 
  if (result < 0)
    return result;
   
  /* 动态申请设备结构体的内存*/
  globalmem_devp = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
  if (!globalmem_devp)    /*申请失败*/
  {
    result =  - ENOMEM;
    goto fail_malloc;
  }
  memset(globalmem_devp, 0, sizeof(struct globalmem_dev));
 
  globalmem_setup_cdev(globalmem_devp, 0);
  　自旋锁与信号量"类似而不类"，类似说的是它们功能上的相似性，"不类"指代它们在本质和实现机理上完全不一样，不属于一类。

　　自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环查看是否该自旋锁的保持者已经释放了锁，"自旋"就是"在原地打转"。而信号量则引起调用者睡眠，它把进程从运行队列上拖出去，除非获得锁。这就是它们的"不类"。

　　但是，无论是信号量，还是自旋锁，在任何时刻，最多只能有一个保持者，即在任何时刻最多只能有一个执行单元获得锁。这就是它们的"类似"。

　　鉴于自旋锁与信号量的上述特点，一般而言，自旋锁适合于保持时间非常短的情况，它可以在任何上下文使用；信号量适合于保持时间较长的情况，会只能在进程上下文使用。如果被保护的共享资源只在进程上下文访问，则可以以信号量来保护该共享资源，如果对共享资源的访问时间非常短，自旋锁也是好的选择。但是，如果被保护的共享资源需要在中断上下文访问（包括底半部即中断处理句柄和顶半部即软中断），就必须使用自旋锁。

  spin_lock_init(&lock);//初始化自旋锁
  init_MUTEX(&globalmem_devp->sem);   /*初始化信号量*/ 
  return 0;
 
 
  //以下是申请两个以上的设备：/* 动态申请2个设备结构体的内存*/
  globalmem_devp = kmalloc(2*sizeof(struct globalmem_dev), GFP_KERNEL);
  if (!globalmem_devp)    /*申请失败*/
  {
    result =  - ENOMEM;
    goto fail_malloc;
  }
  memset(globalmem_devp, 0, 2*sizeof(struct globalmem_dev));
 
  globalmem_setup_cdev(&globalmem_devp[0], 0);
  globalmem_setup_cdev(&globalmem_devp[1], 1);
  return 0;
 
  fail_malloc: unregister_chrdev_region(devno, 1);//释放申请的设备号
  return result;
}

/*模块卸载函数*/
void globalmem_exit(void)
{
  cdev_del(&globalmem_devp->cdev);   /*注销cdev*/
  kfree(globalmem_devp);     /*释放设备结构体内存*/
  unregister_chrdev_region(MKDEV(globalmem_major, 0), 1); /*释放设备号*/
   //以下是申请两个以上的设备
    cdev_del(&(globalmem_devp[0].cdev));  
  cdev_del(&(globalmem_devp[1].cdev));   /*注销cdev*/
  kfree(globalmem_devp);     /*释放设备结构体内存*/
  unregister_chrdev_region( (globalmem_major, 0), 2); /*释放设备号*/
}

MODULE_AUTHOR("Song Baohua");
MODULE_LICENSE("Dual BSD/GPL");

module_param(globalmem_major, int, S_IRUGO);

module_init(globalmem_init);
module_exit(globalmem_exit);


使用 insmod 挂载之后。cat /proc/devices
mknod /dev/globalmem c 250 0 创建设备节点
echo "hello world" > /dev/globalmem 写数据到设备
cat /dev/globalmem
linux中的驱动中的总线和设备模型都可以在 /sys(sysfs文件系统)目录下找到对应的节点
sysfs文件系统 :是一个虚拟的文件系统把系统上的设备和总线构成一个分级的文件
#include <linux/init.h>                               
#include <linux/module.h>                               
MODULE_LICENSE("Dual BSD/GPL");                               
                               
int add_integar(int a,int b)                               
{                               
 return a+b;                            
}
                              
int sub_integar(int a,int b)                               
{                               
 return a-b;                            
}                           

EXPORT_SYMBOL(add_integar);
EXPORT_SYMBOL(sub_integar);

knight_yzzz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux字符设备驱动权限修改,3. Linux - 字符设备驱动模型
weixin_32459553的博客
04-30 1268
在上一节(Linux 设备驱动 — 概念)中，我们对Linux设备驱动有了大致的了解；接下来的几个章节主要对字符设备进行学习。1、设备描述结构在任何一种驱动模型中，设备都会用内核中的一种结构来描述。我们的字符设备在内核中使用struct cdev {struct kobject kobj;struct module *owner;const struct file_operations *ops;...
linux 字符设备 平台总线,3. 字符设备驱动-总线设备驱动模型写法
weixin_39620629的博客
05-08 297
一、引言：在 字符设备驱动的传统写法 中，介绍了字符设备的传统写法。从代码中我们可以看到，使用的引脚，写死在代码中了，如果更改硬件资源，比如将GPIO3_4改成GPIO3_5，那就需要重新编译这个驱动程序，如果该驱动程序是放在内核里的，那么就需要重新编译内核。并且，在需要更改硬件资源的时候都需要去阅读驱动源码，对于没有写驱动能力的人来说，这也是挺痛苦的。在Linux内核持续发展中，改进了写驱动程序...
1.1设备树的引进与体验——字符设备驱动程序的三种写法
一个嵌入式软件工程师的博客
08-23 643
怎么写一个LED驱动程序？
字符设备驱动模型，混杂设备驱动模型，总线驱动模型之间的关联
欧阳海宾
08-13 750
字符设备驱动程序的三种写法
天高任鸟飞海阔凭鱼跃的专栏
10-27 3968
驱动工程师如何去写驱动程序？ 要看原理图。确定如何去操作硬件。 对于点亮led灯来说，确定引脚，查看芯片手册，确定如何去操作引脚，要设置哪些寄存器，如何设置这些寄存器才可以让这个引脚输出高电平或者低电平。 写驱动程序 驱动程序起封装作用，如何封装。应用程序要操作硬件需要open某个设备文件。调用read函数获得led的状态。设置灯的状态可以调用write函数或者各种ioctl函数等。驱动程序就需要...
Linux设备驱动-字符设备驱动浅析
一起学嵌入式
01-06 1146
Linux 设备驱动分为三种：字符设备驱动、块设备驱动、网络设备驱动。内核针对每一类设备都提供了对应的驱动模型框架，包括基本的内核设施和文件系统接口。 其中，字符设备驱动程序是最常见的，也是相对比较容易理解的一种。其典型的程序框架示例，如下： #include <linux/module.h> #include <linux/kernel.h> #include <linux/fs.h> #include <linux/cdev.h> /* 定义一个字符设备
Linux 字符设备驱动模型
终南樵夫
03-11 354
Linux 字符设备驱动模型
linux字符设备驱动模型
03-26
linux字符设备驱动模型
Linux字符设备驱动实现
11-06
总之，编写Linux字符设备驱动是一项技术性极强的任务，它涉及到内核编程、同步机制和设备驱动模型的理解。通过实现一个简单的聊天程序，我们可以直观地看到字符设备驱动如何在用户空间和内核空间之间搭建桥梁，提供...
Linux驱动开发——字符设备驱动
weixin_43920383的博客
08-23 1009
分享一句话：大事随心，小事随脑。字符驱动开发，字符驱动框架
字符设备驱动的过程
weixin_43601709的博客
07-28 563
##字符设备驱动 ###字符设备驱动组成 1.字符驱动模块加载与卸载函数，在加载函数中应包括设备号的申请和 cdev 的注册，卸载函数则完成其相反的功能，其中设备号的申请则涉及到设备号的注册函数和动态分配函数， cdev 的注册则要用到内核提供的 cdev_add() 函数， cdev 的注销则用到内核提供的 cdev_del() 函数。 2.字符设备驱动的 file_operations 结构体成员函数的实现，我们清楚用户调用到驱动操作的大致过程，先由用户空间到内核空间，最终落实到驱动中的文件操作结构体中
WinSock学习笔记（二）
my15y的专栏
02-14 817
WinSock学习笔记（二）作者：肖进 与socket有关的一些函数介绍1、读取当前错误值：每次发生错误时，如果要对具体问题进行处理，那么就应该调用这个函数取得错误代码。 int WSAGetLastError(void ); #define h_errno WSAGetLastError()错误值请自己阅读Winsock2.h。2、将主机的unsign
黑苹果英伟达驱动Geforce-Kepler-Patcher-V2-by-Chris1111-HeiPG.cn
最新发布
09-07
Geforce_Kepler_Patcher_V2_by_Chris1111___HeiPG.cn
自激式开关电源变压器的设计技术资料开发设计用的重要资料.zip
09-07
自激式开关电源变压器的设计技术资料开发设计用的重要资料.zip
SENSORO物联网智慧城市解决方案.pdf
09-07
SENSORO物联网智慧城市解决方案.pdf
南京邮电大学通达学院在广东2021-2024各专业最低录取分数及位次表.pdf
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
河南城建学院在广东2021-2024各专业最低录取分数及位次表.pdf
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
爬取淘宝热销(热门)沐浴露商品信息透明公开的数据集
09-07
本资源专注于收集淘宝热销(热门)沐浴露商品信息，内容涵盖商品的店铺所在省份、城市位置、商品的名称、销售价格、累积销量、单价（以人民币计价）、付款的顾客人数、是否提供包邮服务、是否为天猫平台的商品，以及相关的满减优惠情况。这些详细的数据点均来源于淘宝平台的公开透明信息，经过精确抓取和整理，旨在为分析电商平台上的新品推荐策略和消费者购买行为提供实用数据。 这些数据严格遵循淘宝平台的公开政策和隐私保护原则获取，确保了信息的合法性与合规性。然而，本资源仅作为学习参考之用，意在帮助研究人员、市场分析师或学生等理解电商领域的商品推荐机制、销售动态及市场趋势。 任何将此数据用于商业目的或其他未授权的活动都是不恰当的，甚至可能触犯相关法律条款。 在使用这些数据进行学术研究或个人学习时，用户应自觉遵守相关法律法规，尊重数据来源和版权，正确引用数据源，并不得用于任何形式的商业盈利。 注意：这是一份数据集
Linux 2.6 设备驱动模型解析
"Linux_2.6_设备驱动模型.pdf" 在Linux内核2.6版本中，设备驱动模型是一个核心的组件，它为管理硬件设备提供了统一的框架。这个模型是一个复杂的数据结构网络，旨在简化设备驱动的开发和管理。下面将详细阐述该模型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值