android7.1（a40i）驱动开发--使用sys文件系统与用户空间交互

最新推荐文章于 2024-10-12 22:00:13 发布
最新推荐文章于 2024-10-12 22:00:13 发布
阅读量622 收藏 1
点赞数
分类专栏： 通用kernel 文章标签： misc驱动 gpio sys
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mcsbary/article/details/102477769
版权

思路

1、创建字符设备
2、创建于字符设备关联的sys文件系统
3、在用户空间，通关串口命令查看驱动状态

使用示例

在这里插入图片描述
代码

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <linux/miscdevice.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/of_platform.h>
#include <linux/string.h>
#include <linux/err.h>
#include <linux/pinctrl/pinconf-sunxi.h>
#include <linux/sys_config.h>
#include <linux/ctype.h>
#include <linux/crypto.h>
#include <linux/err.h>
#include <linux/scatterlist.h>
#include <linux/ioctl.h>
#include <linux/fs.h>

#define LOG_TAG	 "misc_gpio:"
#define print_dbg(fmt, ...) printk(KERN_DEBUG LOG_TAG "%s:%d->" fmt, \
					__func__, __LINE__, ##__VA_ARGS__)
#define print_err(fmt, ...) printk(KERN_ERR LOG_TAG "%s:%d->" fmt, \
					__func__, __LINE__, ##__VA_ARGS__)
#define print_war(fmt, ...) printk(KERN_WARNING LOG_TAG "%s:%d->" fmt, \
					__func__, __LINE__, ##__VA_ARGS__)

typedef struct {
	int gpio;
	int value;
}st_gpio_param;

#define GPIO_MAGIC 'G'
#define GET_GPIO_LEVEL  	_IOR(GPIO_MAGIC, 0, st_gpio_param*)
#define SET_GPIO_LEVEL  	_IOR(GPIO_MAGIC, 1, st_gpio_param*)

#define INPUT_GPIO					0
#define OUTPUT_GPIO 				1
#define PIN_BANK_NAME_MAX_LEN		7
#define GPIO_USER_NAME_MAX_LEN		15

struct misc_gpio_config {
	char pin_bank[PIN_BANK_NAME_MAX_LEN + 1];
	char user[GPIO_USER_NAME_MAX_LEN + 1];
	struct gpio_config config;
};

static int g_gpio_num = 0;
static struct misc_gpio_config* g_gpio_array = NULL;
struct gpio_config g_attr_gpio_config = {0, 0, 0, 0, 0};

static DEFINE_MUTEX(itech_gpio_mutex);

static int get_parameter(const char *buf, int *data, size_t size)
{
	char *after;
	size_t count;
	int tmp;

	tmp = simple_strtoul(buf, &after, 10);
	count = after - buf;

	if (isspace(*after))
		count++;

	if (count == size){
		*data = tmp;
		return size;
	}

	return -EINVAL;
}

static int find_attr_gpio(void)
{
	int i = 0;
	for(i = 0;i <= g_gpio_num;i++) {
		if(g_gpio_array[i].config.gpio == g_attr_gpio_config.gpio) {
			g_attr_gpio_config.mul_sel = g_gpio_array[i].config.mul_sel;
			return g_gpio_array[i].config.gpio;
		}
	}

	if(i > g_gpio_num) {
		return -1;
	}
	return -1;
}


static ssize_t show_all_gpio(struct device *dev, struct device_attribute *attr,
			 const char *buf, size_t count)
{
	int i = 0;
	struct gpio_config* pconfig;
	printk("%-6s%-8s%-16s%-6s%-4s%-6s%-6s%-5s\n",
			"index", "pin", "user", "gpio", "sel", "pull", "level", "data");

	for(i = 0;i <= g_gpio_num;i++) {
		pconfig = &(g_gpio_array[i].config);

		printk("%-6d%-8s%-16s%-6d%-4d%-6d%-6d%-5d\n",
			i, g_gpio_array[i].pin_bank, g_gpio_array[i].user, pconfig->gpio,
			pconfig->mul_sel, pconfig->pull, pconfig->drv_level, gpio_get_value(pconfig->gpio));
	}

	return count;
}

static ssize_t set_gpio_num(struct device *dev, struct device_attribute *attr,
			 const char *buf, size_t count)
{
	return get_parameter(buf, &g_attr_gpio_config.gpio, count);
}

static ssize_t set_gpio_value(struct device *dev, struct device_attribute *attr,
			 const char *buf, size_t count)
{
	int gpio = -1;
	get_parameter(buf, &g_attr_gpio_config.data, count);
	if(g_attr_gpio_config.data != 0 && g_attr_gpio_config.data != 1) {
		printk(KERN_ERR "gpio num(%d),the set value(%d) is invalid.\n",
			g_attr_gpio_config.gpio, g_attr_gpio_config.data);
		return count;
	}

	gpio = find_attr_gpio();
	if(gpio < 0) {
		printk(KERN_ERR "gpio num(%d) is invalid.\n", g_attr_gpio_config.gpio);
		return count;
	}
	if(g_attr_gpio_config.mul_sel != OUTPUT_GPIO) {
		printk(KERN_ERR "gpio num(%d) mul_sel(%d) is not output.",
			g_attr_gpio_config.gpio, g_attr_gpio_config.mul_sel);
		return count;
	}
	gpio_set_value(g_attr_gpio_config.gpio, g_attr_gpio_config.data);
	return count;
}

static ssize_t show_gpio_value(struct device *dev, struct device_attribute *attr,
			 const char *buf, size_t count)
{
	int gpio = -1;
	int value = -1;
	get_parameter(buf, &g_attr_gpio_config.gpio, count);

	gpio = find_attr_gpio();
	if(gpio < 0) {
		printk(KERN_ERR "gpio num(%d) is invalid.\n", g_attr_gpio_config.gpio);
		return count;
	}
	/*
	if(g_attr_gpio_config.mul_sel != OUTPUT_GPIO) {
		printk(KERN_ERR "gpio num(%d) mul_sel(%d) is not output.",
			g_attr_gpio_config.gpio, g_attr_gpio_config.mul_sel);
		return count;
	}
	*/
	value = gpio_get_value(g_attr_gpio_config.gpio);
	printk("gpio(%d) value is %d.", g_attr_gpio_config.gpio, value);
	return count;
}

static DEVICE_ATTR(show_all_gpio, 0666,		NULL, show_all_gpio);
static DEVICE_ATTR(set_gpio_num, 0666, NULL, set_gpio_num);
static DEVICE_ATTR(set_gpio_value, 0666, NULL, set_gpio_value);
static DEVICE_ATTR(show_gpio_value, 0666, NULL, show_gpio_value);

static int _open (struct inode *node, struct file *fp)
{
	print_dbg("enter\n");
	return 0;
}

static int _release (struct inode *node, struct file *fp)
{
	print_dbg("enter\n");
	return 0;
}

static bool checkGpioAccess(int gpio)
{
	int i = 0;
	for(i = 0; i <= g_gpio_num; i++)
	{
		if(g_gpio_array[i].config.gpio == gpio) {
			return true;
		}
	}

	return false;
}

static int set_gpio_level(int gpio, int value)
{
	print_dbg("enter\n");
	if(!checkGpioAccess(gpio)) {
		print_err("gpio(%d) is not configured.Please configure it firstly.\n", gpio);
		return -1;
	}
	print_dbg("gpio = %d  value = %d\n", gpio, value);
	gpio_set_value(gpio, value);
	return 0;
}

static int get_gpio_level(int gpio)
{
	print_dbg("enter\n");
	if(!checkGpioAccess(gpio)) {
		print_err("gpio(%d) is not configured.Please configure it firstly.\n", gpio);
		return -1;
	}
	print_dbg("gpio = %d\n", gpio);
	return gpio_get_value(gpio);
}

static long _ioctl (struct file *fp, unsigned int cmd, unsigned long args)
{
	long ret = 0;
	switch(cmd) {
		case SET_GPIO_LEVEL:
		{
			st_gpio_param stGpioParam = {0,0};
			if(copy_from_user(&stGpioParam, (st_gpio_param*)args, sizeof(st_gpio_param))) {
				print_err("SET_GPIO_LEVEL copy_from_user fail.\n");
				return -1;
			}
			ret = set_gpio_level(stGpioParam.gpio, stGpioParam.value);
		}
			break;
		case GET_GPIO_LEVEL:
		{
			st_gpio_param stGpioParam = {0,0};
			if(copy_from_user(&stGpioParam, (st_gpio_param*)args, sizeof(st_gpio_param))) {
				print_err("SET_GPIO_LEVEL copy_from_user fail.\n");
				return -1;
			}
			stGpioParam.value = get_gpio_level(stGpioParam.gpio);
			ret = copy_to_user((void *)args, &stGpioParam, sizeof(st_gpio_param));
		}
			break;
		default:
			print_err("command is error.");
			return -1;
	}
	return ret;
}


static struct attribute *misc_attributes[] = {
	&dev_attr_show_all_gpio.attr,
	&dev_attr_set_gpio_num.attr,
	&dev_attr_set_gpio_value.attr,
	&dev_attr_show_gpio_value.attr,
	NULL,
};

static struct attribute_group misc_attribute_group = {
	.name  = "itech_gpio",
	.attrs = misc_attributes,
};

struct file_operations itech_gpio_fops = {
    .owner = THIS_MODULE,
    .open = _open,
    .release = _release,
    .unlocked_ioctl = _ioctl,
};


static struct miscdevice itech_misc_dev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name  = "itech_gpio",
	.fops  = &itech_gpio_fops,
};

int request_itech_misc_gpio(const char* pin_bank, const char* user)
{
	int index = 0;
	int pin_bank_len = 0;
	int user_len = 0;
	if(pin_bank == NULL || user == NULL) {
		print_err("params are error.\n");
		return -1;
	}

	pin_bank_len = strlen(pin_bank);
	user_len = strlen(user);
	if(pin_bank_len == 0 ||  pin_bank_len > PIN_BANK_NAME_MAX_LEN
		|| user_len == 0 || user_len > GPIO_USER_NAME_MAX_LEN) {
		print_err("params's value is invalid, string len is too short or too long.\n");
		return -1;
	}

	mutex_lock(&itech_gpio_mutex);
	for(index = 0; index <= g_gpio_num; index++) {
		if(!strcmp(pin_bank, g_gpio_array[index].pin_bank)) break;
	}

	if(index > g_gpio_num) {
		print_err("%s is not a gpio.Please config it firstly.\n", pin_bank);
		goto fail;
	}

	if(g_gpio_array[index].user[0] != '\0'
		&& (strlen(g_gpio_array[index].user) != strlen(user)
		|| strcmp(g_gpio_array[index].user, user))) {
		print_err("Pin %s has been used, Please change another pin.\n", pin_bank);
		goto fail;
	}
	strcpy(g_gpio_array[index].user, user);
	mutex_unlock(&itech_gpio_mutex);

	return g_gpio_array[index].config.gpio;

	fail:
		mutex_unlock(&itech_gpio_mutex);
		return -1;
}
EXPORT_SYMBOL_GPL(request_itech_misc_gpio);


int init_one_gpio(struct platform_device *pdev, char* name,
			struct gpio_config* const pconfig) {
	struct device_node *gpio_node = pdev->dev.of_node;
	int ret = -1;
	int gpio = -1;

	if(name == NULL || pconfig == NULL) {
		print_err("%s\n", "param is error.");
		return -1;
	}

	mutex_lock(&itech_gpio_mutex);
	gpio = of_get_named_gpio_flags(gpio_node, name, 0, (enum of_gpio_flags *)pconfig);
    if(!gpio_is_valid(gpio)) {
		print_err("get gpio %s failed\n", name);
		goto fail;
    }

    ret = gpio_request(gpio, name);
	if (ret < 0) {
		print_err("can't request %s gpio %d\n", name, gpio);
		goto fail;
	}

    if(pconfig->mul_sel == 0){
        ret = gpio_direction_input(gpio);
		if (ret < 0) {
			print_err("can't request input direction %s gpio %d\n", name, gpio);
			goto fail;
		}
    }else if(pconfig->mul_sel == 1){
        ret = gpio_direction_output(gpio, pconfig->data);
        if (ret < 0) {
			print_err("can't request output direction %s gpio %d\n",
				name, gpio);
			goto fail;
		}
    } else {
        print_war("misc-GPIO : %s config.mul_sel:%d is not a gpio.\n", name, pconfig->mul_sel);
    }

	print_dbg("MISC-GPIO : %s gpio = %d\n", name, gpio);
	mutex_unlock(&itech_gpio_mutex);
	return gpio;

	fail:
		mutex_unlock(&itech_gpio_mutex);
		return -1;
}
EXPORT_SYMBOL_GPL(init_one_gpio);

static int misc_gpio_probe(struct platform_device *pdev) {
    int ret = -1;
	int gpio_nums = 0;
	int index = 0;
	const char *pins_string = NULL;
	const char* p = NULL;
	char temp[PIN_BANK_NAME_MAX_LEN + 1] = "\0";
	struct gpio_config config;
	struct device_node *np = pdev->dev.of_node;
	print_dbg("enter\n");

	if (of_property_read_u32(np, "gpio_nums", &gpio_nums)) {
		print_err("%s.\n","get resourcce gpio_nums fail");
		return -1;
	}
	g_gpio_num = gpio_nums;
	print_dbg("g_gpio_num = %d\n", g_gpio_num);

	g_gpio_array = devm_kzalloc(&pdev->dev, gpio_nums*sizeof(struct misc_gpio_config), GFP_KERNEL);
	if (!g_gpio_array) {
		print_err("no memory.");
		return -ENOMEM;
	}

	if (of_property_read_string(np, "pin_banks", &pins_string)) {
		print_err("get resourcce pin_banks fail.\n");
		return -1;
	}
	print_dbg("pin_banks = %s\n", pins_string);

	if(pins_string == NULL || strlen(pins_string) == 0) {
		print_err("value of pin_banks is error.");
		return -1;
	}

	p = pins_string;
	for(index = 0; index <= gpio_nums; index++) {
		if(sscanf(p, "%s", temp) <= 0) break;
		print_dbg("index = %d  name = %s", index, temp);
		p += (strlen(temp) + 1);

		init_one_gpio(pdev, temp, &config);
		memcpy(g_gpio_array[index].pin_bank, temp, PIN_BANK_NAME_MAX_LEN);
		g_gpio_array[index].pin_bank[PIN_BANK_NAME_MAX_LEN] = '\0';
		g_gpio_array[index].user[0] = '\0';
		memcpy(&g_gpio_array[index].config, &config, sizeof(struct gpio_config));

		if(*(p-1) == '\0') break;
		while(*p == ' ') p++;
	}

	// 1.注册字符设备
	ret = misc_register(&itech_misc_dev);
	if (ret) {
		print_err("register driver as misc device error!\n");
		return ret;
	}
	// 2.创建sys文件系统操作文件
	ret = sysfs_create_group(&itech_misc_dev.this_device->kobj,
			&misc_attribute_group);
	if (ret) {
		print_err("register sysfs create group failed!\n");
		return ret;
	}
    return 0;
}

static int misc_gpio_remove(struct platform_device *pdev)
{
	WARN_ON(0 != misc_deregister(&itech_misc_dev));
	sysfs_remove_group(&(itech_misc_dev.this_device->kobj),
			&misc_attribute_group);
	return 0;
}

static const struct of_device_id of_misc_gpio_match[] = {
    { .compatible = "icetech, misc-gpio", },
    {},
};

static struct platform_driver misc_gpio_driver = {
    .probe          = misc_gpio_probe,
    .remove         = misc_gpio_remove,
    .driver         = {
        .name   = "misc-gpio",
        .owner  = THIS_MODULE,
        .of_match_table = of_match_ptr(of_misc_gpio_match),
    },
};

static int __init module_misc_gpio_init(void)
{
	print_dbg("enter\n");
	return platform_driver_register(&misc_gpio_driver);
}

static void __exit module_misc_gpio_exit(void)
{
	platform_driver_unregister(&misc_gpio_driver);
}

// module_platform_driver(misc_gpio_driver);
fs_initcall(module_misc_gpio_init);
module_exit(module_misc_gpio_exit);

MODULE_AUTHOR("binn.chen@icetech-china.com");
MODULE_DESCRIPTION("icetech misc device gpio config driver");
MODULE_LICENSE("GPL");
A40I框架图
01-10
A40I全志工业级芯片，主要应用领域汽车导航，工控电脑
A40i-linux 扩展文件系统分区
qq_32017483的博客
07-29 366
移植resize2fs工具,执行resize2fs/dev/mmcblk0p7。所以在系统脚本只执行一次，所以我们在rcS做如下修改。在etc目录下添加firstboot文件。8G的emmc发现分区大小不对。这时候发现分区大小对了。
全志A40i核心板开发资料
最新发布
gitblog_09813的博客
10-12 296
全志A40i核心板开发资料 全志A40i核心板开发资料 全志A40i核心板开发资料本仓库提供了全志A40i核心板的开发资料，包括芯片手册、电路图以及相关的技术规格书 项目地址: https://gitcode.com/open-s...
飞凌嵌入式A40i 开发板平台应用笔记-华为-ME909S-4G 模块的移植应用
飞凌嵌入式
12-04 184
本文讲解了国产A40i开发板移植华为-ME909S-4G 模块的应用，本篇文章主要适用于飞凌OKA40i 平台Linux3.10.65 操作系统，其他arm 平台也可以参考，但是不同平台之间会存在差异，请自行修改以适应自己的使用。 写本文章的主要目的是协助客户加速产品的研发速度，由于水平有限， 不提供任何的完整性、可靠性等保证，软件版本更新之后，有些位置名称等内容可能会及时更新，修改方法请参考使用。 1. 查看内核配置文件：arch/arm/configs/sun8iw11p1smp_oka40i_c..
Android驱动利用sys节点进行调试
前行
08-17 1858
#define SYS_CHANGE_EXT_SPK_PA_MODE_SUPPORT#ifdef SYS_CHANGE_EXT_SPK_PA_MODE_SUPPORT static ssize_t store_caliberate(struct device *dev, struct device_attribute *attr, const char *buf, size_t co
a40i 全志 芯片手册_飞凌嵌入式 全志A40i开发板试用体验 之 控制一个GPIO
weixin_39733821的博客
01-02 659
1.Linux内核提供了一套在用户态配置GPIO的接口，在/sys/class/gpio/目录下。l export用于将指定编号的引脚导出，作为GPIO使用l unexport用于将导出的GPIO删除掉l gpiochipN当前芯片中包含的GPIO控制器参考https://www.cnblogs.com/lxyd/p/9671673.html2.找到一个未使用的引脚，我这里选择的是SPI2的...
a40i-linux-使用指导文档-20210412.pdf
06-17
建议使用文档中RP-A40i为基础进行说明，其他板型用户可查找对应目录获取文件。 在开发环境搭建方面，文档明确指出需要使用Ubuntu 12.04 64bit或Ubuntu 14.04 64bit操作系统进行编译。之后详细罗列了一系列软件包的...
A40i-LinuxSDK使用手册.pdf
11-18
A40i-LinuxSDK使用手册 A40i-LinuxSDK使用手册是Allwinner公司发布的LinuxSDK使用手册...A40i-LinuxSDK使用手册提供了A40i-Linux平台的详细开发指南和开发环境配置方法，旨在帮助开发者快速上手A40i-Linux平台的开发。
 A40I 平台Android7.1 系统程序 -4G EC200T
hanping1020的专栏
04-22 1437
A40I 平台Android7.1 系统程序 -4G EC200T （1） a40_p1.mk文件修改 增加copy配置： #EC200 PRODUCT_COPY_FILES += \ device/softwinner/a40-p1/r2ril/ec200/ip-down:system/etc/ppp/ip-down \ device/soft...
A40I android7.1 4路摄像头视频同时预览
09-27
这里我们关注的是"A40I android7.1 4路摄像头视频同时预览"的主题，这涉及到一系列的技术知识点，包括硬件平台、操作系统、视频输入接口以及驱动程序的开发。 首先，A40I是一个基于Android系统的嵌入式设备，其运行...
A40I原理图
01-26
A40I原理图，包含整机图纸，包含内存，falsh wifi 电源部分，USB接口，可以直接使用
A40i_user_manual_V1.1.pdf
08-19
全志A40i芯片手册，包含硬件性能及框图、电气特性、寄存器的描述等等，软硬件设计必备，有助于A40i平台的开发、研究、应用，这资源全志官网不提供
A40I工控主板（SBC-X40I）串口通信测试
szembed的博客
09-01 770
工业宽温设计，工作更稳定：SBC-X40I主板隶属于盈鹏飞嵌入式Single Board Computer(SBC)系列，是CoM-X40I核心模块的工程底板的参考设计，该产品集成了四核Cortex-A71.2GHz(MAX)A40I处理器，稳定运行Linux3.10。SBC-X40I提供了3.3V I/O接口，可提供宽温的工业组件，运行于条件恶劣的工业现场！...
QZY-A40i低成本智慧商显主板
whochange的博客
08-07 372
一、产品概述： QZY-A40i 采用全志A40i Cortex-A7 四核处理器，搭载Android 7.0系统，超强性能。采用 Mali-400 MP GPU，支持 4K、H.265 硬解码。内存1G，本机存储16G（可选32/64G）。可搭配3G/4G实现数据通信，丰富的外接设备，接口丰富、性能稳定。 二、产品特点： 1、 供电：支持12V电源输入，支持外挂电池 2、尺寸：12075mm小...
【A40i-Android7.1】--- A40i 编译流程 和 打包成固件
秋知叶i
08-26 2572
一个好的文章能够帮助开发者完成更便捷、更快速的开发。书山有路勤为径，学海无涯苦作舟。我是秋知叶i、期望每一个阅读了我的文章的开发者都能够有所成长。
A40I构建编译应用程序的SDK环境
kgs0716的博客
04-18 292
手动修改第三方软件包的配置文件,如下所示,哈希校验值的修改根据下载过程中哈希校验报错的信息,来调整哈希文件中的内容。cd进入buildroot生成文件系统目标文件目录。导出文件系统编译环境SDK。第三方库软件包版本更新。
全志A40i开发板（4核ARM Cortex-A7）测评合集——开箱上电测试
创龙，嵌入式一体化解决方案商
10-31 492
本次测试板卡是创龙科技旗下，一款基于全志科技A40i开发板，其接口资源丰富，可引出双路网口、双路CAN、双路USB、双路RS485等通信接口，板载Bluetooth、WIFI、4G（选配）模块，同时引出MIPI LCD、LVDS LCD、TFT LCD、HDMI OUT、CVBS OUT、CAMERA、LINE IN、H/P OUT等音视频多媒体接口，支持双屏异显、1080P@45fps H.264视频硬件编码、1080P@60fps H.264视频硬件解码，并支持SATA大容量存储接口。
一起来了解下全志A40i芯片详细参数
热门推荐
szx940213的博客
03-14 2万+
全志A40i处理器代表了Allwin在智能工业控制领域的最新成就。该处理器适用于需要3D图形、高级视频处理的应用程序。用户接口丰富、质量高、功耗低、系统集成度高。 A40i主要应用于基于视觉交互的工业控制产品。 A40i芯片特性： 可以在4车道MIPIDSI显示器、RGB面板或双通道LVDS面板上显示内容。也支持CVBS-OUT和HDMIV1.4 支持双cmos传感器并行接口和4通道cvb...
A40i-Linux SDK入门指南：最新V1.5版详解与环境配置
本资源是全志科技发布的A40i-LinuxSDK使用手册，适用于A40i平台的Linux开发。该手册详细介绍了如何在A40i-EVB开发板上进行Linux开发环境的搭建、代码编译和固件烧写过程。 1. **概述**：本手册首先提供了一个简洁的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值