Linux驱动之 pinctrl和GPIO子系统

1
2
3
4
5
6
7
8
9
10
11
12
Port A(GPA) : 25-output port
Port B(GPB) : 9-input/output port
Port C(GPC) : 16-input/output port
Port D(GPD) : 16-input/output port
Port E(GPE) : 16-input/output port
Port F(GPF) : 8-input/output port
Port G(GPG) : 8-input/output port
Port H(GPH) : 15-input/output port
Port K(GPK) : 16-input/output port
Port L(GPL) : 7-input/output port
Port M(GPM) : 2-input port

1
2
3
4
5
6
7
8
9
10
11
12
		gpa0: gpa0 {
			gpio-controller;		// 表明该节点为GPIO控制
			#gpio-cells = <2>;		// 槽为2  这里是根据文档获得的
//#interrupt-cells – 与#address-cells 和 #size-cells相似，它表明连接此中断控制器的设备的interrupts属性的cell大小。	#address-cells 表示子节点的reg address属性的大小 如果为1 那么代表只有一个address
			interrupt-controller;	// 中断控制
			#interrupt-cells = <2>;	
		};
	gpj0: gpj0 { gpio-controller;
		#gpio-cells = <2>;
		interrupt-controller;
		#interrupt-cells = <2>; };

1
2
3
4
5
6
7
8
		/*pin group*/
		uart0_data: uart0-data {
			samsung,pins = "gpa0-0", "gpa0-1";			  //引用管脚	[pin bank name]-[pin number within the bank]	
			samsung,pin-function = <EXYNOS_PIN_FUNC_2>;   // 设置功能复用模式
			samsung,pin-pud = <EXYNOS_PIN_PULL_NONE>;	  // pud 上拉下拉配置
			samsung,pin-drv = <EXYNOS4_PIN_DRV_LV1>;	  // 驱动强度为LV1
		};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/*
 * Samsung's Exynos pinctrl bindings
 *
 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
 *		http://www.samsung.com
 * Author: Krzysztof Kozlowski <krzk@kernel.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
*/
#ifndef __DT_BINDINGS_PINCTRL_SAMSUNG_H__
#define __DT_BINDINGS_PINCTRL_SAMSUNG_H__

#define EXYNOS_PIN_PULL_NONE		0
#define EXYNOS_PIN_PULL_DOWN		1
#define EXYNOS_PIN_PULL_UP		3

#define S3C64XX_PIN_PULL_NONE		0
#define S3C64XX_PIN_PULL_DOWN		1
#define S3C64XX_PIN_PULL_UP		2

/* Pin function in power down mode */
#define EXYNOS_PIN_PDN_OUT0		0
#define EXYNOS_PIN_PDN_OUT1		1
#define EXYNOS_PIN_PDN_INPUT		2
#define EXYNOS_PIN_PDN_PREV		3

#define EXYNOS_PIN_FUNC_INPUT		0		//输入
#define EXYNOS_PIN_FUNC_OUTPUT		1		//输出
#define EXYNOS_PIN_FUNC_2		2
#define EXYNOS_PIN_FUNC_3		3
#define EXYNOS_PIN_FUNC_4		4
#define EXYNOS_PIN_FUNC_5		5
#define EXYNOS_PIN_FUNC_6		6
#define EXYNOS_PIN_FUNC_EINT		0xf
#define EXYNOS_PIN_FUNC_F		EXYNOS_PIN_FUNC_EINT


#endif /* __DT_BINDINGS_PINCTRL_SAMSUNG_H__ */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*在pinctrl_1节点中*/
/* 因为gpl2定义在了pinctrl_1 节点里面*/
	/*添加自定义的LED pinctrl节点*/
	/*pin bank*/
pinctrl_1: pinctrl@11000000 {
			gpl1: gpl1 {
			gpio-controller;
			#gpio-cells = <2>;

			interrupt-controller;
			#interrupt-cells = <2>;
		};
		/*pin group*/
		my_led: my_led {
			samsung,pins = "gpl2-0"; //引用GPL2_0
			samsung,pin-function = <EXYNOS_PIN_FUNC_OUTPUT>; // 设置为输出模式
			samsung,pin-val = <0x1>; 		//初始值输出高电平			
		};
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
	/* 添加自定义节点*/
	
	myled:myled {
		#address-cells = <1>;		
		#size-cells = <1>;
		compatible = "myledxxx";  //描述
//		reg = <0x11000100 0x4 0x11000104 0x1>; //GPL2CON GPL2DAT
		status = "okay";
		pinctrl-names = "default";	/* 即是名字也是 状态status*/
		pinctrl-0 = <&my_led>;		/* 当使用default状态时，就会使用 所引用节点的 配置*/
        /*这里的配置主要是将gpl2_0 引脚设置为GPIO*/
        
        /*管脚的描述信息  主要是*/
		gpios = <&gpl2 0 GPIO_ACTIVE_HIGH>;	//GPL2_0   GPIO_ACTIVE_HIGH 表示高电平有效
	};

1
2
3
4
5
6
7
8
9
10
#include <linux/pinctrl/consumer.h> 
struct pinctrl {
	struct list_head node;	//全局列表节点
	struct device *dev;		//使用这个pin控制的设备
	struct list_head states;//这个设备的状态列表
	struct pinctrl_state *state;//当前状态
	struct list_head dt_maps;	//:从设备树动态解析的映射表块
	struct kref users;			//引用计数
};

1
2
3
4
5
6
struct pinctrl_state {
	struct list_head node;	//states字段的列表节点
	const char *name;		//该状态的名称
	struct list_head settings;	//这个状态的设置列表
};

1
2
3
4
#include <linux/pinctrl/consumer.h> 
struct pinctrl *devm_pinctrl_get(struct device *dev)  ;
//返回值 成功返回pinctrl句柄  失败返回NULL

1
2
3
4
5
#include <linux/pinctrl/consumer.h> 
struct pinctrl_state *pinctrl_lookup_state(struct pinctrl *p, const char *name) ;
// 返回值  成功返回pinctrl 状态  失败返回NULL
   

1
2
3
4
#include <linux/pinctrl/consumer.h> 
int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *state) ；
// 成功返回 0  失败返回错误码

1
2
void devm_pinctrl_put(struct pinctrl *p);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
		/*添加自定义的LED pinctrl节点*/
	/* 在pinctrl_1 中 ，因为 gpl2 在pinctrl_1中*/	
		my_led_on: my_led-on {
			samsung,pins = "gpl2-0"; //引用GPL2_0
			samsung,pin-function = <EXYNOS_PIN_FUNC_OUTPUT>; // 设置为输出模式
			samsung,pin-val = <0x1>; 		//初始值输出高电平			
			samsung,pin-pud = <EXYNOS_PIN_PULL_UP>;
		};
		my_led_off: my_led-off {
			samsung,pins = "gpl2-0"; //引用GPL2_0
			samsung,pin-function = <EXYNOS_PIN_FUNC_OUTPUT>; // 设置为输出模式
			samsung,pin-val = <0x0>; 		//初始值输出低电平			
			samsung,pin-pud = <EXYNOS_PIN_PULL_UP>;
		};

1
2
3
4
5
6
7
8
	myled:myled {
		compatible = "myledxxx";  //描述
		status = "okay";
		pinctrl-names = "default", "my_led_off";	/* 即是名字也是 状态status*/
		pinctrl-0 = <&my_led_on>;		/* 当使用default状态时，就会使用所引用节点的配置*/
		pinctrl-1 = <&my_led_off>;
	};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
int ledprobe(struct platform_device *pdev)
{
    struct pinctrl * led_pinctrl;
    struct pinctrl_state * led_pinctrl_state;
    int ret;
    /*1、获取pinctrl句柄*/
    led_pinctrl = devm_pinctrl_get(&pdev->dev);
    if (NULL == led_pinctrl)
    {
        printk("devm pinctrl get is error!n");
        return -1;
    }
    /*2、获取 指定的name的 state*/
    /*	pinctrl-name = "default, led_off";	 即是名字也是 状态status*/
    led_pinctrl_state = pinctrl_lookup_state(led_pinctrl, "default"); //获取pinctrl-0的配置状态
    if (NULL == led_pinctrl_state)
    {
        printk("pinctrl lookup state is error!n");
        return -1;
    }
    /*3、设置引脚状态*/
    ret = pinctrl_select_state(led_pinctrl, led_pinctrl_state);
    if (0 != ret)
    {
        printk("pinctrl select state is error!n");
        return -1;
    }
    /*4、 句柄销毁*/
   // devm_pinctrl_put(led_pinctrl);  //     
    return 0;    
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
pinctrl_1: pinctrl@11000000 {
		gpl2: gpl2 {
			gpio-controller;
			#gpio-cells = <2>;

			interrupt-controller;
			#interrupt-cells = <2>;
		};
		
		my_led_on: my_led-on {
			samsung,pins = "gpl2-0"; //引用GPL2_0
			samsung,pin-function = <EXYNOS_PIN_FUNC_OUTPUT>; // 设置为输出模式
			samsung,pin-val = <0x1>; 		//初始值输出高电平			
			samsung,pin-pud = <EXYNOS_PIN_PULL_UP>;		//电气属性， 上拉/下拉
		};
		my_led_off: my_led-off {
			samsung,pins = "gpl2-0"; //引用GPL2_0
			samsung,pin-function = <EXYNOS_PIN_FUNC_OUTPUT>; // 设置为输出模式
			samsung,pin-val = <0x0>; 		//初始值输出低电平			
			samsung,pin-pud = <EXYNOS_PIN_PULL_UP>;
		};
};

1
2
3
4
5
6
7
	my_led_on: my_led-on {
		samsung,pins = "gpl2-0"; //引用GPL2_0
		samsung,pin-function = <EXYNOS_PIN_FUNC_OUTPUT>; // 设置为输出模式
		samsung,pin-val = <0x1>; 		//初始值输出高电平			
		samsung,pin-pud = <EXYNOS_PIN_PULL_UP>;		//电气属性， 上拉/下拉
	};

1
2
3
4
5
6
7
8
9
10
11
12
13
	myled:myled {
		compatible = "myledxxx";  //描述
		reg = <0x11000100 0x4 0x11000104 0x1>; //GPL2CON GPL2DAT
		status = "okay";
		/*pinctrl*/
		pinctrl-names = "default", "my_led_off";	/* 即是名字也是 状态status*/
		pinctrl-0 = <&my_led_on>;		/* 当使用default状态时，就会使用所引用节点的配置*/
		pinctrl-1 = <&my_led_off>;
		/*GPIO*/	
		led-gpios = <&gpl2 0 GPIO_ACTIVE_HIGH>;	//GPL2_0   GPIO_ACTIVE_HIGH 表示高电平有效
		//gpios  = <&gpl2 0 GPIO_ACTIVE_HIGH>;
	};

1
2
3
4
5
#include<linux/of_gpio.h>

int of_get_named_gpio(struct device_node *np,const char *propname, int index)；
// 返回值  成功返回 GPIO编号，  失败返回 负数

1
2
3
4
#include<linux/gpio.h>
int gpio_request(unsigned gpio, const char *label);
// 返回值  成功 0，  失败返回 非0

1
2
3
#include<linux/gpio.h>
void gpio_free(unsigned gpio);

1
2
3
4
#include <linux/gpio.h>
int gpio_direction_input(unsigned gpio);
//返回值  成功返回0 ， 失败返回负数	

1
2
3
4
#include <linux/gpio.h>
int gpio_direction_output(unsigned gpio, int value);
//返回值 成功返回0 ，失败返回 负数

1
2
3
4
#include <linux/gpio.h>
int gpio_get_value(unsigned gpio);
//返回值， 成功返回GPIO的值， 失败返回 负数

1
2
3
#include<linux/gpio.h>
void gpio_set_value(unsigned gpio, int value);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/pinctrl/consumer.h> 
#include <dt-bindings/pinctrl/samsung.h>	
#include <linux/of_gpio.h>		

/*  字符设备框架
    1、注册 platform driver
    2、构建file_operations
    3、获取硬件资源
    4、注册字符设备驱动
    4、生成字符设备节点
*/  

struct device *device_cdev; 
struct class *class_cdev;

int GPIO_ID;

ssize_t led_read (struct file *file, char __user * user, size_t size, loff_t * loff )
{
    printk("read is success!n");
    return 0;
}
ssize_t led_write (struct file *file, const char __user *user, size_t size, loff_t * loff)
{   char buf[128] = {0};
    int ret ;
    printk("write is success!n");
    ret  = copy_from_user(buf, user, size);
    if (0 != ret)
    {
        printk("copy form user is error!n");
        return ret;
    }
    if (buf[0] == 1 || buf[0] == 0)
        gpio_set_value(GPIO_ID, buf[0]);
    return 0;
}
int led_open(struct inode *inode, struct file *file)
{
    printk("open is success!n");
    return 0;
}
int led_release (struct inode *inode, struct file *file)
{
    printk("release is success!n");
    return 0;
}

/*2、获取硬件资源 */
int ledprobe(struct platform_device *pdev)
{
    int ret;
    /*1、获取GPIO号*/
    GPIO_ID = of_get_named_gpio(pdev->dev.of_node, "led-gpios", 0);//index=0 ,因为在设备树中只引用了一个
    if (GPIO_ID < 0)
    {
        printk("of get named gpio is error!n");
        return -1;
    }
    /*2、申请一个GPIO管脚*/
    ret = gpio_request(GPIO_ID, "led_gpio");
    if (ret != 0)
    {
        printk("gpio request is error!n");
        return -1;
    }
    /*3、 将管脚设置为输出*/
    /* 这里先不设置，因为在pinctrl复用中已经将管脚设置为了OUTPUT*/
    return 0;    
}
int ledremove(struct platform_device *pdev)
{
    return 0;
}
struct of_device_id of_match_table = {      // 与设备树节点进行匹配
    .compatible = "myledxxx"
};
/*1、初始化platform driver*/
struct platform_driver pdev = {
    .probe = ledprobe,          // 与 of_match_table 匹配成功后进入probe函数获取硬件资源
    .remove = ledremove,
    .driver = {
        .name = "myledxxx",     //无设备树时 使用.name 与device进行匹配
        .owner = THIS_MODULE,
        .of_match_table = &of_match_table,
    }
};
//3、注册字符设备驱动
/*3.1 分配设备号*/
dev_t dev_number;
/*3.2 定义cdev*/
struct cdev cdev_;
/*3.3 构建file_operation结构体*/
struct file_operations fop = {
    .owner = THIS_MODULE,
    .open    = led_open,
    .release = led_release,
    .write   = led_write,
    .read    = led_read,
};
static int char_driver_init(void)
{
    /*1、注册platform driver*/
    int ret = platform_driver_register(&pdev);
    if (0 != ret)
    {   
        printk("platform driver register is error!n");
        return -1;
    }
    /*3.1 分配设备号(动态分配设备号)*/
    ret = alloc_chrdev_region(&dev_number, 0, 1, "my_led");
    if (0 != ret)
    {
        printk("alloc chrdev region is error!n");
        return ret;
    }
    /*3.4 初始化cdev*/
    cdev_.owner = THIS_MODULE;
    cdev_init(&cdev_, &fop);
    /*3.5 注册字符设备到内核*/
    ret = cdev_add(&cdev_, dev_number, 1);
    if (0 != ret)
    {
        printk("cdev add is error!n");
        return -1;
    }
    /*4、生成设备节点*/
    /*4.1 创建字符设备类*/
   class_cdev =  class_create(THIS_MODULE, "my_led");
    if (NULL == class_cdev)
    {
        printk("class create is error!n");
        return -1;
    }
    /*生成设备节点*/
    device_cdev = device_create (class_cdev, NULL, dev_number, NULL,  "my_led");
    if (NULL == device_cdev)
    {
        printk("device create is error!n");
    }
    return 0;
};

static void char_driver_exit(void)
{
    gpio_free(GPIO_ID);                     //释放GPIO
    device_destroy(class_cdev, dev_number); // 卸载设备节点
    class_destroy(class_cdev);              //卸载设备类
    cdev_del(&cdev_);                       //卸载cdev
    unregister_chrdev_region(dev_number, 1);// 注销设备号 
    platform_driver_unregister(&pdev);       // 注销platform driver
   
}
module_init(char_driver_init);
module_exit(char_driver_exit);
MODULE_LICENSE("GPL");