S5PV210基于pinctrl和gpio点亮led

led_pinctrl: led_pinctrl {
	samsung,pins = "gpj0-3", "gpj0-4", "gpj0-5";
	samsung,pin-function = <EXYNOS_PIN_FUNC_OUTPUT>;
	samsung,pin-val = <1>;
	samsung,pin-pud = <S3C64XX_PIN_PULL_UP>;
	samsung,pin-drv = <EXYNOS4_PIN_DRV_LV1>;
};
	led: led {
	#address-cells = <1>;
	#size-cells = <1>;
	compatible = "s5pv210, led";
	pinctrl-names = "default";
	pinctrl-0 = <&led_pinctrl>;
	led_pin = <&gpj0 3 1>, <&gpj0 4 1>, <&gpj0 5 1>;
	status = "okay";
};

驱动代码：

#include <linux/module.h>		
#include <linux/init.h>
#include <linux/platform_device.h>
#include <asm/io.h>
#include <linux/types.h>
#include <linux/cdev.h>
#include <linux/fs.h>

/* dts */
#include <linux/of.h>
#include <linux/of_address.h>

/* gpio */
#include <linux/gpio.h>
#include <linux/of_gpio.h>

#define DEV_CNT		(1)
#define DEV_NAME	"s5pv210_led"

struct led_ctrl
{
	unsigned int blue_led_pin;
	unsigned int yellow_led_pin;
	unsigned int red_led_pin;

	/* char device driver*/
	dev_t dev_id;
	struct cdev led_chr_dev;
	struct class * led_class;
	struct device * led_device;
};

static struct led_ctrl g_led_ctrl = {0};

static int led_chr_dev_open(struct inode *inode, struct file *filp)
{
	printk(KERN_INFO "open driver\n");
	return 0;
}

int led_chr_dev_release(struct inode *inode, struct file *filp)
{
	printk(KERN_INFO "release driver\n");
	return 0;
}

static ssize_t led_chr_dev_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int ret = -1;
	unsigned int user_data = 0;
	ret = copy_from_user(&user_data, buf, cnt);
	if (ret < 0)
	{
		printk(KERN_INFO "copy_from_user error\n");
		return -EINVAL;
	}
	/* bit[0:7]: blue_led, bit[8:15]: yellow led, bit[16:23]: red led*/
	if (user_data & 0xff)
	{
		gpio_direction_output(g_led_ctrl.blue_led_pin, 0);
	}
	else
	{
		gpio_direction_output(g_led_ctrl.blue_led_pin, 1);
	}

	if ((user_data >> 8) & 0xff)
	{
		gpio_direction_output(g_led_ctrl.yellow_led_pin, 0);
	}
	else
	{
		gpio_direction_output(g_led_ctrl.yellow_led_pin, 1);
	}

	if ((user_data >> 16) & 0xff)
	{
		gpio_direction_output(g_led_ctrl.red_led_pin, 0);
	}
	else
	{
		gpio_direction_output(g_led_ctrl.red_led_pin, 1);
	}
	return 0;
}

/*字符设备操作函数集*/
static struct file_operations led_chr_dev_fops =
{
	.owner = THIS_MODULE,
	.open = led_chr_dev_open,
	.write = led_chr_dev_write,
};

static int s5pv210_led_probe(struct platform_device * pdev)
{
	int ret = -1;
	struct device * dev = &pdev->dev;
	struct device_node * dp_node = dev->of_node;

	g_led_ctrl.blue_led_pin = of_get_named_gpio(dp_node, "led_pin", 0);
	if (g_led_ctrl.blue_led_pin < 0)
	{
		printk(KERN_INFO "of_get_named_gpio blue error\n");
		goto of_get_named_gpio_err;
	}

	g_led_ctrl.yellow_led_pin = of_get_named_gpio(dp_node, "led_pin", 1);
	if (g_led_ctrl.yellow_led_pin < 0)
	{
		printk(KERN_INFO "of_get_named_gpio yellow error\n");
		goto of_get_named_gpio_err;
	}

	g_led_ctrl.red_led_pin = of_get_named_gpio(dp_node, "led_pin", 2);
	if (g_led_ctrl.red_led_pin < 0)
	{
		printk(KERN_INFO "of_get_named_gpio yellow red\n");
		goto of_get_named_gpio_err;
	}

	ret = devm_gpio_request_one(dev, g_led_ctrl.blue_led_pin, GPIOF_OUT_INIT_HIGH, "GPJ0_3");
	if (ret < 0)
	{
		printk(KERN_INFO "devm_gpio_request_one blue error\n");
		goto of_get_named_gpio_err;
	}
	ret = devm_gpio_request_one(dev, g_led_ctrl.yellow_led_pin, GPIOF_OUT_INIT_HIGH, "GPJ0_4");
	if (ret < 0)
	{
		printk(KERN_INFO "devm_gpio_request_one yellow error\n");
		goto gpio_request_yellow_err;
	}
	ret = devm_gpio_request_one(dev, g_led_ctrl.red_led_pin, GPIOF_OUT_INIT_HIGH, "GPJ0_5");
	if (ret < 0)
	{
		printk(KERN_INFO "devm_gpio_request_one red error\n");
		goto gpio_request_red_err;
	}

	/* char device driver*/
	ret = alloc_chrdev_region(&g_led_ctrl.dev_id, 0, DEV_CNT, DEV_NAME);
	if (ret)
	{
		printk(KERN_INFO "alloc_chrdev_region error\n");
		goto alloc_chrdev_region_err;
	}
	g_led_ctrl.led_chr_dev.owner = THIS_MODULE;
	cdev_init(&g_led_ctrl.led_chr_dev, &led_chr_dev_fops);
	ret = cdev_add(&g_led_ctrl.led_chr_dev, g_led_ctrl.dev_id, DEV_CNT);
	if (ret)
	{
		printk(KERN_INFO "cdev_add error\n");
		goto cdev_add_err;
	}
	g_led_ctrl.led_class = class_create(THIS_MODULE, DEV_NAME);
	if (NULL == g_led_ctrl.led_class)
	{
		printk(KERN_INFO "class_create error\n");
		goto class_create_err;
	}
	g_led_ctrl.led_device = device_create(g_led_ctrl.led_class, NULL, g_led_ctrl.dev_id, NULL, DEV_NAME);
	if (NULL == g_led_ctrl.led_device)
	{
		printk(KERN_INFO "device_create error\n");
		goto device_create_err;
	}
	return 0;
device_create_err:
	class_destroy(g_led_ctrl.led_class);
class_create_err:
	cdev_del(&g_led_ctrl.led_chr_dev);
cdev_add_err:
	unregister_chrdev_region(g_led_ctrl.dev_id, DEV_CNT);
alloc_chrdev_region_err:
	devm_gpio_free(dev, g_led_ctrl.red_led_pin);
gpio_request_red_err:
	devm_gpio_free(dev, g_led_ctrl.yellow_led_pin);
gpio_request_yellow_err:
	devm_gpio_free(dev, g_led_ctrl.blue_led_pin);
of_get_named_gpio_err:
	return -EINVAL;
}

static int s5pv210_led_remove(struct platform_device * pdev)
{
	struct device * dev = &pdev->dev;
	device_destroy(g_led_ctrl.led_class, g_led_ctrl.dev_id);
	class_destroy(g_led_ctrl.led_class);
	cdev_del(&g_led_ctrl.led_chr_dev);
	unregister_chrdev_region(g_led_ctrl.dev_id, DEV_CNT);
	devm_gpio_free(dev, g_led_ctrl.red_led_pin);
	devm_gpio_free(dev, g_led_ctrl.yellow_led_pin);
	devm_gpio_free(dev, g_led_ctrl.blue_led_pin);
	return 0;
}

static const struct of_device_id s5pv210_led_of_match_table[] =
{
	{.compatible = "s5pv210, led",},
	{},
};

static struct platform_driver s5pv210_led_driver = 
{
	.probe = s5pv210_led_probe,
	.remove = s5pv210_led_remove,
	.driver = {
		.name = "s5pv210_led",
		.owner = THIS_MODULE,
		.of_match_table = s5pv210_led_of_match_table,
	}
};

// 模块安装函数
static int __init chrdev_init(void)
{
	int ret = platform_driver_register(&s5pv210_led_driver);
	if (ret)
	{
		printk(KERN_INFO "platform_driver_register fail\n");
		return -EINVAL; 
	}
	printk(KERN_INFO "platform_driver_register ok\n");
	return 0;
}

// 模块卸载函数
static void __exit chrdev_exit(void)
{
	platform_driver_unregister(&s5pv210_led_driver);
	printk(KERN_INFO "platform_driver_unregister\n");
}


module_init(chrdev_init);
module_exit(chrdev_exit);

// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL");				// 描述模块的许可证
MODULE_AUTHOR("Mark");				// 描述模块的作者
MODULE_DESCRIPTION("test for driver");	// 描述模块的介绍信息
MODULE_ALIAS("alias test");			// 描述模块的别名信息