Linux CommonClock Framework分析之四 gpio clk gate驱动实现

最新推荐文章于 2024-07-29 00:33:16 发布
最新推荐文章于 2024-07-29 00:33:16 发布
阅读量1k 收藏 3
点赞数
分类专栏： Linux 设备驱动学习专栏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lickylin/article/details/107804007
版权

     前面我们已经完成了CCF子系统的分析，也说明了如何实现CCF驱动，本章为该专栏的最后一篇文章，

本章我们将实现一个虚拟的gpio clk gate驱动。本章大概分为如下几个章节：
一、 本次驱动开发涉及的知识点

 

二、clk provider driver的实现流程说明

 

三、gpio clk gate driver驱动设计

 

 

一、 本次驱动开发涉及的知识点

本次驱动实践主要涉及如下几个方面的知识点:

  1. Platform device、platform drvier
  2. Gpio 驱动使用
  3. Clk provider驱动开发流程

 

二、clk provider driver的实现流程说明

 

关于clk provider driver的开发流程，在上一篇文章中已经做了说明，此处再说明一下，主要实现流程包括如下两步：

  1. 完成clk的注册，主要是调用clk_register接口，完成上述章节一所述的内容；
  2. 完成该clk provider的map，这种map机制可以理解为定义了clk consumer与clk_provider的映射关系，即该clk provider可以给哪些clk consumer提供时钟（如针对非设备树模式，则定义了clk consumer的设备名称、clk consumer的时钟使用名称），而clk provider的map存在两种方式：
    1. 若linux不支持设备树机制，则通过调用接口clk_register_clkdev，完成这种映射操作（即完成下图中“非设备树模式下clk_core的map”）。
    2. 若linux支持设备树机制，则通过调用接口of_clk_add_provider，完成map操作（即完成下图中“设备树模式下clk_core的map”）

 

三、gpio clk gate driver驱动设计

本次我们主要实现gpio clk gate driver，本次实现的平台为ubuntu16.04，我们使用之前模拟的gpio chip

driver，提供gpio index，从而通过gpio 的值实现gpio clk gate driver。。另外针对clk gate，仅需要提供enable、disable、is_enabled接口即可。

 

相关数据结构


    结构体struct virt_gpio_clk_gate作为本次gpio clk gate driver的数据结构，主要包含clk provier device、gpio index描述信息；

struct virt_gpio_clk_gate

{

        struct gpio_desc *gpiod_clk_gate;

        struct clk_hw   hw;

};

       而结构体gpio_clk_gate_platform_data主要用于传递platform device for clk provider的enable gpio index信息，因为此次我们使用ubuntu16.04进行验证，因此使用该模式传递gpio 信息，包含gpio index、是否低有效等信息。

struct gpio_clk_gate_platform_data

{

        int enable_gpio_index;

        int active_low;

};

 

 

    gpio clk provider driver实现

        Gpio clk provider driver的实现如下，主要完成clk provider device注册、clk_ops的实现（enable、disable、is_enabled）等。如下即为clk provider driver的probe接口，主要调用clk_register完成clk provider的注册、并调用of_clk_add_provider/clk_register_clkdev实现clk provider的map。

static int virt_gpio_clk_gate_probe(struct platform_device *pdev)
{
        struct gpio_clk_gate_platform_data *pdata = (struct gpio_clk_gate_platform_data *)(pdev->dev.platform_data);
        struct virt_gpio_clk_gate * gpio_clk_gate_ptr = NULL;
        struct clk_init_data init_data;
        unsigned long gate_gpio_flag = 0;
        struct clk *clk;
        int ret = 0;
        #ifdef CONFIG_OF
        int en_gpio = 0;
        enum of_gpio_flags of_flags;
        #endif

        printk("%s %d\n", __FUNCTION__, __LINE__);
        gpio_clk_gate_ptr = devm_kzalloc(&pdev->dev, sizeof(struct virt_gpio_clk_gate), GFP_KERNEL);

        if (!gpio_clk_gate_ptr)
                return -ENOMEM;

        printk("%s %d\n", __FUNCTION__, __LINE__);
        memset(&init_data, 0, sizeof(init_data));

        init_data.num_parents = 0;
        init_data.ops = &virt_gpio_clk_gate_ops;
        init_data.name = pdev->name;
        init_data.flags = CLK_IS_ROOT;

        if(pdata != NULL)
        {
                gpio_clk_gate_ptr->gpiod_clk_gate = gpio_to_desc(pdata->enable_gpio_index);
                gpio_clk_gate_ptr->hw.init = &init_data;

                printk("%s %d\n", __FUNCTION__, __LINE__);
                if(pdata->active_low)
                        gate_gpio_flag = GPIOF_ACTIVE_LOW | GPIOF_OUT_INIT_HIGH;
                else
                        gate_gpio_flag = GPIOF_OUT_INIT_LOW;
        }

        #ifdef CONFIG_OF
        if(pdev->dev.of_node != NULL)
        {
                en_gpio = of_get_named_gpio_flags(pdev->dev.of_node, "enable-gpio", 0, &of_flags);
                if(en_gpio < 0)
                        return en_gpio;

                if(of_flags & OF_GPIO_ACTIVE_LOW)
                        gate_gpio_flag = GPIOF_ACTIVE_LOW | GPIOF_OUT_INIT_HIGH;
                else
                        gate_gpio_flag = GPIOF_OUT_INIT_LOW;

        }
        #endif

        printk("%s %d gpio index=%d\n", __FUNCTION__, __LINE__, pdata->enable_gpio_index);
        ret = devm_gpio_request_one(&pdev->dev, pdata->enable_gpio_index, gate_gpio_flag, pdev->name);
        if (ret)
        {
                printk("%s %d ret=%d\n", __FUNCTION__, __LINE__, ret);
                return ret;
        }

        printk("%s %d\n", __FUNCTION__, __LINE__);
        clk = devm_clk_register(&pdev->dev, &gpio_clk_gate_ptr->hw);
        if (IS_ERR(clk))
                return -EINVAL;

        printk("%s %d\n", __FUNCTION__, __LINE__);
        if(pdev->dev.of_node != NULL)
                return of_clk_add_provider(pdev->dev.of_node, of_clk_src_simple_get, clk);
        else
                return clk_register_clkdev(clk, "virt_gpio_gate", NULL);

        printk("%s %d\n", __FUNCTION__, __LINE__);
}

static int virt_gpio_clk_gate_remove(struct platform_device *pdev)
{


        printk("%s %d\n", __FUNCTION__, __LINE__);
        return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id of_gpio_clk_gate_match[] = {
        { .compatible = "virt_gpio_clk", },
        {},
};
#endif
static struct platform_driver gpio_clk_gate_driver = {
        .probe          = virt_gpio_clk_gate_probe,
        .remove         = virt_gpio_clk_gate_remove,
        .driver         = {
                .name   = "virt_gpio_clk",
                .owner  = THIS_MODULE,
                .of_match_table = of_match_ptr(of_gpio_clk_gate_match),
        },
};

module_platform_driver(gpio_clk_gate_driver);

MODULE_AUTHOR("jerry_chg");
MODULE_DESCRIPTION("gpio clk gate driver");
MODULE_LICENSE("GPL");

该gpio clk gate provider 的clk_ops操作接口定义如下：

#define to_clk_gpio(_hw) container_of(_hw, struct virt_gpio_clk_gate, hw)

static int virt_gpio_clk_gate_enable(struct clk_hw *hw)
{
        struct virt_gpio_clk_gate *gpio_clk_gate_ptr = to_clk_gpio(hw);

        gpiod_set_value(gpio_clk_gate_ptr->gpiod_clk_gate, 1);
        return 0;
}

static void virt_gpio_clk_gate_disable(struct clk_hw *hw)
{
        struct virt_gpio_clk_gate *gpio_clk_gate_ptr = to_clk_gpio(hw);
        gpiod_set_value(gpio_clk_gate_ptr->gpiod_clk_gate, 0);
}

static int virt_gpio_clk_gate_is_enabled(struct clk_hw *hw)
{
        struct virt_gpio_clk_gate *gpio_clk_gate_ptr = to_clk_gpio(hw);

        return gpiod_get_value(gpio_clk_gate_ptr->gpiod_clk_gate);
}

static struct clk_ops virt_gpio_clk_gate_ops =
{
        .enable = virt_gpio_clk_gate_enable,
        .disable = virt_gpio_clk_gate_disable,
        .is_enabled = virt_gpio_clk_gate_is_enabled,

};

 gpio clk consumer driver实现

     该consumer driver驱动主要用于验证gpio clk provider driver是否生效，我们在probe接口完成clk的enable操作；而在remove接口完成clk 的disable操作。接口实现如下：

static int virt_gpio_clk_consumer_probe(struct platform_device *pdev)
{
        struct virt_gpio_consumer_data *pdata = (struct virt_gpio_consumer_data *)(pdev->dev.platform_data);
        struct virt_clk_consumer *consumer_ptr = NULL;

        printk("%s %d\n", __FUNCTION__, __LINE__);
        consumer_ptr = devm_kzalloc(&pdev->dev, sizeof(struct virt_clk_consumer), GFP_KERNEL);

        if (!consumer_ptr)
                return -ENOMEM;

        printk("%s %d\n", __FUNCTION__, __LINE__);
        consumer_ptr->clk = clk_get(&pdev->dev, pdata->con_id);
        if (IS_ERR(consumer_ptr->clk))
        {
                return PTR_ERR(consumer_ptr->clk);
        }
        printk("%s %d\n", __FUNCTION__, __LINE__);
        platform_set_drvdata(pdev, consumer_ptr);
        clk_prepare_enable(consumer_ptr->clk);
        return 0;
}

static int virt_gpio_clk_consumer_remove(struct platform_device *pdev)
{
        struct virt_clk_consumer *consumer_ptr = platform_get_drvdata(pdev);

        clk_disable_unprepare(consumer_ptr->clk);
        clk_put(consumer_ptr->clk);
        printk("%s %d\n", __FUNCTION__, __LINE__);
        return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id of_gpio_clk_consumer_match[] = {
        { .compatible = "virt_gpio_consumer", },
        {},
};
#endif
static struct platform_driver gpio_clk_gate_driver = {
        .probe          = virt_gpio_clk_consumer_probe,
        .remove         = virt_gpio_clk_consumer_remove,
        .driver         = {
                .name   = "virt_gpio_consumer",
                .owner  = THIS_MODULE,
                .of_match_table = of_match_ptr(of_gpio_clk_consumer_match),
        },
};

module_platform_driver(gpio_clk_gate_driver);

MODULE_AUTHOR("jerry_chg");
MODULE_DESCRIPTION("gpio clk gate driver");
MODULE_LICENSE("GPL");

Virt gpio chip driver

该驱动使用的是gpio driver子系统专栏中实现的虚拟gpio驱动，本处不再细述，想要了解的童鞋请参考

之前的文章。

 

 

测试验证：

  • 加载virt gpio 驱动
    1. insmod virt_gpio_dev.ko；
    2. insmod virt_gpio.ko
  • 加载gpio clk gate 驱动
    1. insmod gpio_clk_platform.ko
    2. insmod gpio_clk_driver.ko
  • 加载clk consumer device驱动
    1. insmod gpio_comsumer_device.ko
  • 查看当前gpio的值：

 

  • 加载clk consumer driver驱动
    1. insmod gpio_comsumer_driver.ko
  • 查看当前gpio的值

此时gpio已经改变，clk已经使能；

 

  • 卸载clk consumer driver驱动
    1. insmod gpio_comsumer_driver.ko
  • 查看当前gpio的值

此时gpio已经修改为0，clk 已经关闭；

 

 

 

     以上就是本章的主要内容，我们主要实现一个gpio clk gate provider driver，至此我们基本上已完成CCF子系统的学习，本章的驱动代码链接如下：

https://gitee.com/jerry_chg/gpio_clk_gate.git

jerry_chg
关注
专栏目录
高通开发系列 - gpio模拟输出PWM或者CLK时钟
fulinux的博客
01-04 1450
高通开发系列 - gpio模拟输出PWM或者CLK时钟
从零开始之驱动发开、linux驱动（四十、Linux common clock framework(5)_使用举例）
To_run_away的博客
11-25 1852
前面三节分析的3.16.57内核中，三星的驱动中，恰好S5PV210的CPU没有使用Linux common clock framework来处理clk。所以，本文采用4.9.92的内核来分析S5PV210对前面第三节中时钟注册部分的使用。对于老的时钟框架，后面章节可能会用1到2部分说明一下。   首先是根据设备树传过来来的时钟资源的寄存器地址做地址映射，后面则就是使用设备树节点做大量的时钟...
【嵌入式Linux】i.MX6ULL 时钟树——理论分析
Beihai_Van的博客
06-22 972
本文章结合了正点原子的**i.mx6u嵌入式Linux开发指南**和笔者的理解。 本文章应配合《【嵌入式Linux】i.MX6ULL 时钟树——代码梳理（基础时钟初始化）》使用。
精通 Linux 设备驱动开发（二）
最新发布
龙哥盟
07-29 313
在深入研究 syscon 框架及其 API 之前，我们将介绍 MFD。有些外围设备或硬件块通过它们嵌入的子设备来提供多个功能，这些子设备由内核中的单独子系统处理。也就是说，子设备是所谓的多功能设备中的专用实体，负责特定任务，并通过芯片的寄存器映射中的一组减少的寄存器进行管理。ADP5520是 MFD 设备的典型示例，因为它包含背光、键盘、LED 和 GPIO 控制器。每个子设备都被视为一个子设备，正如您所看到的，每个子设备都属于不同的子系统。MFD 子系统定义在中，并在。
android应用程序访问/sys下节点(gpioclk)
qq_35141454的博客
10-10 715
1.位置:device/qcom/common/rootdir/etc/init.qcom.rc 添加， chmod 777 /sys/devices/soc/soc:qcom,gpioclk/gpio_clock_duty chmod 777 /sys/devices/soc/soc:qcom,gpioclk/gpio_clock_enable 2.位置：device/qcom/sepo...
设备树与驱动的关系_Linux CommonClock Framework分析之四 gpio clk gate驱动实现
weixin_39664696的博客
12-06 172
前面我们已经完成了CCF子系统的分析，也说明了如何实现CCF驱动，本章为该专栏的最后一篇文章， 本章我们将实现一个虚拟的gpio clk gate驱动。本章大概分为如下几个章节：一、 本次驱动开发涉及的知识点二、clk provider driver的实现流程说明三、gpio clk gate driver驱动设计一、 本次驱动开发涉及的知识点本次驱动实践主要涉及如下几个方面的知识点:Platf...
clock gate cell 时钟门控单元
qq446293528的博客
09-21 6447
1、结构图（锁存器，与门，D触发器） latch或reg：用于同步使能信号，防止出现亚稳态和毛刺。 与门：使能信号无效时，关断模块输入时钟。 D触发器：简化的reg。 2、为什么需要clk gate？ 模块不工作时，clk翻转浪费功耗。模块/reg相当于一个DFF，但是en为高时，模块才工作，clk才有效。不工作时，clk翻转浪费功耗。 3、如何clk gate？ 将一直翻转的时钟变为en有效才翻转的时钟，即将CLK转化为CLK_G。 4、基于与门的clk gate（会有右图所示问题
STM32 -- 笔记一 -- CLK、GPIO、PWM
非常懒的博主
03-09 8439
时钟时钟源：HSI、HSE、LSI、LSE、PLL 时钟频率都不一样。 为什么要多个时钟源？ A：STM32拥有者丰富的外设，这些外设需要的时钟频率不一定都要有系统时钟那么高，像是看门狗，只需要几十k的时钟频率即可。并且，同一个电路，时钟越快功耗越大，同时，抗电磁干扰能力也会越弱。 系统时钟SYSCLK的分频： 通过AHB分频器分频以后送给各模块使用 模块包括总线，内核，内存，DMA等
clock gate spec
weixin_42614350的博客
03-29 849
clock gate specclock gate distributioncombinational clock gatingIntegrated Gated Clock Cells（ICG Cell） clock gate distribution clock gate 有两种实现技术， combinational clock gating 和 sequential clock gating，其中 combinational clock gating 是由dc工具在综合时自动添加的，而sequenti
linux内核gpio模拟spi驱动,Linux gpio模拟spi
weixin_42377196的博客
05-04 1976
1.config配置首先是spidev，要在/dev/下面产生设备文件，需要spidev的支持CONFIG_SPI_SPIDEV=y使用的是gpio模拟spi，gpio模拟spi的时序原理是bitbang文件实现的，所以这个也需要打开，如果是在openwrt下动态加载的话就是如下两个配置CONFIG_PACKAGE_kmod-spi-bitbang=y+CONFIG_PACKAGE_kmod-sp...
Linux通过GPIO状态实现按键上报(按键功能)
大昱的博客
01-20 3588
  GPIO是集成电路或电子电路板上未提交的数字信号引脚，用于将微控制器连接到其他电子设备的标准接口。当然，我们也可以通过几个GPIO口编写一个键盘驱动，驱动挂载后拥有按键功能。   示例驱动基于ARM64架构开发，其中用到的知识将会在文章中讲述。 设备树 platform 工作队列 input 设备树：   设备树是一种描述硬件的数据结构，它起源于OpenF...
在ARM Linux下使用GPIO模拟SPI时序详解
02-25
在ARM Linux下使用GPIO模拟SPI时序详解.pdf
linux设备驱动 gpio,在Linux驱动中使用gpio子系统
weixin_35565522的博客
05-08 3032
reference：内核相关文档Documentation\devicetree\bindings\pinctrl\pinctrl-bindings.txtDocumentation\gpio\gpio.txtDocumentation\devicetree\bindings\gpio\gpio.txt背景随着内核的发展，linux驱动框架在不断的变化。在早期，GPIO子系统存在之前，我们驱动需要...
linux内核gpio模拟spi驱动,linux/Android 使用GPIO口模拟SPI 总线和设备驱动
weixin_34571272的博客
05-04 1657
linux 使用gpio模拟spi总线的驱动文件是kernel/drivers/spi/spi_gpio.c,它里面包含了spi总线的注册，而具体的通过GPIO模拟spi读写方法的会在里面调用 kerneldriversSpi/Spi_bitbang.c中的方法，这个方法封装在 kerneldriversSpi/Spi_bitbang_txrx.h中的bitbang_txrx_be_cpha0()...
Linux芯片级移植与底层驱动（基于3.7.4内核）(GPIO&&pinctrl&&clk)
myxmu的专栏
04-04 4359
7.   pinctrl驱动 许多SoC内部都包含pin控制器，通过pin控制器的寄存器，我们可以配置一个或者一组引脚的功能和特性。在软件上，Linux内核的pinctrl驱动可以操作pin控制器为我们完成如下工作： §  枚举并且命名pin控制器可控制的所有引脚； §  提供引脚复用的能力； §  提供配置引脚的能力，如驱动能力、上拉下拉、开漏（open drain）等。
一文搞懂 | Linux 时钟子系统
Peter的专栏
12-28 1961
Clock 时钟就是 SoC 中的脉搏，由它来控制各个部件按各自的节奏跳动。比如，CPU主频设置，串口的波特率设置，I2S的采样率设置，I2C的速率设置等等。这些不同的clock设置，都需...
Linux CommonClock Framework分析之三 驱动开发流程说明
lickylin的专栏
08-02 1201
在上两篇文章中，我们简要介绍了CCF子系统内部的设计，并说明了CCF子系统内部数据结构的定义及关联。本篇文章主要介绍CCF子系统下驱动程序的开发，本章涉及如下三个方面的内容： 一、clk注册与注销接口说明 二、clk驱动开发流程 三、clk使用流程 四、依据clk provider用途封装的注册接口 一、clk注册与注销接口说明 clk注册与注销接口分别为clk_register、clk_unregister,在上一章我们已经简要说过，c...
Linux clock driver（2） clk_register 详解
往事随风的博客
11-16 2400
clock driver（2） clk_register 详解clk_register是底层clock driver用来向CCF（common clock framework）层注册时钟节点的接口，是CCF中的关键函数之一，下面将结合程序详细介绍其功能。先看一下来看一下 clk_register 函数的实现：struct clk *clk_register(struct device *dev, s
第20章　Linux芯片级移植及底层驱动之时钟驱动
xiezhi123456的博客
06-10 911
20.8　时钟驱动    在一个SoC中，晶振、PLL、驱动和门等会形成一个时钟树形结构，在Linux 2.6中，也存有clk_get_rate（）、clk_set_rate（）、clk_get_parent（）、clk_set_parent（）等通用API，但是这些API由每个SoC单独实现，而且各个SoC供应商在实现方面的差异很大，于是内核增加了一个新的通用时钟框架以解决这个碎片化问题。之所以...
S3C6410 GPIO驱动详解与实现
本文档主要探讨了三星S3C6410处理器的通用输入/输出(GPIO)驱动程序的分析。作为初学者在ARM-Linux平台上的学习项目，作者在研究过程中遇到了并解决了GPIO驱动的相关问题，旨在分享自己的经验以便为其他同样入门的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值