设备驱动基础学习–platform driver简单实现

设备驱动基础学习–platform driver简单实现platform是一条虚拟的总线。设备用platform_device表示,驱动用platform_driver进行注册,Linuxplatformdriver机制和传统的devicedriver机制(通过driver_register进行注册)相比,一个明显的优势在于platform机制将设

大家好,欢迎来到IT知识分享网。

platform是一条虚拟的总线。设备用platform_device表示,驱动用platform_driver进行注册,Linux platform driver机制和传统的device driver机制(通过driver_register进行注册)相比,一个明显的优势在于platform机制将设备本身的资源注册进内核,由内核统一管理,在驱动中使用这些资源时通过platform device提供的标准结构进行申请并使用。这样提高了驱动和资源的独立性,并且具有较好的可移植性和安全性(这些标准接口是安全的)。

pltform机制本身使用并不复杂,由两部分组成:platform_device和platform_driver。通过platform机制开发底层驱动的大致流程为:定义platform_deive->注册platform_device->定义platform_driver->注册platform_driver。

platform driver的probe函数是平台总线实现匹配以后首先被调用的函数,因此在其中实现字符设备、块设备、网络设备驱动的初始化是有意义的,这样的设备驱动就是基于平台总线的设备驱动,便于维护。如果添加实际的设备到该平台总线设备驱动模型中,则可以在该函数中实现具体的设备驱动函数的初始化操作,包括设备号的申请,设备的初始化,添加。自动设备文件创建函数的添加等操作。或者是混杂字符设备的相关初始化操作。在remove函数中实现具体的设备的释放,包括设备的删除,设备号的注销等操作。

基于misc device实现一个简单的platform driver(仿照driver/char/sonypi.c).

fellowplat.h

#ifndef _FELLOW_MISC_H_
#define _FELLOW_MISC_H_
#include <linux/ioctl.h>
//#define FELLOW_MISC_MAJOR 199
//#define FELLOW_MISC_NR 2
struct miscdata {
int val;
char *str;
unsigned int size;
};
#define FELLOW_MISC_IOC_MAGIC ‘f’
#define FELLOW_MISC_IOC_PRINT _IO(FELLOW_MISC_IOC_MAGIC, 1)
#define FELLOW_MISC_IOC_GET _IOR(FELLOW_MISC_IOC_MAGIC, 2, struct miscdata)
#define FELLOW_MISC_IOC_SET _IOW(FELLOW_MISC_IOC_MAGIC, 3, struct miscdata)
#define FELLOW_MISC_IOC_MAXNR 3
#endif

 

fellowplat.c

#include <linux/module.h>
#include <linux/init.h>
//#include <linux/moduleparam.h>
#include <linux/types.h>
#include <linux/miscdevice.h>
#include <linux/platform_device.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include “fellowplat.h”
struct fellowmisc_dev{
struct miscdevice misc;
struct miscdata data;
};
struct fellowmisc_dev *fellowmisc_devp;
int fellowmisc_open(struct inode *inode, struct file *filep)
{
  filep->private_data = fellowmisc_devp;
  return 0;
}
int fellowmisc_release(struct inode *inode, struct file *filep)
{
  return 0;
}

long fellowmisc_ioctl(struct file *filep,unsigned int cmd,unsigned long arg)

{

  int ret = 0;
  struct fellowmisc_dev *devp = (struct fellowmisc_dev *)(filep->private_data);
  if (_IOC_TYPE(cmd) != FELLOW_MISC_IOC_MAGIC)
    return -EINVAL;
  if (_IOC_NR(cmd) > FELLOW_MISC_IOC_MAXNR)
    return -EINVAL;
  switch(cmd)
  {
    case FELLOW_MISC_IOC_PRINT:
      printk(“FELLOW_MISC_IOC_PRINT\n”);
      printk(“val:%d, size: %d, str: %s\n”, devp->data.val, devp->data.size, devp->data.str);
    break;
    case FELLOW_MISC_IOC_SET:
      printk(“FELLOW_MISC_IOC_SET\n”);
      ret = copy_from_user((unsigned char*)&(devp->data), (unsigned char *)arg, sizeof(struct miscdata));
      printk(“set val:%d, size: %d, str: %s\n”, devp->data.val, devp->data.size, devp->data.str);
    break;
    case FELLOW_MISC_IOC_GET:
      printk(“FELLOW_MISC_IOC_GET\n”);
      ret = copy_to_user((unsigned char*)arg,(unsigned char*)&(devp->data), sizeof(struct miscdata));
    break;
    default:
      return -EINVAL;

  }
  return ret;
}
static const struct file_operations fellowmisc_fops ={
.owner = THIS_MODULE,
.open = fellowmisc_open,
.release = fellowmisc_release,
.unlocked_ioctl = fellowmisc_ioctl,
};
static struct miscdevice fellow_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = “fellowplat”,
.fops = &fellowmisc_fops,
};
static struct platform_device *fellow_platform_device;
static int fellow_plat_drv_probe(struct platform_device *dev)
{
  int error;
  printk(“fellow_plat_drv_probe\n”);
  fellowmisc_devp = kmalloc(sizeof(struct fellowmisc_dev), GFP_KERNEL);
  if (!fellowmisc_devp)
  {
    error = -ENOMEM;
    return error;
  }
  memset(&(fellowmisc_devp->data), 0, sizeof(fellowmisc_devp->data));
  fellowmisc_devp->misc = fellow_misc;
  error = misc_register(&fellow_misc);
  return error;
}
static int fellow_plat_drv_remove(struct platform_device *dev)
{
  int error;
  if (fellowmisc_devp)
    kfree(fellowmisc_devp);
  error = misc_deregister(&fellow_misc);
  return error;
}
static struct platform_driver fellow_platform_driver = {
.driver = {
.name = “fellow”,
},
.probe = fellow_plat_drv_probe,
.remove = fellow_plat_drv_remove,
};

static int fellowplat_init(void)
{
  int error;
  printk(“fellowplat_init\n”);
  printk(“fellow register driver\n”);
  error = platform_driver_register(&fellow_platform_driver);//注册platform driver
  if (error)
    return error;

  fellow_platform_device = platform_device_alloc(“fellow”, -1);//名字与platform driver相同。
  if (!fellow_platform_device) {
    error = -ENOMEM;
    goto err_driver_unregister;
  }

  printk(“fellow register device\n”);
  error = platform_device_add(fellow_platform_device);//添加platform device
  if (error)
    goto err_free_device;

  return 0;

err_free_device:
  platform_device_put(fellow_platform_device);
err_driver_unregister:
  platform_driver_unregister(&fellow_platform_driver);
  return error;
}

static void fellowplat_exit(void)
{
  platform_device_unregister(fellow_platform_device);
  platform_driver_unregister(&fellow_platform_driver);
}

MODULE_AUTHOR(“fellow”);
MODULE_LICENSE(“GPL”);
module_init(fellowplat_init);
module_exit(fellowplat_exit);

 

app.c

#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include “fellowplat.h”
int main(void)
{
  int fd = open(“/dev/fellowplat”, O_RDWR);
  if (fd < 0)
  {
    printf(“open fail:%s\n”, strerror(errno));
    return -1;
  }
  int ret = 0;
  struct miscdata data;
  data.val = 18;
  data.str = “fellow platform device”;
  data.size = sizeof(“fellow platform device”);
  if ((ret = ioctl(fd, FELLOW_MISC_IOC_SET, &data)) < 0)
  {
    printf(“ioctl set fail:%s\n”, strerror(errno));
  }
  struct miscdata getdata;
  if ((ret = ioctl(fd, FELLOW_MISC_IOC_GET, &getdata)) < 0)
  {
    printf(“ioctl get fail:%s\n”, strerror(errno));
  }
  printf(“get val:%d, str:%s, size: %d\n”, getdata.val, getdata.str, getdata.size);
  if ((ret = ioctl(fd, FELLOW_MISC_IOC_PRINT, NULL)) < 0)
  {
    printf(“ioctl print fail:%s\n”, strerror(errno));
  }
  close(fd);
  return ret;
}

运行结果如下

设备驱动基础学习--platform driver简单实现

 

免责声明:本站所有文章内容,图片,视频等均是来源于用户投稿和互联网及文摘转载整编而成,不代表本站观点,不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益,请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权,请联系删除,如若转载,请注明出处:https://yundeesoft.com/35042.html

(0)

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注

关注微信