2017-04-21 15:57:37 renlonggg 阅读数 274
  • input子系统基础之按键-linux驱动开发第8部分

    本课程是linux驱动开发的第8个课程,主要内容是linux的input子系统。学习本课程的目标是对input子系统的框架结构有深入理解,应用层和驱动层的调用关系和方法完全了解,能够自己移植按键等常见输入类设备的驱动。

    5099 人正在学习 去看看 朱有鹏

原文地址:http://blog.chinaunix.net/uid-22237530-id-1781802.html

最近做Linux下驱动程序遇到了不少问题。Linux下驱动程序的设计,参考的书籍有《Linux设备驱动》第二版和第三版。但是书籍上说的驱动程序的编写都是怎么供用户态使用,即用于内核和用户态的交互。但是现在做项目遇到了,在静态编译进内核的程序中调用驱动程序,这涉及了怎么在内核中调用驱动程序。查了很多书籍都没有介绍这方面的知识。经过几个星期的努力,不断上网找资料,终于实现了怎么在内核模块中调用驱动程序,下面和大家一起分享一下经验,希望对大家有帮助。同时我还有几个问题没有解决,望大家提点意见,谢了。

   下面是我参考书籍写的一个简单的字符设备驱动程序,如下:
#include
#include
#include
#include
#include
#include
#include
#include"chardev.h"
MODULE_LICENSE("GPL");
#define MAJOR_NUM 250//
ssize_t bao_read (struct file*,char*,size_t,loff_t*);
ssize_t bao_write (struct file*,const char*,size_t,loff_t*);
int bao_ioctl(struct inode *inode,struct file*filp,unsigned int cmd,unsigned long args);
int bao_open(struct inode *inode,struct file *filp);
int bao_release(struct inode *inode,struct file *filp);
//file_operations
struct file_operations bao_fops=
{
 read:bao_read,
 write:bao_write,
 ioctl:bao_ioctl,
 open:bao_open,
 release:bao_release,
 owner:THIS_MODULE,
};
static int bao_var=0;//baovar
static int bao_count=0;
static struct semaphore  sem;
static spinlock_t spin=SPIN_LOCK_UNLOCKED;
int __init bao_init(void)
{
 int ret;
 //
 ret=register_chrdev(MAJOR_NUM,"baovar",&bao_fops);
 if(ret)
 {
  printk("baovar register failure\n");
 }
 else
 {
  printk("baovar register success\n");
  init_MUTEX(&sem);
 }
 return ret;
}
void __exit bao_exit(void)
{
 int ret;
 
 //
 ret=unregister_chrdev(MAJOR_NUM,"baovar");
 if(ret)
 {
  printk("baovar unregister failure\n");
 }
 else
 {
  printk("baovar unregister success\n");
 }
}
int bao_open(struct inode *inode,struct file *filp)
{
 //
 spin_lock(&spin);
 //
 if(bao_count)
 {
  spin_unlock(&spin);
  return -EBUSY;
 }
 printk("baoopen\n");
 bao_count++;
 // spin_unlock(&spin);
 return 0;
}
int bao_release(struct inode *inode,struct file *filp)
{
 bao_count--;
 printk("close->bao\n");
 return 0;
}
ssize_t bao_read(struct file*filp,char *buf,size_t len,loff_t *off)
{
 //
 if(down_interruptible(&sem))
 {
  return -ERESTARTSYS;
 }
 //
 if(__copy_to_user(buf,&bao_var,sizeof(int)))
 {
  up(&sem);
  return -EFAULT;
 }
 up(&sem);
 return sizeof(int);
}
ssize_t bao_write(struct file*filp,const char *buf,size_t len,loff_t *off)
{
 //
 if(down_interruptible(&sem))
 {
  return -ERESTARTSYS;
 }
 //
 if(__copy_from_user(&bao_var,buf,sizeof(int)))
 {
  up(&sem);
  return -EFAULT;
 }
 //
 up(&sem);
 return sizeof(int);
}
int bao_ioctl(struct inode *inode,struct file*filp,unsigned int cmd,unsigned long args)
{
 if(_IOC_TYPE(cmd)!=BAO_IOCTL){return -EINVAL;}
 if(_IOC_NR(cmd)>BAO_IOCTL_MAXNR){return -EINVAL;}
 
 int ret;
 switch(cmd)
 {
  case IOCTL_READ:
   return __put_user(bao_var, (int *) args);
  case IOCTL_WRITE:
   {ret = __get_user(bao_var, (int *) args);
              if (ret)
                 return ret;
              printk("bao_var = %d\n", bao_var);
              break; }
  default:printk("error\n");
   
 }
 return 1;
}
module_init(bao_init);
module_exit(bao_exit);
以上是字符设备驱动模块
chardev.h头文件的内容如下:
#include
#define BAO_IOCTL 't'
#define IOCTL_READ  _IOR(BAO_IOCTL, 0, int)
#define IOCTL_WRITE  _IOW(BAO_IOCTL, 1, int)
#define BAO_IOCTL_MAXNR 1

下面是另一内核模块,在此模块中调用了以上驱动程序,成功的对设备进行操作:
  #include     
  #define   __KERNEL_SYSCALLS__  
  #ifdef   MODVERSIONS  
  #include     
  #endif   
  #include     
  #include     
  #include     
  #include     
  #include     
  #include  
  #include     
  #include     
  #include     
  #include  
  #include   "chardev.h"
  static inline _syscall3(int, ioctl, int ,fd,int, cmd,int*, arg);
  MODULE_LICENSE("GPL");
  static char buf1[20];
  static char buf2[20];
  #define  BEGIN_KMEM { mm_segment_t  old_fs  =  get_fs();  set_fs(get_ds());  
  #define  END_KMEM  set_fs(old_fs);  }  
   
  int   errno;  
  int   init_module(void){  
  int   err;
  int put,get;
  put=113579;
  sprintf(buf1,"%s","baoqunmin"); 
  printk("<1>Hello,world\n");  
  BEGIN_KMEM;  
  err=open("/dev/baovar",O_RDWR,0); 
  if(err>0)  
  printk("open   file   successful\n");
  write(err,buf1,sizeof(buf1));
  read(err,buf2,sizeof(buf2));
  buf2[20]='\n';
  printk("buf2-->%s\n",buf2);
  ioctl(err,IOCTL_WRITE,&put);
  ioctl(err,IOCTL_READ,&get);
  printk("get-->%d\n",get);
  END_KMEM;  
  return   0;  
  }  
  void   cleanup_module(void){  
  printk("<1>Goodbye   cruel   word\n");  
  }
说明:部分转载,详细的去访问原文

2018-01-24 23:29:32 eZiMu 阅读数 3288
  • input子系统基础之按键-linux驱动开发第8部分

    本课程是linux驱动开发的第8个课程,主要内容是linux的input子系统。学习本课程的目标是对input子系统的框架结构有深入理解,应用层和驱动层的调用关系和方法完全了解,能够自己移植按键等常见输入类设备的驱动。

    5099 人正在学习 去看看 朱有鹏

概述:

linux驱动程序调用(运行/执行)应用程序,即驱动调用用户空间的应用程序。本文主要是从系统API的使用角度讲述。


API声明的位置:

声明在include/linux/kmod.h里面,相应函数实现在kernel/kmod.c里面。


函数call_usermodehelper()使用:

函数call_usermodehelper()声明如下:

extern int call_usermodehelper(char *path, char **argv, char **envp, int wait);

参数说明:
path:需要执行的应用程序,及路径。
argv:传递给应用程序的参数,如果没有参数用NULL。
envp:环境变量。如果在path指定的地方没有找到应用程序,那么将会在envp环 境变量中,查找应用程序。
wait:控制标志,可用下面的4个宏定义其中之一。在kmod.h中定义如下控制标志:

//驱动程序不等待应用程序的返回
#define UMH_NO_WAIT     0       /* don't wait at all */
//驱动程序等待应用程序执行完毕返回,但不处理返回的值
#define UMH_WAIT_EXEC   1       /* wait for the exec, but not the process */
//驱动程序等待应用程序执行完毕返回,并处理返回值
#define UMH_WAIT_PROC   2       /* wait for the process to complete */
//个人理解,应用程序不会返回时,驱动等待,直到应用程序进程被杀死后返回
#define UMH_KILLABLE    4       /* wait for EXEC/PROC killable */

用法例子:

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/kmod.h>

MODULE_AUTHOR("zimu");
MODULE_LICENSE("GPL");

static int __init practiceCall(void)
{
        char *path = "/home/zimu/practice/a.out";
        char *arv[] = {path,"",NULL};//无参数,注意要按照这个格式path在 第一个位置,必须NULL结束
        char *env[] = {"/home/zimu","/usr/local/sbin",NULL};//多路径可以用逗号隔开,也可以在一对引号中用分号隔开,必须NULL结束标志

        printk("%s:call_usermodehelper\n",__func__);
        call_usermodehelper(path,arv,env,UMH_WAIT_PROC);
        return 0;
}

static void __exit practiceCallExit(void)
{
        printk("%s:call_usermodehelper\n",__func__);
}

module_init(practiceCall);
module_exit(practiceCallExit);

驱动执行在/home/zimu/practice/路径下的应用程序a.out,如果在指定路径找不到a.out,将会在环境变量/home/zimu,/usr/local/sbin路径下查找a.out。a.out无参数。注意:arv,env最后一个一定要是NULL,否则会无法调用到应用程序,env如果没有参数,必须写成char *env[] = {NULL}。

a.out的源码如下:

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

main()
{
        int fd = -1;

        fd = open("/home/zimu/practice/file.txt",O_RDWR|O_CREAT);
        write(fd,":practice\n",10);
        close(fd);
}

a.out的功能是在/home/zimu/practice/路径下,打开file.txt文件,如果文件不存在,就创建file.txt文件,并向文件中写入“:practice”字符,以回车键结束。

加载例子中的驱动模块时,就会在/home/zimu/practice/路径下创建file.txt文件。

注意:驱动调用的应用程序,都是在root用户下运行的

2015-08-18 13:47:28 Chihiro_S 阅读数 1056
  • input子系统基础之按键-linux驱动开发第8部分

    本课程是linux驱动开发的第8个课程,主要内容是linux的input子系统。学习本课程的目标是对input子系统的框架结构有深入理解,应用层和驱动层的调用关系和方法完全了解,能够自己移植按键等常见输入类设备的驱动。

    5099 人正在学习 去看看 朱有鹏

Linux驱动教程http://pan.baidu.com/s/1c0hljUS


编写简单应用调用驱动——头文件

• 打印头文件

– include <stdio.h>调用打印函数printf

• 应用中调用文件需要的头文件

– #include <sys/types.h>基本系统数据类型。系统的基本数据类型在32 编译

 

环境中保持为32 位值,并会在64 编译环境中增长为64 位值。

– #include <sys/stat.h>系统调用函数头文件。可以调用普通文件,目录,管

道,socket,字符,块的属性

– #include <fcntl.h>定义了open函数

– #include <unistd.h>定义了close函数

– #include <sys/ioctl.h>定义了ioctl函数

• 调用的头文件是和编译器放在一起的

– 这里使用arm2009q3编译器,编译器使用arm-none-linux-gnueabi-gcc

• 在编译器目录下使用查找命令找到该头文件

– 例如#find ./ -name types.h

• 调用的函数

– open函数是返回文件描述符

– ioctl函数是应用向驱动传值

– close函数是关闭打开的文件

• 编写应用程序的代码,编译

– arm-none-linux-gnueabi-gcc -o invoke_hello invoke_hello.c -static

• 开发板中加载devicenode_linux_module驱动,运行应用

2018-10-02 16:27:00 u014281970 阅读数 90
  • input子系统基础之按键-linux驱动开发第8部分

    本课程是linux驱动开发的第8个课程,主要内容是linux的input子系统。学习本课程的目标是对input子系统的框架结构有深入理解,应用层和驱动层的调用关系和方法完全了解,能够自己移植按键等常见输入类设备的驱动。

    5099 人正在学习 去看看 朱有鹏

禁止转载!!!!

Linux内核调用I2C驱动_以MPU6050为例

0. 导语

最近一段时间都在恶补数据结构和C++,加上导师的事情比较多,Linux内核驱动的学习进程总是被阻碍、不过,十一假期终于没有人打扰,有这个奢侈的大块时间,可以一个人安安静静的在教研室看看Linux内核驱动的东西。按照Linux嵌入式学习的进程,SPI驱动搞完了之后就进入到I2C驱动的学习当中,十一还算是比较顺利,I2C的Linux驱动完成了。

为了测试I2C是否好用,选择一个常用的I2C传感器,手头有个MPU6050,刚好作为I2C的从器件,那就以MPU6050为例,进行Linux底层的I2C驱动开发。

同样的使用Linux内核中的GPIO模拟I2C的时序一点难度没有,I2C的硬件标准时序也是非常的简单,闭着眼睛都能画出时序图吧,如果我们使用Linux内核提供了I2C机制,那么问题不单单是要解决时序,而重点在于对于整个I2C的机制的把握,,。刚刚拿到I2C内核机制的时候,我也看的很晕,i2c_client, i2c_master, i2c_driver, i2c_device,这些东西到底有什么关系呢?到底我该如何让Linux系统的I2C为我所用,按照我的意愿对MPU6050进行读取?到底我能挑出对我有用的Linux的I2C机制,其他没用的机制我不启动,以简化代码。

那么,就真需要从I2C最底层说起。

1. 实验平台

平台 内容
ARM板子 友善之臂Nano-T3 (CortexA53架构,Samsung S5C6818芯片)
ARM板子的Linux系统 Ubuntu 16.04.2 LTS
Linux开发主机 Ubuntu 16.04.3 LTS amd4版本
Linux内核版本 Linux3.4.y
编译器COMPILE_CROSS arm-cortexa9-linux-gnueabihf-
从设备 MPU6050模块(I2C接口)

2. 查看系统I2C的支持

按照SPI驱动的思维,使用spi_driver注册,然后和spi_device匹配,使之进入probe函数,完成spi_master的获取,依照这个方法,我的I2C驱动也是按照这个方法,寻求i2c_driver和i2c_device匹配,然而I2C的驱动尤其特殊之处,使得我的i2c_driver怎么注册都不成功,不是内核内存炸了,就是总是返回失败。

后来我才发现,i2c的使用是不需要注册的,或者严格说一点,Linux系统在启动的时候已经帮你注册好了,而你再去i2c_driver_register的时候肯定是失败的。所以到底我们使用I2C驱动的时候到底需不需要注册,则需要在Linux系统里面查看当前I2C的注册状态。那么流程就比较清晰了,如果查看系统注册了I2C那么就在驱动中直接使用;如果系统没有注册I2C那么我们先注册I2C再使用。

2.1 如何查看?

目标板终端输入:ls /sys/bus/i2c/devices

810200-20181002154126726-1097954101.png

可以看到我这个主机是支持4个I2C外设的(方框圈出),如果是这样的情况,我们就可以直接使用上面的i2c。这里的i2c-0,i2c-1....指的是4个i2c_master,而i2c_master可以挂N个i2c_client

其他的数字设备就是我挂载的i2c_master上的i2c_client,举个例子,画圈的【0-0069】意思是:挂载到i2c-0上的从地址为0x69的设备,那么【2-0048】的意思就是:挂载到i2c-2 adapter上的从地址为0x48的设备。

我们开发的MPU6050驱动依托I2C进行传输,则需要在这个文件夹创建设备节点才能利用Linux内核提供的I2C方法进行数据的交互。

2.2 弄清楚MPU6050的从地址与Linux I2C从地址的合法性

随手搜了一下MPU6050的从地址,有的给出了MPU6050的从地址是0x68,有的给出的是0xD0,一开始我也懒查,认定MPU6050的地址在A0引脚为低电平的时候为0x68,加载驱动的时候出现了很尴尬的事情,0-0068这个地址已经被DS1607实时时钟占用,然后网上有人说是把A0引脚打到高电平地址就是0xD0,可是我试0xD0的时候,被Linux警告,说是从地址不合法,我查看了Linux内核的i2c_core.c文件,里面有个地址校验,高于0x7F的7-bit地址,都是不合法的,Linux不可能犯这样的错误,肯定是网友的锅。果然,我阅读了手册,如果A0的电平为高那么地址是0x69。说从地址是0xD0的人,犯了一个错误,他们多半玩的是模拟IO出的I2C波形,他们对I2C协议标准不够了解,的确0x69 << 1 = 0xD0,I2C在读写的时候,预留出7-bit地址前移1位,把最低位作为读写标识,但绝对不能说从地址就是0xD0。

不过可以再一次看见Linux内核的严谨、严肃的态度。也再一次说,不能懒惰,自己查手册,看最标准的说明。

3 I2C 驱动开发

我这里给出最简单的模型,其他的字符驱动注册什么的同spi驱动,这里只说明I2C驱动怎么使用。

3.1 I2C的注册

static struct i2c_board_info __initdata sp6818_mpu6050_board_info = {
    I2C_BOARD_INFO("mpu6050-i2c", MPU6050_SLAVE_ADDRESS),,
    .irq    = -1,
};

int xxx_hw_init(){
    struct i2c_client *client;
    struct i2c_adapter *adapter;

    adapter = i2c_get_adapter(0);
    if (!adapter) {
        ret = -ENXIO;
        printk(DRV_NAME "\terror: %d : init i2c adapter failed.\n", ret);
        return ret;
    }
    strlcpy(adapter->name, "nxp_i2c",sizeof(adapter->name));
    client = i2c_new_device(adapter, &sp6818_mpu6050_board_info);
    if (!client) {
        ret = -ENXIO;
        printk(DRV_NAME "\terror: %d : init i2c client failed.\n", ret);
        return ret;
    }
}

你没有看错,i2c的使用就是这么简单,我有什么办法,我之前开发加上i2c_register和字符驱动的初始化什么的,整init函数整了近100多行,结果不断的尝试,发现就这些。

下面就说几个重点:

3.1.1 adapter的获取

adapter = i2c_get_adapter(0);定义一个指针,然后使用i2c_get_adapter(0),得到我们上面说的,i2c-0,这个adapter。你疑问了,我为什么选择i2c-0这个adapter,为什么不选择-i2c-其他。因为这个开发板只把-i2c-0的引脚印出来了。

810200-20181002160501845-1145647767.png

。。。

这样就获取到了adapter。

3.1.2 client的创建

接着我们就要创建一个client,这个client就指的是你的mpu6050,我们使用i2c_board_info这个结构体来描述mpu6050,先定义一个这个info:

static struct i2c_board_info __initdata sp6818_mpu6050_board_info = {
    I2C_BOARD_INFO("mpu6050-i2c", MPU6050_SLAVE_ADDRESS),,
    .irq    = -1,
};

第二行的,”mpu6050-i2c“就是注册到Linux系统里面的设备名字,可以在如图所示路径和cat命令查看。

810200-20181002160841607-1477667037.png

MPU6050_SLAVE_ADDRESS就是MPU6050的地址了,0x69 ,MPU6050的A0接高电平,地址是0x69没毛病。

然后,就是生成这个client且和之前那个adapter绑定:

client = i2c_new_device(adapter, &sp6818_mpu6050_board_info);

之后client的信息和adapter的信息我们要保存起来,可以定义一个全局指针之类的承接初始化后的client和adapter,因为后面的传输数据要用。

到此,I2C完成了,很简单,可是探索起来好麻烦。

3.2 I2C数据的写入

static int 
__mpu6050_write_reg(MPU6050* this, char reg_addr, char reg_value)
{
    int ret;
    struct i2c_msg msg;
    char write_buffer[10];
    
    memset(write_buffer, 0, 10);
    write_buffer[0] = (char)reg_addr;
    write_buffer[1] = (char)reg_value;
    msg.addr = (this->hw->i2c_clit->addr);
    msg.flags = 0;
    msg.len = 2;
    msg.buf = &write_buffer[0];
    ret = i2c_transfer(this->hw->i2c_adper, &msg, 1);

    return ret;
}

看一下我的数据写入函数,提取出有用的信息,mpu6050写寄存器,需要传输两个字节的信息,一个是寄存器地址,另一个是寄存器的值,按照上面的格式进行,msg.length不包含器件的从地址,就是实在的你想法几个数据的多少,我们这里只发两个,一个是寄存器地址和寄存器的值,所以是2;如果你是要发送则msg.flag一定是0。

我的函数this->hw->i2c_adapter就是上面存储的adapter的指针,this->hw->i2c_clit就是存储的上面初始化的client的指针。

3.3 I2C数据的读

读相比于写就费劲多了,但是也没难到哪里去,只不过是两条msg,先写后读:

__mpu6050_read_reg(MPU6050* this, char reg_addr)
{

    struct i2c_msg msg[2];
    char write_buffer[10];
    int ret, i;

    memset(write_buffer, 0, 10);
    memset(this->buffer, 0, 10);
    write_buffer[0] = (char)reg_addr;
    msg[0].addr = (this->hw->i2c_clit->addr);
    msg[0].flags = 0;
    msg[0].len = 1;
    msg[0].buf = &write_buffer[0];
    msg[1].addr = (this->hw->i2c_clit->addr);
    msg[1].flags = I2C_M_RD;
    msg[1].len = 1;
    msg[1].buf = &this->buffer[0];
    
    ret = i2c_transfer(this->hw->i2c_adper, &msg, 2);
}

意思很明显。

到此,i2c的注册和数据传输完成,我们可以在上层建立函数读取MPU6050的值了。

4 成果

验证函数:

#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>

short x_accel, y_accel, z_accel;
short x_gyro, y_gyro, z_gyro;

int main()
{
    char buffer[128];
    short *time;
    int in, out;
    int nread;
    
    in = open("/dev/MPU6050", O_RDONLY);
    if (!in) {
        printf("ERROR: %d, Open /dev/MPU6050 nod failed.\n", -1);
        return -1;  
    }   
    nread = read(in, buffer, 12);
    close(in);  
    if (nread < 0) {
        printf("ERROR: %d, A read error has occurred\n", nread);
        return -1;  
    }

    time = (short*)buffer;
    x_accel = *(time);
    y_accel = *(time + 1);
    z_accel = *(time + 2);
    x_gyro =  *(time + 3);
    y_gyro =  *(time + 4);
    z_gyro =  *(time + 5);
    printf("x accel is: %d \n", x_accel);
    printf("y accel is: %d \n", y_accel);
    printf("z accel is: %d \n", z_accel);   
    printf("x gyro is: %d \n", x_gyro);
    printf("y gyro is: %d \n", y_gyro);
    printf("z gyro is: %d \n", z_gyro);

    exit(0);
}

测试脚本:

# !/bin/bash                                                                            
for((i=1;i<=10000;i++));                                                                
do                                                                                      
./test_mpu6050.o                                                                        
sleep 1                                                                                 
done                                                                                    

810200-20181002200518098-1025064281.png

源代码:

Github地址:https://github.com/lifimlt/carlosdriver

见 mpu6050.c mpu6050.h 和mpu6050_def.h三个文件

mpu6050_test.c为测试文件

参考文献:

[1] Linux org, Serial Peripheral Interface (I2C),

[2] choiyoung87, Linux中的I2C(二)——adapter的初始化, 2011年12月01日

[3] liuwanpeng , [《linux设备驱动开发详解》笔记——15 linux i2c驱动](https://www.cnblogs.com/liuwanpeng/p/7346558.html), 2017年8月23日

2020-01-01 20:26:42 G_Super_Mouse 阅读数 10
  • input子系统基础之按键-linux驱动开发第8部分

    本课程是linux驱动开发的第8个课程,主要内容是linux的input子系统。学习本课程的目标是对input子系统的框架结构有深入理解,应用层和驱动层的调用关系和方法完全了解,能够自己移植按键等常见输入类设备的驱动。

    5099 人正在学习 去看看 朱有鹏

Linux驱动设计之系统调用

  • Linux系统调用结构
    • 特点一:系统调用就像快递员,只传送命令,不实现相关命令
    • 特点二:会调用VFS进行分类
  • 字符设备驱动
    • 内核的对象为struct cdev
    • 每个字符设备驱动都有 主设备号 从设备号
      • 主设备号: 类型---从内核中找到对应cdev对象链表
      • 从设备号 : 该类型下具体哪个 设备
  •  
没有更多推荐了,返回首页