gpio驱动

最新推荐文章于 2023-09-14 14:03:10 发布
最新推荐文章于 2023-09-14 14:03:10 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： 驱动 工作 文章标签： gpio gpio驱动 gpio中断 高通
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/onetwothreef/article/details/49977717
版权

  通过gpiolib标准库，实现gpio功能，如读写，中断。gpio产生中断后，kernel向进程发送一个SIGUSR1信号。可以供大家参考。

my_gpio.h

#define QL_RET_ERR_GPIO_UNREG		-11	/* pin not register or not register for GPIO */

#define QL_RET_ERR_KERNEL		-100      /* there are some error occured in kernel */
#define QL_RET_ERR_KERNEL_NOMEM		-101	/* no memory in kernel */
#define QL_RET_ERR_NOIOCTLCMD		-515	/* no ioctl command */

/*
* checek gpio reuslt Macro
*/

#define GPIO_INVAILID	0x01
#define GPIO_INUSE	0x02
#define	GPIO_UNUSE	0x03

/*
* gpio direction Macro
*/

#define GPIO_DIR_OUT	1
#define GPIO_DIR_IN	0


typedef struct {
	unsigned int gpio;	// gpio number
	pid_t	userpid;	// user process id
}quectel_gpio_reg_info;


typedef struct {
	unsigned int gpio;	// gpio number
	unsigned int dir;	// 1:out  0:in
	unsigned int value;	// pin level
}quectel_gpio_config;

struct list_irq_info_node
{
	pid_t userpid;
	unsigned int gpio;
	int irq;
	unsigned dir;
	struct list_head list;
};

struct key_value
{
	unsigned int key;
	unsigned int value;
};

struct list_irq_info_node infohead;  // for user register int and user pid


#endif


my_gpio.c

/* Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */
/*
 * My gpio driver
 *
 */
#include <linux/init.h>
#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/pid.h>
#include <linux/signal.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <asm/atomic.h>
#include <linux/gpio.h>
#include <linux/sched.h>
#include <linux/string.h>
//#include <linux/spinlock.h>
//#include <linux/workqueue.h>




#include "my_gpio.h"

#define DEVICE_NAME	"quectel_gpio"

dev_t gpio_dev_num;
struct cdev gpio_dev;
static struct class *gpio_class;

#if 0
static int quectel_gpio_open(struct inode *inode, struct file *file)
{
		
	printk("%s: gpio open\n",__func__);
	try_module_get(THIS_MODULE);
	return 0;
}

static int release()
{
	printk("%s: gpio_release!\n", __func__);
	module_put(THIS_MODULE);
	return 0;
}

#endif


static struct list_irq_info_node * find_gpio_in_list(unsigned gpio)
{
	struct list_irq_info_node *p;
	struct list_head * pos;
	list_for_each(pos, &infohead.list)
	{
		p = list_entry(pos, struct list_irq_info_node, list);
		if(p->gpio == gpio)
		{
			return p;
		}
	}
	return NULL;
}

static pid_t find_pid_by_irq(int irq)
{
	pid_t pid = -1;
	struct list_irq_info_node *p;
	struct list_head * pos;
	list_for_each(pos, &infohead.list)
	{
		p = list_entry(pos, struct list_irq_info_node, list);
		if(p->irq == irq)
		{
			return p->userpid;
		}
	}	
	
	return pid;
}
static int check_gpio(unsigned int gpio)
{
	//int ret = 0;
	if(!gpio_is_valid(gpio))
	{
		printk("%s:%d gpio_is_valid failed!\n", __func__, __LINE__);
		return GPIO_INVAILID;
	}
	if(find_gpio_in_list(gpio) == NULL)
		return GPIO_UNUSE;
	else
		return GPIO_INUSE;
}
static irqreturn_t irqHandler(int irq, void*dev_id)
{
	pid_t pid = -1;
	struct task_struct *p = NULL;
	//gpio = irq_to_gpio(irq);
	pid = find_pid_by_irq(irq);
	printk("%s:%d get a irq=%d  pid=%d\n", __func__, __LINE__, irq, pid);
	if(pid<0)
	{
		printk("%s:%d get pid failed!\n", __func__, __LINE__);
		return IRQ_NONE;
	}
	p = pid_task(find_vpid(pid), PIDTYPE_PID);
	if(NULL == p)
	{
		printk("%s:%d get task struct for pid:%d Failed!\n",__func__, __LINE__, pid);
		return IRQ_NONE;
	}
	if(send_sig(SIGUSR1, p, 0))
	{
		printk("%s:%d send_sig to pid:%d failed!\n", __func__, __LINE__, pid);
	}
	return IRQ_HANDLED;
}

static long register_gpio_irq_from_user(quectel_gpio_reg_info info)
{
	int err;
	int irq;
	struct list_irq_info_node *infonode;
	
	err = 	check_gpio(info.gpio);
	if(GPIO_INVAILID == err)
		return QL_RET_ERR_NOSUPPORTPIN;
	else if(GPIO_INUSE == err)
		return QL_RET_ERR_PINALREADYSUBCRIBE;
	
	err = gpio_request( info.gpio,"qgpio");
	if(err<0)
	{
		printk("%s:%d gpio_request %d error %d!\n",__func__, __LINE__, info.gpio, err);
		return QL_RET_ERR_KERNEL;
	}
	err = gpio_direction_input(info.gpio);
	if(err<0)
	{
		printk("%s:%d gpio_direction_input %d error %d!\n",__func__, __LINE__, info.gpio, err);
		gpio_free(info.gpio);
		return QL_RET_ERR_KERNEL;
	}
	err = gpio_to_irq(info.gpio);
	if(err<0)
	{
		printk("%s:%d gpio_to_irq %d error %d!\n",__func__, __LINE__, info.gpio, err);
		gpio_free(info.gpio);
		return QL_RET_ERR_KERNEL;
	}
	irq = err;
	printk("%s:%d gpio=%d irq=%d \n", __func__, __LINE__, info.gpio, irq);
	err = request_irq(irq, irqHandler, IRQF_TRIGGER_FALLING, DEVICE_NAME, NULL);
	if(err < 0)
	{
		printk("%s:%d request_irq %d error %d!\n",__func__, __LINE__, info.gpio, err);
		gpio_free(info.gpio);
		return QL_RET_ERR_KERNEL;
	}

	// add irq info node to list
	//printk("%s:%d add info to list gpio=%d userpid=%d!\n",__func__, __LINE__, info.gpio, info.userpid);
	infonode = (struct list_irq_info_node *)kmalloc(sizeof(struct list_irq_info_node), GFP_KERNEL);
	if(NULL == infonode)
	{
		printk("%s:%d kmalloc failed!\n",__func__, __LINE__);
		gpio_free(info.gpio);
		free_irq(irq, (void*)0);
		return QL_RET_ERR_KERNEL_NOMEM;
	}
	infonode->gpio = info.gpio;
	infonode->userpid = info.userpid;
	infonode->irq = irq;
	infonode->dir = GPIO_DIR_IN;
	list_add_tail(&infonode->list, &infohead.list);	
	
	
	return 0;	
	
}

static long release_gpio_irq_from_user(unsigned int gpio)
{
	struct list_head * pos, *n;
	struct list_irq_info_node * p = NULL;
	
	// move gpio irq info node to list
	list_for_each_safe(pos, n, &infohead.list)
	{
		
		p = list_entry(pos, struct list_irq_info_node, list);
		if(p->gpio == gpio && p->irq >0)
		{
			
			free_irq(p->irq,(void*)0);
			gpio_free(gpio);
			//disable_irq_wake(p->irq);
			list_del(pos);
			kfree(p);
			return 0;
		}
	}
	return QL_RET_ERR_EINT_UNREG;
}



static long request_gpio_func(unsigned int gpio)
{
	//long ret;
	int err;
	char lable[8] = {0};
	struct list_irq_info_node *infonode;	
	
	err = check_gpio(gpio);
	if(GPIO_INVAILID == err)
		return QL_RET_ERR_NOSUPPORTPIN;
	else if(GPIO_INUSE == gpio)
		return QL_RET_ERR_PINALREADYSUBCRIBE;

	sprintf(lable, "qgpio%u", gpio);
	err = gpio_request(gpio, lable);
	if(err<0)
	{
		printk("%s:%d gpio_request %d error %d!\n",__func__, __LINE__, gpio, err);
		return QL_RET_ERR_PINALREADYSUBCRIBE;
	}
	
	// add gpio info node to list
	printk("%s:%d add info to list gpio=%d!\n",__func__, __LINE__, gpio);
	infonode = (struct list_irq_info_node *)kmalloc(sizeof(struct list_irq_info_node), GFP_KERNEL);
	if(NULL == infonode)
	{
		printk("%s:%d kmalloc failed!\n",__func__, __LINE__);
		gpio_free(gpio);
		return QL_RET_ERR_KERNEL_NOMEM;
	}
	infonode->gpio = gpio;
	infonode->userpid = -1;
	infonode->irq = -1;
	infonode->dir = 0;
	list_add_tail(&infonode->list, &infohead.list);		
	
	return 0;
	
}

static long release_gpio_func(unsigned int gpio)
{
	//long ret;
	// int err;
	struct list_head * pos, *n;
	struct list_irq_info_node * p = NULL;
	
	// move gpio info node to list
	list_for_each_safe(pos, n, &infohead.list)
	{
		
		p = list_entry(pos, struct list_irq_info_node, list);
		if(p->gpio == gpio && p->irq<0)
		{
			gpio_free(gpio);
			list_del(pos);
			kfree(p);
			return 0;
		}
	}	
	
	return QL_RET_ERR_GPIO_UNREG;	
}


static long init_gpio_func(quectel_gpio_config gpioconf)
{
	int err;
	/* request gpio */
	char lable[8] = {0};
	struct list_irq_info_node *infonode;	
	
	err = check_gpio(gpioconf.gpio);
	if(GPIO_INVAILID == err)
		return QL_RET_ERR_NOSUPPORTPIN;
	else if(GPIO_INUSE == err)
		return QL_RET_ERR_PINALREADYSUBCRIBE;

	sprintf(lable, "qgpio%u", gpioconf.gpio);
	err = gpio_request(gpioconf.gpio, lable);
	if(err<0)
	{
		printk("%s:%d gpio_request %d error %d!\n",__func__, __LINE__, gpioconf.gpio, err);
		return QL_RET_ERR_KERNEL;
	}
	
	// add gpio info node to list
	printk("%s:%d add info to list gpio=%d!\n",__func__, __LINE__, gpioconf.gpio);
	infonode = (struct list_irq_info_node *)kmalloc(sizeof(struct list_irq_info_node), GFP_KERNEL);
	if(NULL == infonode)
	{
		printk("%s:%d kmalloc failed!\n",__func__, __LINE__);
		gpio_free(gpioconf.gpio);
		return QL_RET_ERR_KERNEL_NOMEM;
	}
	infonode->gpio = gpioconf.gpio;
	infonode->userpid = -1;
	infonode->irq = -1;
	infonode->dir = gpioconf.dir;
	list_add_tail(&infonode->list, &infohead.list);	
	
	/* set gpio direction */
	if( GPIO_DIR_IN == gpioconf.dir) /* gpio input */
	{
		if((err = gpio_direction_input(gpioconf.gpio))<0)
		{
			release_gpio_func(gpioconf.gpio);
			printk("%s:%d gpio_direction_input failed!\n",__func__, __LINE__);
			return QL_RET_ERR_KERNEL;
		}
	}
	else /* gpio output */
	{
		if((err = gpio_direction_output(gpioconf.gpio, gpioconf.value))<0)
		{
			release_gpio_func(gpioconf.gpio);
			printk("%s:%d gpio_direction_output failed!\n",__func__, __LINE__);
			return QL_RET_ERR_KERNEL;
		}
		
	}
	/* set level */
	gpio_set_value(gpioconf.gpio, gpioconf.value);
	
	return 0;
	
}
static long quectel_gpio_set_dir(unsigned int gpio, unsigned int dir)
{
	struct list_irq_info_node *p;
	long err;
	if((p=find_gpio_in_list(gpio)) == NULL)
	{
		return QL_RET_ERR_GPIO_UNREG;
	}
	p->dir = dir;
	if( GPIO_DIR_IN == dir) /* gpio input */
	{
		if((err = gpio_direction_input(gpio))<0)
		{
			// release_gpio_func(gpio);
			return -1;
		}
		
	}
	else /* gpio output */
	{
		if((err = gpio_direction_output(gpio, 1))<0)
		{
			// release_gpio_func(gpio);
			return -1;
		}
		
	}
	return 0;
}

static long quectel_gpio_get_conf(quectel_gpio_config * gpioconf)
{
	struct list_irq_info_node * p;
	if( (p=find_gpio_in_list(gpioconf->gpio)) == NULL)
	{
		return QL_RET_ERR_GPIO_UNREG;
	}
	gpioconf->dir = p->dir;
	gpioconf->value = gpio_get_value(gpioconf->gpio);
	return 0;
}
static long quectel_get_gpio_dir(struct key_value *kvalue)
{
	struct list_irq_info_node * p;
	if( (p=find_gpio_in_list(kvalue->key)) == NULL)
	{
		return QL_RET_ERR_GPIO_UNREG;
	}
	kvalue->value = p->dir;
	return 0;
}
static long quectel_gpio_get_value(struct key_value *kvalue)
{
	if( find_gpio_in_list(kvalue->key) == NULL)
	{
		return QL_RET_ERR_GPIO_UNREG;
	}
	kvalue->value = gpio_get_value(kvalue->key);
	return 0;
}

static long quectel_gpio_set_value(struct key_value kvalue)
{
	struct list_irq_info_node * p;
	if( (p=find_gpio_in_list(kvalue.key)) == NULL)
	{
		return QL_RET_ERR_GPIO_UNREG;
	}
	gpio_set_value(kvalue.key, kvalue.value);
	return 0;
}

static long quectel_gpio_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)  
{
	long ret;
	quectel_gpio_reg_info info;
	quectel_gpio_config gpioconf;
	unsigned int gpio;
	struct key_value kvalue;
	switch(cmd)
	{
		case QUECTEL_GPIO_REQ: /* get unsigned int gpio */
			if(copy_from_user(&gpio, (unsigned int *)arg, sizeof(gpio)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}
			return request_gpio_func(gpio);
			break;
		case QUECTEL_GPIO_INIT: /* get quectel_gpio_config gpioconf */
			if(copy_from_user(&gpioconf, (quectel_gpio_config *)arg, sizeof(gpioconf)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}
			return init_gpio_func(gpioconf);
			break;
		case QUECTEL_GPIO_RELEASE:
			if(copy_from_user(&gpio, (unsigned int *)arg, sizeof(gpio)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}
			return release_gpio_func(gpio);
			break;

		case QUECTEL_GPIO_GET_DIR:
			if(copy_from_user(&kvalue, (struct key_value *)arg, sizeof(kvalue)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}			
			ret = quectel_get_gpio_dir(&kvalue);
			if(ret)
			{
				return ret;
			}
			if(copy_to_user((struct key_value *)arg, &kvalue, sizeof(kvalue)))
			{
				printk("%s:%d copy_to_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}			
			return 0;
			break;
		case QUECTEL_GPIO_SET_DIR_IN:
			if(copy_from_user(&gpio, (unsigned int *)arg, sizeof(gpio)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}
			return quectel_gpio_set_dir(gpio, GPIO_DIR_IN);
			break;
		case QUECTEL_GPIO_SET_DIR_OUT:
			if(copy_from_user(&gpio, (unsigned int *)arg, sizeof(gpio)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}
			return quectel_gpio_set_dir(gpio, GPIO_DIR_OUT);
			break;
		case QUECTEL_GPIO_READ:
		case QUECTEL_GPIO_GET_CONF:
			if(copy_from_user(&gpioconf, (quectel_gpio_config *)arg, sizeof(gpioconf)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}
			ret = quectel_gpio_get_conf(&gpioconf);
			if(ret)
			{
				return ret;
			}
			if(copy_to_user((quectel_gpio_config *)arg, &gpioconf, sizeof(gpioconf)))
			{
				printk("%s:%d copy_to_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}			
			return 0;
			break;
		case QUECTEL_GPIO_GET_VALUE:
			if(copy_from_user(&kvalue, (struct key_value *)arg, sizeof(kvalue)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}			
			ret = quectel_gpio_get_value(&kvalue);
			if(ret)
			{
				return ret;
			}
			if(copy_to_user((struct key_value *)arg, &kvalue, sizeof(kvalue)))
			{
				printk("%s:%d copy_to_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}			
			return 0;
			break;
		case QUECTEL_GPIO_SET_VALUE:
			if(copy_from_user(&kvalue, (struct key_value *)arg, sizeof(kvalue)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}
			return quectel_gpio_set_value(kvalue);
			break;
		/* for gpio interrupts */
		case QUECTEL_GPIO_REG_IRQ:
			if(copy_from_user(&info, (quectel_gpio_reg_info *)arg, sizeof(info)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}
			return register_gpio_irq_from_user(info);
			break;
		case QUECTEL_GPIO_REL_IRQ:
			if(copy_from_user(&gpio, (unsigned int *)arg, sizeof(gpio)))
			{
				printk("%s:%d copy_from_user error!\n",__func__, __LINE__);
				return QL_RET_ERR_KERNEL;
			}
			return release_gpio_irq_from_user(gpio);
			break;		
		
		default:
			return QL_RET_ERR_NOIOCTLCMD;		
	}
	return QL_RET_OK;
}

struct file_operations quectel_gpio_fops =
{
	.owner = THIS_MODULE,
	.unlocked_ioctl  = quectel_gpio_unlocked_ioctl,
//	.open = quectel_gpio_open,
//	.release = quectel_gpio_release,
};

static int __init quectel_gpio_init(void)
{
	int ret;
	printk("%s:in gpio driver\n",__func__);
	ret = alloc_chrdev_region(&gpio_dev_num, 0, 1, DEVICE_NAME);
	
	if(ret < 0)
	{
		printk("%s:alloc_chrdev_region error!\n", __func__);
		goto err_alloc_chardev;
	}
	
	cdev_init(&gpio_dev, &quectel_gpio_fops);
	ret = cdev_add(&gpio_dev, gpio_dev_num, 1);
	if(ret)
	{
		printk("%s: cdev_add error!\n", __func__);
		goto err_register_chrdev;
	}
	
	gpio_class = class_create(THIS_MODULE, DEVICE_NAME);
	if (IS_ERR(gpio_class))
	{
		printk("%s:%d Err:failed in creating class.\n",__func__, __LINE__);
		goto err_register_chrdev;
	}
	device_create(gpio_class, NULL, gpio_dev_num, NULL, "%s", DEVICE_NAME);
	// init list.
	INIT_LIST_HEAD(&infohead.list);
	
	return 0;

err_register_chrdev:
	unregister_chrdev_region(gpio_dev_num, 1);

err_alloc_chardev:
	return ret;
}

static void __exit quectel_gpio_cleanup(void)
{
	struct list_head * pos, *n;
	struct list_irq_info_node * p = NULL;
	cdev_del(&gpio_dev);
	device_destroy(gpio_class, gpio_dev_num);
	class_destroy(gpio_class);
	unregister_chrdev_region(gpio_dev_num, 1);
	
	// release list
	list_for_each_safe(pos, n, &infohead.list)
	{
		list_del(pos);
		p = list_entry(pos, struct list_irq_info_node, list);
		if(p->gpio>=0)
		{
			gpio_free(p->gpio);
		}
		if(p->irq>0)
		{
			free_irq(p->irq, (void*)0);
			//disable_irq_wake(p->irq);
		}
		kfree(p);
	}
	return;
}



module_init(quectel_gpio_init);
module_exit(quectel_gpio_cleanup);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("QUECTEL GPIO driver");
MODULE_VERSION("1.0");
MODULE_ALIAS("sam.wu@quectel.com");





飞翔到天边
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
gpio驱动程序.zip
05-25
飞凌IMX6 gpio 驱动源码，采用platform设备驱动模型，适用于带设备树的内核版本，内含测试程序，已经自测可用。
LINUX驱动之——GPIO的基本驱动
zzzzzz_9的博客
02-26 4043
Linux 驱动开发之GPIO
GPIO以及引脚(pin)的驱动能力
qq_45519101的博客
05-06 3102
3）I/O驱动能力的差异来源于MOS管自身的特性，要想过电流能力大，MOS管体积就要大，芯片所需的面积就会更大，成本自然也会更高。道理同上，流过N-MOS电流越大，N-MOS产生压降越大，I/O口电压越大。当电压达到逻辑0的最高电压Vol时，这时的电流就表示驱动能力。2）如果某I/O的驱动能力是5mA，并不是表示它输出不了超过5mA的电流，只是当输出电流超过5mA之后，它的输出电压会下降，电压会小于Voh。当输出高电平1时，I/O内部VDD经过PMOS流向I/O引脚，如下图红色箭头所示，
linux设备驱动程序——gpio控制
m0_74282605的博客
07-05 3657
在gpio初始化的函数中添加这个接口，在加载完成之后查看/sys/class/gpio/目录下是否有相应的gpio$num(这里是gpio26)文件(需要注意的是，在上例中，当用户程序打开设备时才进行gpio的初始化，关闭文件时释放gpio的资源，所以需要打开文件再操作)。当用户程序执行时，用户程序一直获取用户的输入，根据用户输入"on"或者"off"，然后将其写入设备文件，触发系统调用，设备文件根据设备号找到内核中相应的file_operation结构体，相应write函数被调用，执行相应的点灯操作。
【LINUX驱动框架学习】Linux GPIO驱动以及底层实现方式
yy197696的博客
04-02 4176
GPIO（通用目的输入/输出端口）是一种灵活的软件控制的数字信号。大多数的嵌入式 处理器都引出一组或多组的 GPIO，并且部分普通管脚通过配置可以复用为 GPIO。利用可 编程逻辑器件，或总线（如 I 2 C、SPI）转 GPIO 芯片，也可以扩展系统的 GPIO。不管是何 种 GPIO，GPIOLIB 为内核和用户层都提供了标准的操作方法。 GPIOLIB 的接口十分简洁。在 GPIOLIB，所有的 GPIO 都是用整形的 GPIO 编号标识。 只要获得要操作 GPIO 的编号，就可以调用 GPIOLIB
【gpio_key按键驱动】
Sugar_wolf的博客
07-01 1850
【gpio_key按键驱动】
GPIO驱动LED
06-06
GPIO驱动LED
WINCE6 GPIO 驱动
04-08
WINCE6 GPIO 驱动，他是一个用WINCE gpio控制设备外围引脚高低的驱动程序，为流驱动 WINCE6 GPIO 驱动，他是一个用WINCE gpio控制设备外围引脚高低的驱动程序，为流驱动
liunux gpio驱动
06-22
在arm架构下，在linux系统下，利用系统提供的gpio接口函数，实现关于gpio操作的驱动
海思GPIO驱动程序
07-02
海思GPIO驱动程序，通过操作海思驱动设备，既可以控制海思的设备GPIO；
＜＜RT_Thread gd450 学习 ＞＞ 二. drv_gpio
m0_47226014的博客
07-22 536
GD450z 开发板 drv_gpio驱动 修改SConscript 解决默认工程添加文件后保存配置消失问题， drv_gpio 使用流水灯demo
一个常用的gpio驱动
上官绝痕的专栏
05-20 1231
分享一个gpio驱动，其中使用了gpio、pinctrl、irq、workqueue、input等知识，代码中有较详细的注释，不时可以来瞅一瞅！ 首先设备树中如下配置： &pio { touchsensor_pins_tp_int10: eint@10 { pins_cmd_dat { pins = <MT8163_PIN_32_EINT10__FUNC_GPIO32>; slew-rate = <0>; bias-disable; }; };
linux内核中的GPIO系统之（1）：软件框架
wjs1033的专栏
01-06 1517
一、前言 作为一个工作多年的系统工程师，免不了做两件事情：培训新员工和给新员工分配任务。对于那些刚刚从学校出来的学生，一般在开始的时候总是分配一些非常简单的任务，例如GPIO driver、LED driver。往往CPU datasheet的关于GPIO或者IO ports的章节都是比较简单的，非常适合刚入行的工程师。虽然GPIO子系统相关的硬件比较简单，没有复杂的协议，不过，对于软件抽象
GPIO驱动概念-学习笔记
最新发布
qq_52495812的博客
09-14 157
Linux 驱动层gpio调用_乡棒的博客-CSDN博客注：有点API以devm_开头，内核会有自动回收机制，因此在错误处理时会自动回收资源。
Linux内核的GPIO子系统驱动框架详解以及基于pinctrl和gpio子系统的LED驱动程序
cumtchw
09-06 1754
上图就是gpio子系统的层次结构图，在其他的驱动程序里面，我们可以直接用gpiod_set_value这种函数来设置引脚的值，这个函数是在gpio库里面定义的，gpio库起到一个承上启下的作用，然后这个gpiod_set_value函数最终调用的是chip->set(chip, gpio_chip_hwgpio(desc), value)函数，这里的chip就是在gpio驱动程序里面注册的结构体，这个结构体体里面就包含了一些对gpio的操作函数。base // 这个GPIO控制器的GPIO编号。
设备树中的GPIO
qq_18737805的博客
01-27 7824
  涉及到的GPIO驱动基于linux-4.14，soc是全志H3，平台是nanopi-m1， linux中关于GPIO控制是通过GPIOLIB实现的，相关主要API如下： #include &lt;linux/gpio.h&gt; //GPIO操作相关接口 int gpio_direction_input(unsigned gpio);//把管脚设置成输入 int gpio_direc...
写一个公用的gpio口驱动
嵌入式Linux
03-13 1066
因为项目需要控制的GPIO口比较多，如果每个GPIO口都写一个驱动就显得比骄麻烦，所以就写了一个通用的GPIO口驱动。只要dts里面配置好设备GPIO相...
linux c gpio读驱动程序,嵌入式Linux设备驱动开发之：GPIO驱动程序实例
weixin_34551614的博客
05-01 174
本文引用地址：http://www.eepw.com.cn/article/257110.htmstaticvoidgpio_cleanup(void){cdev_del(gpio_devs);/*字符设备的注销*/unregister_chrdev_region(MKDEV(major,0),1);/*设备号的注销*/printk(Gpiodeviceuninstalled\n);}module...
Keil MDK使用调试GPIO寄存器显示问题
twx11213030422的博客
10-17 3256
问题描述 本人在尝试使用结构体来操作寄存器完成STM32F429TIZx芯片的GPIO操作时，发现在Keil MDK的GPIOG寄存器视图中无法查看到寄存器值的变化。我使用的是ST-LINK调试器操作的是GPIOG端口，如下图所示： 代码： //#include "my_gpio_driver.h" #include "stdint.h" #define RCC_BASE_ADDR (0x40003800U) #define GPIOG_BASE_ADDR (0x40021800U) /
linux gpio驱动
06-28
### 回答1： GPIO是英文General Purpose Input/Output的缩写，翻译过来就是通用输入输出。Linux内核提供了GPIO驱动框架，可以通过该框架来控制硬件上的GPIO，实现对外设的控制。 在Linux内核中，GPIO驱动可以分为两类：基于平台的GPIO驱动和基于设备的GPIO驱动。基于平台的GPIO驱动是针对整个平台的GPIO控制，而基于设备的GPIO驱动则是针对单个设备的GPIO控制。 在使用GPIO驱动时，需要先找到所使用的GPIO引脚的编号，并将其映射到内存中的地址。然后通过读写内存中的寄存器来控制GPIO的状态。 对于GPIO的操作可以通过Linux内核提供的sysfs接口来实现。在sysfs中，每个GPIO都被表示为一个文件，可以通过读写文件来进行GPIO的操作。 需要注意的是，在使用GPIO驱动时，需要谨慎操作，避免对硬件造成损坏。同时，还需要了解所使用的硬件设备的特性和限制，以确保GPIO驱动的正确使用。补充说明： 在Linux内核中，GPIO驱动主要由GPIO子系统和GPIO控制器驱动两部分组成。GPIO子系统提供了一个通用的接口，用于操作GPIO控制器驱动，而GPIO控制器驱动则是实际控制硬件的部分。 GPIO子系统可以分为两个部分：GPIO框架和GPIO API。GPIO框架是一个通用的框架，用于管理GPIO控制器和GPIO设备，它定义了一些数据结构和函数接口，用于注册和管理GPIO控制器和GPIO设备。GPIO API是一个用户空间的API，提供了一些函数接口，用于操作GPIO。 GPIO控制器驱动是针对特定的GPIO控制器的驱动程序，它负责实际控制GPIO的硬件操作。在Linux内核中，每种GPIO控制器都有一个对应的GPIO控制器驱动程序。当使用GPIO时，首先需要通过GPIO子系统将GPIO控制器驱动注册到系统中，然后才能使用GPIO API对GPIO进行操作。 需要注意的是，在使用GPIO驱动时，需要注意GPIO的电气特性，避免对硬件造成损坏。同时，在进行GPIO操作时，还需要注意GPIO的并发访问和竞争问题，以确保系统的正确性和稳定性。 ### 回答2： Linux GPI驱动指的是Linux系统中通过General Purpose Input/Output（GPIO）接口与硬件设备进行交互的驱动程序。GPIO接口是一组通用的、可编程的多功能引脚，可用于连接各种外部设备，例如开关、LED、传感器、驱动器等。 Linux GPIO驱动可以实现对GPIO引脚的读写操作、中断处理等功能。它不仅可以与单片机等嵌入式设备进行通信，还可与各种外接硬件设备进行连接和通信。 在Linux系统中，用户可以通过/sys/class/gpio文件系统来访问GPIO引脚。在使用GPIO驱动时，用户需要首先加载相应的内核模块，然后使用GPIO API来对引脚进行读写操作或开启中断。 GPIO驱动程序需要实现以下功能： 1. 查询GPIO可用性及分配资源。通常，由于GPIO是多路的，因此设备需要分配资源共享GPIO。 2. 初始化GPIO引脚，包括定义方向及设置上下拉电阻等。 3. 实现GPIO引脚的读写操作。 4. 解除分配资源并释放相关资源。 正常情况下，GPIO驱动程序会提供一个设备文件，用户可以通过读写该文件实现GPIO引脚的操作。 总之，Linux GPIO驱动具有良好的可移植性和稳定性，可以方便地与其他硬件设备进行交互，因此被广泛应用于各种嵌入式设备和嵌入式系统中。 ### 回答3： Linux GPIO驱动是一种在嵌入式系统中实现通用输入输出（GPIO，General Purpose Input/Output）功能的软件驱动。GPIO是一种非常有用的硬件资源，它可以连接到外部设备，例如LED灯、按键和触摸屏等。 Linux内核支持GPIO操作，当你的嵌入式系统上有GPIO设备时，你可以利用GPIO来读取或设置其状态。驱动程序能够将GPIO标记为输入或输出，并且它们可以在运行时进行配置。 在Linux中，一般有两种方式将GPIO驱动程序添加到内核中：一种是将其编译到内核中，另一种是将其作为模块加载。 GPIO驱动程序等价于操作系统提供的设备文件，例如/dev/gpiochip0，它允许用户空间应用程序访问GPIO。这些设备文件可用于读取或写入GPIO状态。例如，要控制一个LED，需要将GPIO设置为输出模式，然后将其电平设置为高或低即可。 除此之外，GPIO驱动程序也可以实现中断（interrupt）机制，GPIO的状态变化时可以产生中断事件，这常用于处理GPIO键盘或GPIO中断信号的应用场景。 总结来说，Linux内核支持GPIO驱动需要有以下几个步骤：配置GPIO硬件；添加驱动程序；编写用户空间应用程序，按需要读取或设置GPIO状态来和外设交互。GPIO驱动程序是嵌入式系统中非常必要的组成部分，它们能够随时提供接口以方便对外部设备的读写访问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值