am335x gpio 控制的另一种方法

#include <linux/gpio.h>  
#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/moduleparam.h>  
#include <linux/delay.h>  
#include <linux/types.h>  
#include <linux/cdev.h>  
#include <linux/device.h>  
#include <linux/fs.h>  
#include <linux/init.h>  
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/slab.h>

/*-----------------------------------------------------*/
#define DEVICE_NAME        "kio"
#define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))
/*------------------------------------------------------*/

struct gpio_qset;

/*设备编号存储结构体*/
struct dev_num
{
        dev_t devNum;
        unsigned int major;
        unsigned int minor;
        unsigned int minor_first;
        unsigned int count;
};
struct dev_num gpio_dev_num;

/*设备描述结构体*/
struct gpio_dev
{
        struct cdev cdev;
        struct gpio_qset* dptr;    //设备数据存储链表第一项
        unsigned long size;        //链表长度(随着申请的GPIO端口数增长)
};
struct gpio_dev *gpio_devp;

/*设备数据存储结构体(采用链式存储,不理解的可以看《数据结构》)*/
struct gpio_qset
{
        unsigned long port;            //端口号 #define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))
        unsigned int ddr;              //方向（输入(0)或输出(1)）
        char value;                    //高(1)低(0)电平
        unsigned long num;             //当前编号(按照申请顺序编号)
        char label[10];                //申请的GPIO使用名称
        struct gpio_qset* next;        //指向链表下一项的指针
};

/**
 * 功能:初始化gpio_dev
 * *inode:
 * *filp:
 * 描述:用户空间调用open时运行
 *         int (*open) (struct inode *, struct file *);
 * 返回值:0
 */
static int gpio_open(struct inode *inode, struct file *filp)
{
        struct gpio_dev *dev;
        
        //由container_of获得结构体指针inode中结构体cdev的指针，
        //让结构体指针dev指向上述的指针所指的地址，
        //再让file->private指向这一地址，
        dev = container_of(inode->i_cdev, struct gpio_dev, cdev);
        filp->private_data = dev;
        dev->dptr = NULL;
        dev->size = 0;
        //printk(KERN_ERR "gpio_open success!\n");
        return 0;
}

/**
 * 功能:释放申请的GPIO端口以及释放链表(gpio_qset)
 * *inode:
 * *filp:
 * 描述:用户空间调用close时运行
 *         int (*release) (struct inode *, struct file *);
 * 返回值:0
 */
static int gpio_close(struct inode *inode, struct file *filp)
{
        struct gpio_dev *dev = filp->private_data;
        struct gpio_qset *qset, *qsetTmp;
        qsetTmp = (struct gpio_qset *)kzalloc(sizeof(struct gpio_qset), GFP_KERNEL);
        for(qset = dev->dptr; qset->next !=NULL; qset=qsetTmp)
        {
                qsetTmp = qset->next;
                gpio_free(qset->port);        //释放申请的端口
                kfree(qset);                //释放gpio_qset内存
        }
        gpio_free(qsetTmp->port);
        kfree(qsetTmp);
         //printk(KERN_ERR "gpio release!\n");
        return 0;
}

/**
 * 功能:申请新的gpio_qset的内存，确定相应的GPIO端口功能
 * *inode:
 * *filp:
 * cmd:实现的功能，
 *     0：读，
 *     1：写，
 *     2：释放GPIO端口
 * arg:执行操作的GPIO端口
 * 描述:用户空间调用ioctl时运行
 *         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
 * 返回值:成功返回操作的GPIO端口号
 *           错误返回相应的错误码
 */
static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
        int ret;
        struct gpio_dev *dev = filp->private_data;
        struct gpio_qset *qset;

//cmd == 2 设计成为释放arg端口的功能，之后申请内存的任务便不必执行了，所以直接返回
        if(cmd == 2)
        {
                gpio_free(arg);
                return arg;
        }

dev->size++;

if(dev->dptr == NULL)
        {
                dev->dptr = (struct gpio_qset *)kzalloc(sizeof(struct gpio_qset), GFP_KERNEL);
                qset = dev->dptr;
        }
        else
        {
                for(qset = dev->dptr; qset->next != NULL; qset = qset->next);                        //找到链表最后一项
                qset->next = (struct gpio_qset *)kzalloc(sizeof(struct gpio_qset), GFP_KERNEL);
                qset = qset->next;
        }
        /*链表数据*/
        qset->num = dev->size;        //确定自己的编号
        qset->ddr = cmd;              //确定方向
        qset->port = arg;             //确定端口号
        qset->next = NULL;            //最后一项地址清空

//printk(KERN_ERR "qset->num=%d,qset->ddr=%d,qset->port=%d\n", qset->num, qset->ddr, qset->port);
        sprintf(qset->label, "gpio%ld", qset->port);                //确定申请的GPIO使用名称(和端口直接相关)
        ret = gpio_request(qset->port, qset->label);                //申请端口
        
        /*由于gpio_requset会自己判断成功与否并且退出函数，故注释掉对ret的判断
        if(ret < 0)
                printk(KERN_ERR "%s_requset failled!%d \n", qset->label, ret);
        */

/*判断GPIO工作方向(输出或输出)*/        
        switch(qset->ddr)
        {
                case 0:        
                    ret = gpio_direction_input(qset->port);
                    if(ret < 0)
                        printk(KERN_ERR "gpio_direction_input failled!\n");
                break;
                
                case 1:        
                    ret = gpio_direction_output(qset->port, 1);
                    if(ret < 0)
                        printk(KERN_ERR "gpio_direction_output failled!\n");
                break;
                
                default:
                        return -EPERM;        /* Operation not permitted */
        }
        return qset->num;
}

/**
 * 功能:获取相应端口电平，写入相应的qset_dev->value，写到用户空间的readBuf
 * *inode:
 * *filp:
 * *readBuf:读数据缓存指针，用户空间的指针
 * port:被读取的GPIO端口号
 * *offp:
 * 描述:用户空间调用read时运行
 *         ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
 * 返回值:成功返回qset->value
 *           错误返回相应的错误码
 */
static ssize_t gpio_read (struct file *filp, char __user *readBuf, size_t port, loff_t *offp)
{
        long ret;
        struct gpio_dev *dev = filp->private_data;
        struct gpio_qset *qset;
        
        if(dev->dptr == NULL)        
                return -ENODEV;                /* No such device */
                        
        for(qset = dev->dptr; qset != NULL; qset = qset->next)
        {
                if(qset->port == port)
                        break;
                if(qset->next == NULL)        
                        return -ENODEV;        /* No such device */
        }

if(qset->ddr != 0)                //判断是否ioctl设置为读操作
                return -EPERM;                /* Operation not permitted */
        qset->value = gpio_get_value(qset->port);
        //printk(KERN_ERR "qset->port:%d, qset->value:%d\n", qset->port, qset->value);
        switch(qset->value)
        {
                case 0:        
                    ret = copy_to_user(readBuf, "0", 1);
                break;
                
                case 1:        
                    ret = copy_to_user(readBuf, "1", 1);
                break;
        }
        return qset->value;
}
/**
 * 功能:写入相应端口电平，写入相应的qset_dev->value，数据来自用户空间的writeBuf
 * *inode:
 * *filp:
 * *writeBuf:写数据缓存指针，用户空间的指针
 * port:被写入的GPIO端口号
 * *offp:
 * 描述:用户空间调用write时运行
 *         ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
 * 返回值:成功返回qset->value
 *           错误返回相应的错误码
 */
static ssize_t gpio_write (struct file *filp, const char __user *writeBuf, size_t port, loff_t *offp)
{
        long ret;
        struct gpio_dev *dev = filp->private_data;
        struct gpio_qset *qset;

if(dev->dptr == NULL)        
                return -ENODEV;                /* No such device */
                        
        for(qset = dev->dptr; qset != NULL; qset = qset->next)
        {
        //        printk(KERN_ERR "qset->port=%d,port=%d\n", qset->port, port);
                if(qset->port == port)
                        break;
                if(qset->next == NULL)        
                        return -ENODEV;        /* No such device */
        }

if(qset->ddr != 1)                //判断是否ioctl设置为写操作
                return -EPERM;                /* Operation not permitted */

ret = copy_from_user(&qset->value, writeBuf, 1);
        //printk(KERN_ERR "write:%d\n", qset->value);
        switch(qset->value)
        {
                case ‘0‘: qset->value = 0;
                          gpio_set_value(qset->port, 0);
                          break;
                default : qset->value = 1;
                          gpio_set_value(qset->port, 1);
                          break;
        }
        return qset->value;
}

/*文件操作结构体*/
static const struct file_operations gpio_fops = {
        .owner = THIS_MODULE,
        .open = gpio_open,
        .unlocked_ioctl = gpio_ioctl,
        .write = gpio_write,
        .read = gpio_read,
        .release = gpio_close,
};

/*cdev注册函数*/
static void gpio_setup_cdev(struct gpio_dev *dev, int index)
{
        int ret,devno = gpio_dev_num.devNum + index;
        cdev_init(&dev->cdev, &gpio_fops);
        dev->cdev.owner = THIS_MODULE;
        dev->cdev.ops = &gpio_fops;

ret = cdev_add(&dev->cdev, devno, 1);

if(ret)
                printk(KERN_ERR "error %d : adding gpioCtl%d",ret,index);
}

static struct class   *kio_class;

/*设备初始化函数*/
static int __init omap2gpio_init(void)
{
        int ret;

gpio_dev_num.count = 1;
        gpio_dev_num.minor_first = 0;
        
        ret = alloc_chrdev_region(&gpio_dev_num.devNum,
                gpio_dev_num.minor_first,
                gpio_dev_num.count,
                DEVICE_NAME);
        
        if(ret < 0)        
                return ret;
        
        gpio_dev_num.major = MAJOR(gpio_dev_num.devNum);
        gpio_dev_num.minor = MINOR(gpio_dev_num.devNum);

gpio_devp = kzalloc(sizeof(struct gpio_dev),GFP_KERNEL);

gpio_setup_cdev(gpio_devp, 0);

printk(KERN_ERR "gpio alloc_chrdev_region success, major = %d\n",
                gpio_dev_num.major);
        
        kio_class = class_create(THIS_MODULE, DEVICE_NAME);
        
        device_create(kio_class, //pointer to the struct class that this device should be registered to
                  NULL,
                  gpio_dev_num.devNum,        //the dev_t for the char device to be added
                  NULL,
                  "%s",
                  DEVICE_NAME);
        return 0;
}

/*设备释放函数*/
static void __exit omap2gpio_exit(void)
{
        cdev_del(&gpio_devp->cdev);
        kfree(gpio_devp);
        unregister_chrdev_region(gpio_dev_num.devNum, 1);
        
        device_destroy(kio_class, gpio_dev_num.devNum);   //the dev_t for the char device to be added
        
        class_destroy(kio_class);
        
        printk(KERN_ERR "gpio unregister_chrdev_region success, major = %d\n",
                gpio_dev_num.major);
}

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Mlo_Lv,Tute-421E-studio");
MODULE_DESCRIPTION("This module is used to conrtol ti omap2 gpio");

module_init(omap2gpio_init);
module_exit(omap2gpio_exit);

时间： 2024-08-28 23:32:55

am335x gpio 控制的另一种方法的相关文章

am335x gpio控制

1.执行下面的命令,可以显示目前驱动已经申请到的IO状态 : $ mount -t debugfs debugfs /sys/kernel/debug  $ cat /sys/kernel/debug/gpio    [email protected]:/# cat /sys/kernel/debug/gpio  GPIOs 0-31, gpio:   gpio-2   (volume-up           ) in  hi   gpio-3   (volume-down         )

iOS之浅谈纯代码控制UIViewController视图控制器跳转界面的几种方法

一.最普通的视图控制器UIViewContoller 一个普通的视图控制器一般只有模态跳转的功能(ipad我不了解除外,这里只说iPhone),这个方法是所有视图控制器对象都可以用的,而实现这种功能,有两种方法. 1.通过方法 - (void)presentViewController:(UIViewController *)viewControllerToPresent animated: (BOOL)flag completion:(void (^)(void))completion跳转 相

【转】VC 多线程中控制界面控件的几种方法

原文网址:https://software.intel.com/zh-cn/blogs/2010/11/30/vc-3 为了保证界面的用户体验经常要把数据处理等放到子线程中进行,然后把结果更新到主界面,通常有这样几种方法. 1. 启动线程时把控件关联变量的指针传参给线程函数,这种方法无疑是最简单的方法,但极容易造成访问异常,因为VC6中的控件都不是线程安全的. 2. 就是先进一点的方法,把控件的句柄传给线程函数,有时也不好用在子线程中通过SendNotifyMessage or PostMess

AE控制图层中要素可见状态的几种方法

转自原文 AE控制图层中要素可见状态的几种方法 工作中常有这样的需求,一个作业图层由几个作业员来操作,我们要 控制每一个作业员只能看到他负责的区域.作业员的可见区域控制有时候是按空间区域划分,有时候是按照作业属性划分,有时候是属性和区域结合来划分,在程序中应该如何控制呢?本人总结了如下几种可用的方法,不知大家是否有更好的解决方案. ?   唯一值符号法 该方法比较简单,就是通过给图层设置一个唯一值符号渲染,把不想显示的要素符号设置为空.虽然简单,这种方法有这很大的局限性,如果我们要控制某一个区域

jquery控制元素的隐藏和显示的几种方法。

组织略显凌乱,请耐心看! 使用jquery控制div的显示与隐藏,一句话就能搞定,例如: 1.$("#id").show()表示为display:block, $("#id").hide()表示为display:none; 2.$("#id").toggle()切换元素的可见状态.如果元素是可见的,切换为隐藏的:如果元素是隐藏的,则切换为可见的. 3.$("#id").css('display','none');//隐藏 $(

CSS控制图片和文字在同一行显示且对齐的3种方法

CSS控制图片和文字在同一行显示且对齐的3种方法 在 HTML 代码中,有时会需要在文字旁边加上一个图标. 默认情况,是图片置顶对齐,文字置底对齐,所以通常图片高,文字低,不能水平居中对齐. 常见方法有3种:1.通过添加css的“vertical-align:middle;”:2.如果图片是背景图片,可以在css中设置背景图片:3.把文字和图片分别放入不同的div中.上面三种方法都可以让图片和文字在同一行显示,下面我们用实例来应用一下. 1.添加上“vertical-align:middle”属

控制导航条最后一个标签样式的三种方法

<!DOCTYPE html><html> <head> <meta charset="UTF-8"> <title>控制导航条最后一个标签样式的三种方法</title> <script src="http://ajax.aspnetcdn.com/ajax/jquery/jquery-2.1.1.min.js"></script> <style> .nav{

Jsp页面跳转和js控制页面跳转的几种方法

Jsp 页面跳转的几种方法 1. RequestDispatcher.forward() 在服务器端起作用,当使用forward()时,Servlet engine传递HTTP请求从当前的Servlet或者是JSP到另外的一个Servlet.JSP 或普通HTML文件,也即你的form提交至a.jsp,在a.jsp用到了forward()重定向至b.jsp,此时form提交的所有信息在 b.jsp都可以获得,参数自动传递. 但forward()无法重定向至有frame的jsp文件,可以重定向至有

Linux 下操作GPIO（两种方法，驱动和mmap）（转载）

目前我所知道的在Linux下操作GPIO有两种方法: 1．编写驱动,这当然要熟悉Linux下驱动的编写方法和技巧,在驱动里可以使用ioremap函数获得GPIO物理基地址指针,然后使用这个指针根据ioctl命令进行GPIO寄存器的读写,并把结果回送到应用层.这里提供一点程序片断供大家参考: int  init_module(void){ printk(KERN_ALERT "ioctl load.\r\n"); register_chrdev(254,"ioreg"