GPIO控制灯驱动

最新推荐文章于 2023-05-11 13:08:51 发布
最新推荐文章于 2023-05-11 13:08:51 发布
阅读量1k 收藏 1
点赞数
文章标签： 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/max_0711/article/details/124108537
版权

#include <linux/kernel.h>

#include <linux/types.h>

#include <linux/module.h>

#include <linux/init.h>

#include <linux/gpio.h>

#include <linux/err.h>

#include <linux/device.h>

#include <linux/delay.h>

#include <linux/of_gpio.h>

#include <linux/clk.h>

#include <linux/interrupt.h>

#include <linux/rfkill.h>

#include <linux/regulator/consumer.h>

#include <linux/platform_device.h>

#include <linux/sunxi-gpio.h>

#include <linux/etherdevice.h>

#include <linux/miscdevice.h>

#include <linux/capability.h>

#include <linux/pm_wakeirq.h>

#include "sunxi-rfkill.h"

struct sunxi_wlan_platdata {

    struct pinctrl *pctrl;

    int gpio_red_led;

    int gpio_green_led;

    int gpio_blue_led;

    int gpio_power_en;

    struct platform_device *pdev;

};

static struct sunxi_wlan_platdata *wlan_data;

static int sunxi_wlan_on(struct sunxi_wlan_platdata *data, bool on_off);

static DEFINE_MUTEX(sunxi_wlan_mutex);

void sunxi_wl_poweren_set(int dev, int on_off)

{

    /* Only wifi and bt both close, power_en goes down,

     * otherwise, set power_en up to keep module work.

     * dev   : device to set power status. 0: wifi, 1: bt

     * on_off: power status to set. 0: off, 1: on

     */

    static int power_state;

    if (dev == WL_DEV_WIFI || dev == WL_DEV_BLUETOOTH) {

        power_state &= ~(1 << dev);

        power_state |= ((on_off > 0) << dev);

    }

    if (gpio_is_valid(wlan_data->gpio_power_en))

        gpio_set_value(wlan_data->gpio_power_en, (power_state != 0));

}

EXPORT_SYMBOL_GPL(sunxi_wl_poweren_set);

void sunxi_wlan_set_power(bool on_off)

{

    struct platform_device *pdev;

    int ret = 0;

    if (!wlan_data)

        return;

    pdev = wlan_data->pdev;

    mutex_lock(&sunxi_wlan_mutex);

    sunxi_wl_poweren_set(WL_DEV_WIFI, on_off);

    if (on_off != wlan_data->power_state) {

        ret = sunxi_wlan_on(wlan_data, on_off);

        if (ret)

            dev_err(&pdev->dev, "set power failed\n");

    }

    sunxi_wl_chipen_set(WL_DEV_WIFI, on_off);

    mutex_unlock(&sunxi_wlan_mutex);

}

EXPORT_SYMBOL_GPL(sunxi_wlan_set_power);

static int sunxi_wlan_on(struct sunxi_wlan_platdata *data, bool on_off)

{

    struct platform_device *pdev = data->pdev;

    struct device *dev = &pdev->dev;

    int ret = 0;

    if (!on_off && gpio_is_valid(data->gpio_wlan_regon))

        gpio_set_value(data->gpio_wlan_regon, 0);

    if (data->wlan_power_name) {

        data->wlan_power = regulator_get(dev, data->wlan_power_name);

        if (!IS_ERR(data->wlan_power)) {

            if (on_off) {

                ret = regulator_enable(data->wlan_power);

                if (ret < 0) {

                    dev_err(dev, "regulator wlan_power enable failed\n");

                    regulator_put(data->wlan_power);

                    return ret;

                }

                ret = regulator_get_voltage(data->wlan_power);

                if (ret < 0) {

                    dev_err(dev, "regulator wlan_power get voltage failed\n");

                    regulator_put(data->wlan_power);

                    return ret;

                }

                dev_info(dev, "check wlan wlan_power voltage: %d\n",

                         ret);

            } else {

                ret = regulator_disable(data->wlan_power);

                if (ret < 0) {

                    dev_err(dev, "regulator wlan_power disable failed\n");

                    regulator_put(data->wlan_power);

                    return ret;

                }

            }

            regulator_put(data->wlan_power);

        }

    }

    if (data->io_regulator_name) {

        data->io_regulator = regulator_get(dev,

                data->io_regulator_name);

        if (!IS_ERR(data->io_regulator)) {

            if (on_off) {

                ret = regulator_enable(data->io_regulator);

                if (ret < 0) {

                    dev_err(dev, "regulator io_regulator enable failed\n");

                    regulator_put(data->io_regulator);

                    return ret;

                }

                ret = regulator_get_voltage(data->io_regulator);

                if (ret < 0) {

                    dev_err(dev, "regulator io_regulator get voltage failed\n");

                    regulator_put(data->io_regulator);

                    return ret;

                }

                dev_info(dev, "check wlan io_regulator voltage: %d\n",

                        ret);

            } else {

                ret = regulator_disable(data->io_regulator);

                if (ret < 0) {

                    dev_err(dev, "regulator io_regulator disable failed\n");

                    regulator_put(data->io_regulator);

                    return ret;

                }

            }

            regulator_put(data->io_regulator);

        }

    }

    if (on_off && gpio_is_valid(data->gpio_wlan_regon)) {

        mdelay(10);

        gpio_set_value(data->gpio_wlan_regon, 1);

    }

    wlan_data->power_state = on_off;

    return 0;

}

static ssize_t power_state_show(struct device *dev,

    struct device_attribute *attr, char *buf)

{

    return sprintf(buf, "%d\n", wlan_data->power_state);

}

static ssize_t power_state_store(struct device *dev,

    struct device_attribute *attr, const char *buf, size_t count)

{

    unsigned long state;

    int err;

    if (!capable(CAP_NET_ADMIN))

        return -EPERM;

    err = kstrtoul(buf, 0, &state);

    if (err)

        return err;

    if (state > 1)

        return -EINVAL;

    if (state != wlan_data->power_state) {

        sunxi_wlan_set_power(state);

    }

    return count;

}

static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR,

        power_state_show, power_state_store);

static ssize_t scan_device_store(struct device *dev,

    struct device_attribute *attr, const char *buf, size_t count)

{

    unsigned long state;

    int err;

    int bus = wlan_data->bus_index;

    err = kstrtoul(buf, 0, &state);

    if (err)

        return err;

    dev_info(dev, "start scan device on bus_index: %d\n",

            wlan_data->bus_index);

    if (bus < 0) {

        dev_err(dev, "scan device fail!\n");

        return -1;

    }

    sunxi_mmc_rescan_card(bus);

    return count;

}

static DEVICE_ATTR(scan_device, S_IRUGO | S_IWUSR,

        NULL, scan_device_store);

static struct attribute *misc_attributes[] = {

    &dev_attr_power_state.attr,

    &dev_attr_scan_device.attr,

    NULL,

};

static struct attribute_group misc_attribute_group = {

    .name  = "rf-ctrl",

    .attrs = misc_attributes,

};

static struct miscdevice sunxi_wlan_dev = {

    .minor = MISC_DYNAMIC_MINOR,

    .name  = "sunxi-led",

};

static int sunxi_wlan_probe(struct platform_device *pdev)

{

    struct device_node *np = pdev->dev.of_node;

    struct device *dev = &pdev->dev;

    struct sunxi_wlan_platdata *data;

    struct gpio_config config;

    int ret = 0;

    // struct pinctrl_state *pctrl_state = NULL;

    data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);

    if (!dev)

        return -ENOMEM;

    data->pdev = pdev;

    wlan_data = data;


 

    //RED

    data->gpio_red_led = of_get_named_gpio_flags(np, "h616_red",

            0, (enum of_gpio_flags *)&config);

    if (!gpio_is_valid(data->gpio_red_led)) {

        dev_err(dev, "get gpio gpio_red_led failed\n");

    } else {

        dev_info(dev, "wlan_regon gpio=%d  mul-sel=%d  pull=%d  drv_level=%d  data=%d\n",

                config.gpio,

                config.mul_sel,

                config.pull,

                config.drv_level,

                config.data);

        ret = devm_gpio_request(dev, data->gpio_red_led,

                "h616_red");

        if (ret < 0) {

            dev_err(dev, "can't request gpio_red_led gpio %d\n",

                data->gpio_red_led);

            return ret;

        }

        ret = gpio_direction_output(data->gpio_red_led, 0);

        if (ret < 0) {

            dev_err(dev, "can't request output direction gpio_red_led gpio %d\n",

                data->gpio_red_led);

            return ret;

        }

    }

    //GREEN

    data->gpio_green_led = of_get_named_gpio_flags(np, "h616_green",

            0, (enum of_gpio_flags *)&config);

    if (!gpio_is_valid(data->gpio_green_led)) {

        dev_err(dev, "get gpio gpio_green_led failed\n");

    } else {

        dev_info(dev, "gpio_green_led gpio=%d  mul-sel=%d  pull=%d  drv_level=%d  data=%d\n",

                config.gpio,

                config.mul_sel,

                config.pull,

                config.drv_level,

                config.data);

        ret = devm_gpio_request(dev, data->gpio_green_led,

                "h616_green");

        if (ret < 0) {

            dev_err(dev, "can't request gpio_green_led gpio %d\n",

                data->gpio_green_led);

            return ret;

        }

        ret = gpio_direction_output(data->gpio_green_led, 0);

        if (ret < 0) {

            dev_err(dev, "can't request output direction gpio_green_led gpio %d\n",

                data->gpio_green_led);

            return ret;

        }

    }

    //BLUE 

    data->gpio_blue_led = of_get_named_gpio_flags(np, "h616_blue",

            0, (enum of_gpio_flags *)&config);

    if (!gpio_is_valid(data->gpio_blue_led)) {

        dev_err(dev, "get gpio gpio_blue_led failed\n");

    } else {

        dev_info(dev, "gpio_blue_led gpio=%d  mul-sel=%d  pull=%d  drv_level=%d  data=%d\n",

                config.gpio,

                config.mul_sel,

                config.pull,

                config.drv_level,

                config.data);

        ret = devm_gpio_request(dev, data->gpio_blue_led,

                "h616_blue");

        if (ret < 0) {

            dev_err(dev, "can't request gpio_blue_led gpio %d\n",

                data->gpio_blue_led);

            return ret;

        }

        ret = gpio_direction_output(data->gpio_blue_led, 0);

        if (ret < 0) {

            dev_err(dev, "can't request output direction gpio_blue_led gpio %d\n",

                data->gpio_blue_led);

            return ret;

        }

    }      

    //获取某个GPIO状态

    // data->pctrl = devm_pinctrl_get(dev);

    // if (IS_ERR(data->pctrl)) {

    //  dev_warn(dev, "devm_pinctrl_get() failed!\n");

    // } else {

    //  pctrl_state = pinctrl_lookup_state(data->pctrl, pctrl_name);

    //  if (IS_ERR(pctrl_state)) {

    //      dev_warn(dev, "pinctrl_lookup_state(%s) failed! return %p \n",

    //              pctrl_name, pctrl_state);

    //  } else {

    //      ret = pinctrl_select_state(data->pctrl, pctrl_state);

    //      if (ret < 0) {

    //          dev_warn(dev, "pinctrl_select_state(%s) failed! return %d \n",

    //                  pctrl_name, ret);

    //      }

    //  }

    // }

    ret = misc_register(&sunxi_wlan_dev);

    if (ret) {

        dev_err(dev, "sunxi-wlan register driver as misc device error!\n");

        return ret;

    }

    ret = sysfs_create_group(&sunxi_wlan_dev.this_device->kobj,

            &misc_attribute_group);

    if (ret) {

        dev_err(dev, "sunxi-wlan register sysfs create group failed!\n");

        return ret;

    }

    return 0;

}

static int sunxi_wlan_remove(struct platform_device *pdev)

{

    misc_deregister(&sunxi_wlan_dev);

    sysfs_remove_group(&(sunxi_wlan_dev.this_device->kobj),

            &misc_attribute_group);

    return 0;

}

static const struct of_device_id sunxi_wlan_ids[] = {

    { .compatible = "allwinner,sunxi-led" },

    { /* Sentinel */ }

};

static struct platform_driver sunxi_wlan_driver = {

    .probe      = sunxi_wlan_probe,

    .remove = sunxi_wlan_remove,

    .driver = {

        .owner  = THIS_MODULE,

        .name   = "sunxi-led",

        .of_match_table = sunxi_wlan_ids,

    },

};

static int __init sunxi_h616_led_init(void) 

{ 

    return platform_driver_register(&sunxi_wlan_driver); 

} 

module_init(sunxi_h616_led_init); 

static void __exit sunxi_h616_led_exit(void) 

{ 

    return platform_driver_unregister(&sunxi_wlan_driver); 

} 

module_exit(sunxi_h616_led_exit);

//module_platform_driver(sunxi_wlan_driver);

MODULE_LICENSE("GPL");

MODULE_AUTHOR("huangbenyan");

MODULE_DESCRIPTION("sunxi led driver");

MODULE_ALIAS("led");

dts配置

        led:led {
            compatible    = "allwinner,sunxi-led";
            h616_red      = <&pio PH 6 1 0xffffffff 0xffffffff 0>;
            h616_green      = <&pio PH 7 1 0xffffffff 0xffffffff 0>;
            h616_blue      = <&pio PH 8 1 0xffffffff 0xffffffff 0>;
            status        = "okay";
        }

励志成为扫地僧
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux GPIO子系统速览
m0_49328056的博客
12-08 673
Linux GPIO子系统
嵌入式GPIO控制led灯驱动源代码和Makefile编译文件和应用层文件源代码
05-27
嵌入式GPIO控制led灯驱动源代码和Makefile编译文件和应用层文件源代码
android平台通过GPIO口控制LED
11-07
android平台通过GPIO口控制LED灯
基于STM32的WS2812灯带驱动（GPIO口控制，无需驱动芯片或模块）
08-16
基于STM32的WS2812灯带驱动（GPIO口控制，无需驱动芯片或模块） 文章：https://blog.csdn.net/weixin_53403301/article/details/126366119
库函数驱动外设的应用实例：应用STM32的GPIO控制LED灯的亮灭，实现闪亮、跑马灯、流水灯等效果
05-08
例题：使用STM32的GPIOB口控制8个LED灯的亮灭。STM32有7个GPIO口，每个GPIO口有16个引脚，使用其中的8-15引脚对8个LED灯进行控制，可以实现闪亮、跑马灯、流水灯等效果。开发工具为Keil MDK5（最新版本），兼容低版本（本例题程序使用库函数：GPIO_SetBits和GPIO_ResetBits实现对LED亮灭的控制）
蔡工驱动开发实战之操作GPIO控制LED灯亮灭
07-01
本课程主要是给学员分享编写一个GPIO控制板子的LED灯的项目过程，让大家学会如何从无到有地编写一个GPIO驱动，创建设备节点操作GPIO，创建工作队列循环操作GPIO； 课程通过结合开发板，一边添加代码一边调试，现场查看代码的运行过程，现场debug，包括写代码，编译驱动跑起来还有对应打印底层log来debug驱动的过程。 这里是基于rk3288平台上的项目，android版本是7.1，kernel版本是4.4。
概述Linux内核驱动之GPIO子系统API接口
m0_74282605的博客
11-14 4514
在嵌入式Linux开发中，对嵌入式SoC中的GPIO进行控制非常重要，Linux内核中提供了GPIO子系统，驱动开发者在驱动代码中使用GPIO子系统提供的API函数，便可以达到对GPIO控制的效果，例如将IO口的方向设置为输入或输出，当IO口的方向为输入时，可以通过调用API函数获取相应的IO口电平，当IO口设置为输出方向时，可以调用相关的API函数去设置IO口电平，本文将简单描述如何去使用Linux内核中GPIO子系统的API接口。
gpio子系统与pinctrl子系统四：使用
10-20 1251
主要是如何使用gpiolib相关接口，进行驱动开发。
gpio子系统和pinctrl子系统（上）
10-22 1083
前言 　　随着内核的发展，linux驱动框架在不断的变化。很早很早以前，出现了gpio子系统，后来又出现了pinctrl子系统。在网上很难看到一篇讲解这类子系统的文章。就拿gpio操作来说吧，很多时候都是简单的调用gpio子系统提供的api，然后根据sdk说明文档写明的gpio号传参数，至于里面的工作过程对于驱动工程师而言就像个黑盒子。当我们自己设计的板子和demo板有很大变动时，问题就出现了。首先遇到的是怎么配置pin(是基于设备树还是不基于设备树，基于设备树的话，怎么修改设备树关于pinctrl部分的
devm_gpio_request_one 函数
qq_23174771的博客
05-11 2104
devm_gpio_request_one 函数
【RT-Thread】改Kconfig文件参数时，在drv_gpio.h文件里找不到对应IO口引脚序号解决方法
weixin_44549777的博客
05-07 684
问题 在做一个STM32F1的I2C相关实验时，需要更改IO对应相关引脚序号，如下图所示。 资料上说在drv_gpio.h里寻找对应IO口序号，类似于如下格式。 查看自己的drv_gpio.c文件发现缺没有相关代码，原来最新的官方bsp把该代码优化掉了。 解决方法 使用FinSH控制台或串口打印将指定IO口的序号输出，即可得到相关参数，利用GET_PIN(C, 12)宏定义即可得到，FinSH控制台代码如下↓ #include "board.h" void test_hello(void) {
Linux设备驱动开发详解
Software designers are not code farmers
04-09 480
GPIO子系统 驱动使用 定义设备树 gpioled { #address-cells = <1>; #size-cells = <1>; compatible = "atkalpha-gpioled"; pinctrl-names = "default"; pinctrl-0 = <&pinctrl_led&g...
设备树的获取 API
zmjames2000 Just record
02-22 996
come from :https://blog.csdn.net/fengyuwuzu0519/article/details/74352188 二、常用函数 设备树函数思路是： uboot启动时将设备树地址传给内核，内核解析设备树，并创建设备，初始化相关属性，驱动中通 of_get_XXX函数去获取设备树加载时创建的设备。想要知道of函数做了什么，就去追踪这个函数最后调用了什么，同时也就知道...
Linux 内核层和 用户层 配置 GPIO 引脚
Linux_ARM_G的博客
11-12 3221
　Linux BSP 开发的基础就是和GPIO打交道， 下面总结下这几天对某家开发板的GPIO控制的知识。 　　公司的开发板用的是 DTB  模式 ，首先，进入 dts，dtsi文件查看关于GPIO 的模块。 soc { . . . gpio0: gpio@****addr {...
devm_gpio_request_one申请gpio失败，返回-16
热门推荐
weixin_37723417的博客
09-11 1万+
在驱动中调用devm_gpio_request_one（）函数失败，返回错误值是-16 如下是错误码对应的描述 EBUSY 16 Device or resource busy 说明这个接口处于繁忙状态，大致推测是在被使用了。 通过搜索设备树，发现这个gpio号确实被另一个驱动调用了，先把他注销掉，释放出来给我试用 下面...
RK-GPIO基本知识，开发，调试
GS0821606
05-14 1万+
文章目录简介开发DTS配置GPIO 常用API中断复用复用API调试方法IO指令例子 查看i2c3 复用情况GPIO调式接口 简介 GPIO, 全称 General-Purpose Input/Output（通用输入输出），是一种软件运行期间能够动态配置和控制的通用引脚。 RK3399有5组GPIO bank：GPIO0~GPIO4，每组又以 A0~A7, B0~B7, C0~C7, D0~D7 ...
Linux GPIO子系统API
大帅的博客
10-05 2739
Linux GPIO子系统API static inline bool gpio_is_valid(int number) 该函数用来判断获取到的gpio号是否是有效的，只有有效的gpio号，才能向内核中进行申请使用，因此，当我们从设备树的设备节点获取到gpio号，可以使用该函数进行判断是否有效。 int gpio_request(unsigned gpio, const char *label) 该函数用于申请一个 GPIO管脚，在使用一个 GPIO之前一定要使用 gpio_request进行申请。
[Linux 基础] -- gpio 子系统和 pinctrl 子系统（上）
u014674293的博客
12-05 1316
前言 随着内核的发展，linux驱动框架在不断的变化。很早很早以前，出现了gpio子系统，后来又出现了pinctrl子系统。在网上很难看到一篇讲解这类子系统的文章。就拿gpio操作来说吧，很多时候都是简单的调用gpio子系统提供的api，然后根据sdk说明文档写明的gpio号传参数，至于里面的工作过程对于驱动工程师而言就像个黑盒子。当我们自己设计的板子和demo板有很大变动时，问题就出现了。首先...
Linux GPIO驱动部分函数
weixin_61810331的博客
10-21 3663
Linux GPIO端口驱动部分函数
gpio控制器的跑马灯设计与实现
最新发布
01-18
gpio控制器是一种用于控制外部设备的芯片，它可以控制LED灯的闪烁。跑马灯设计是一种以特定模式闪烁的LED灯。 首先，我们需要选择一个适合的gpio控制器和LED灯。然后，我们需要连接LED灯到gpio控制器的输出引脚上。接着，我们需要在系统内核中开启gpio控制器的相关功能，并配置相应的引脚为输出模式。 接下来，我们可以通过编写相应的驱动程序来控制gpio控制器，使LED灯按照跑马灯的设计进行闪烁。例如，我们可以编写一个循环程序，依次点亮不同的LED灯，再逐个关闭，并不断循环。 在实现跑马灯的过程中，我们需要注意控制LED灯的亮灭时间和顺序，使得它们能够呈现出跑马灯的效果。另外，我们还可以根据实际需求调整闪烁的速度和模式。 最后，通过测试和调试，我们可以验证gpio控制器的跑马灯设计与实现是否成功。如果一切正常，LED灯将按照我们设计的跑马灯模式进行闪烁。 总的来说，gpio控制器的跑马灯设计与实现需要选择合适的硬件和编写相应的驱动程序，经过测试和调试，最终可以实现跑马灯效果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值