（三）采用pinctrl控制系统控制GPIO

三、使用pinctrl控制GPIO

1.1、princtrl控制系统

管理系统中所有的可以控制的pin，在系统初始化的时候，枚举所有可以控制的pin，并标识这些pin，主要是获取到pinctrl系统中GPIO对应的编号，然后调用GPIO 的操作函数进行操作。

1.2、设备树添加GPIO节点

在对应的设备树pinctrl节点上添加驱动的GPIO信息。

pinctrl_led:ledgrp{
			fsl,pins = <
				MX6UL_PAD_GPIO1_IO03__GPIO1_IO03    0x10b0
			>;
		};

之后在根/下面添加自己的gpio节点

gpioled{
		#address-cells = <1>;
		#size-cells = <1>;
		compatible = "atkalpha-gpioled";
    	pinctrl-name = "default";
		pinctrl-0=<&pinctrl_led>;
		led-gpio = 	< &gpio1 3 GPIO_ACTIVE_LOW >;	//低电平点亮 
		status = "okay";
	};

其中led-gpio这个节点名字要记住，因为后续驱动代码通过他来获取道GPIO的number，进而对其进行初始化话和控制。
以上设备树修改是基于imx6ull的。

1.3、驱动代码

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/of_fdt.h>
#include <linux/of_irq.h>
#include <linux/of_platform.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>

#define PINCTRL_LED_NAME    "pinctrled"
#define PINCTRL_LED_CT      1

#define LED_ON  1
#define LED_OFF 0

struct pinctrl_led_struct{
    int major;
    int minor;
    dev_t devid;
    struct cdev cdev;  /* use 1 cdev for all pins */
    struct class *class;
    struct device *device;
    struct device_node *nd;
    int gpio;

};

struct pinctrl_led_struct pinctrl_led_dev;

static int pinctrl_led_open(struct inode *inode, struct file *file)
{
	//unsigned m = iminor(inode);
	file->private_data = &pinctrl_led_dev;
    return 0;
}

static int pinctrl_led_release(struct inode *inode, struct file *file)
{
	return 0;
}


ssize_t pinctrl_led_write(struct file *file, const char __user *data,size_t len, loff_t *ppos)
{
    unsigned char data_tmp = 0;
    unsigned int ret = 0;
    struct pinctrl_led_struct *dev = file->private_data;

    ret = copy_from_user(&data_tmp,data,1);

    if(ret){
        printk("get write data err\r\n");
        return 0;
    }

    if(data_tmp == LED_ON){
        gpio_set_value(dev->gpio,0);
    }
    else if(data_tmp == LED_OFF){
        gpio_set_value(dev->gpio,1);
    }

    return 0;
}

ssize_t pinctrl_led_read(struct file *file, char __user * buf,size_t len, loff_t * ppos)
{
    return 0;
}

static const struct file_operations pinctrl_led_fileops = {
	.owner   = THIS_MODULE,
	.write   = pinctrl_led_write,
	.read    = pinctrl_led_read,
	.open    = pinctrl_led_open,
	.release = pinctrl_led_release,
};


int led_init(void)
{
    int ret = 0;
    pinctrl_led_dev.nd = of_find_node_by_path("/gpioled");
    if(pinctrl_led_dev.nd == NULL){
        printk("not find node\r\n");
        return -1;
    }
    printk("find node\r\n");
    pinctrl_led_dev.gpio = of_get_named_gpio(pinctrl_led_dev.nd, "led-gpio", 0);

    if(pinctrl_led_dev.gpio < 0){
        printk("not open gpio\r\n");
        return -2;
    }
    printk("get gpio num:%d\r\n",pinctrl_led_dev.gpio);

    ret = gpio_direction_output(pinctrl_led_dev.gpio, 1);
    if(ret < 0){
        printk("not set gpio output\r\n");
        return -3;
    }

    return 0;
}

static int __init pinctrl_led_init(void)
{
    int ret = 0;

    ret = led_init();

    if(ret < 0){
        goto CHRDEV_ERR;
    }


    pinctrl_led_dev.major = 0;
    /* Register our major, and accept a dynamic number. */
	if (pinctrl_led_dev.major) {
		pinctrl_led_dev.devid = MKDEV(pinctrl_led_dev.major, 0);
		ret = register_chrdev_region(pinctrl_led_dev.devid, PINCTRL_LED_CT, PINCTRL_LED_NAME);
	} else {
		ret = alloc_chrdev_region(&pinctrl_led_dev.devid, 0, PINCTRL_LED_CT, PINCTRL_LED_NAME);
		pinctrl_led_dev.major = MAJOR(pinctrl_led_dev.devid);
	}

    if(ret < 0){
        printk("chedev region err\r\n");
        goto CHRDEV_ERR;
    }

    printk("pinctrl_led major:%#x\r\n",pinctrl_led_dev.major);

    pinctrl_led_dev.cdev.owner   = THIS_MODULE;
    cdev_init(&pinctrl_led_dev.cdev, &pinctrl_led_fileops);
	ret = cdev_add(&pinctrl_led_dev.cdev, pinctrl_led_dev.devid, PINCTRL_LED_CT);

    if(ret < 0){
        printk("cdev add err\r\n");
        goto CDEV_ERR;
    }


    pinctrl_led_dev.class = class_create(THIS_MODULE, PINCTRL_LED_NAME);

	if (IS_ERR(pinctrl_led_dev.class)) {
        printk("class err\r\n");
		ret = PTR_ERR(pinctrl_led_dev.class);
		goto CLASS_ERR;
	}
	pinctrl_led_dev.device = device_create(pinctrl_led_dev.class, NULL, pinctrl_led_dev.devid, NULL,PINCTRL_LED_NAME);

    if (IS_ERR(pinctrl_led_dev.device)) {
        printk("device err\r\n");
		ret = PTR_ERR(pinctrl_led_dev.device);
		goto DEVICE_ERR;
	}

    return 0;

DEVICE_ERR:
class_destroy(pinctrl_led_dev.class);

CLASS_ERR:
    cdev_del(&pinctrl_led_dev.cdev);
CDEV_ERR:
  unregister_chrdev_region(pinctrl_led_dev.devid, PINCTRL_LED_CT);  

CHRDEV_ERR:
    return ret;
}


static void __exit pinctrl_led_exit(void)
{
    device_destroy(pinctrl_led_dev.class,pinctrl_led_dev.devid);
	class_destroy(pinctrl_led_dev.class);
    cdev_del(&pinctrl_led_dev.cdev);
    unregister_chrdev_region(pinctrl_led_dev.devid, PINCTRL_LED_CT);
}

module_init(pinctrl_led_init);
module_exit(pinctrl_led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("gale");

二、个人理解

通过这种方式来修改，后续只需要修改设备树，即可完成GPIO的初始化，相对来讲调用pinctrl控制系统来驱动GPIO，稍微简单一点，不需要自己去映射虚拟地址之类的。