linuxGPIO的设置-使用LED的驱动

最新推荐文章于 2024-09-02 21:09:47 发布
最新推荐文章于 2024-09-02 21:09:47 发布
阅读量1.7k 收藏 5
点赞数
分类专栏： linux c 文章标签： 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaozhi0810/article/details/124921127
版权

因为我的引脚控制比较简单，只需要固定的输出高低电平就可以了，也没有其他需求。所以就搭上leds-gpio的驱动吧，自己就不用写了。

首先，内核中增加leds-gpio的驱动。

根据Kconfig和Make file 和帮助信息，可以定位到图中的选项。

第一步先定位到led的驱动是哪一个

第二步，查看该目录中的Makefile

vim drivers/leds/Makefile

找到这个相关的配置项

第三步，make menuconfig的时候找到对应的CONFIG就行，右斜杆，弹出搜索界面

 在帮助信息中可以看到我需要勾选的选项了。

第四步，保存退出，重新编译内核

第五步，修改dts，可以参考其他dts文件修改。

 

这里我修改PMON的dts，因为我的linux加载时使用的是pmon的dtb

	gpio-conf422 {
		compatible = "gpio-leds";

		re0 {
			label = "re0";
			gpios = <&pioA 50 0>;
		};
		de0 {
			label = "de0";
			gpios = <&pioA 51 0>;
			default-state = "on";
		};
		re1 {
			label = "re1";
			gpios = <&pioA 48 0>;
		};
		de1 {
			label = "de1";
			gpios = <&pioA 49 0>;
			default-state = "on";			
		};
	};

全部dts如下：

/*
 * 2K1000 Device Tree Source for LS2K1000 boards
 */

/dts-v1/;
/ {
    model = "loongson,LS2k1000-EVP";
    compatible = "loongson,ls2k";
    #address-cells = <2>;
    #size-cells = <2>;

    // Since 2K1000 support > 4GiB DIMM, use 2 cell for and address size
    memory {
        name = "memory";
        device_type = "memory";
//#ifdef NOGPU
        reg =  <0 0x00200000 0 0x0ce00000    // 200MiB at 2MiB
//#else
//        reg =  <0 0x00200000 0 0x0ee00000    // 200MiB at 2MiB
//#endif
//            1 0x10000000 1 0xb0000000>;    // 7424 - 512 MiB at 4352MiB
            1 0x10000000 0 0xd0000000>;    // 4G 7424 - 512 MiB at 4352MiB
    };

    aliases {
        ethernet0 = &gmac0;
        ethernet1 = &gmac1;
    };

    // all soc device use 32bit address

    soc {
        compatible = "ls,nbus", "simple-bus";
        #address-cells = <1>;
        #size-cells = <1>;
        ranges = <0x10000000 0 0x10000000 0x10000000
              0x40000000 0 0x40000000 0x40000000
              0x20000000 0 0x20000000 0x20000000
                        0x0d000000 0 0x0d000000 0x02000000>;

        dma-coherent;
        nr_cpus_loongson = <2>;
        cores_per_package = <2>;

        icu: interrupt-controller@1fe11400 {
            compatible = "loongson,2k-icu";
            interrupt-controller;
            #interrupt-cells = <1>;
            reg = <0x1fe11400 0x40>;
        };

        msi: pci-msi-controller@1fe114a0 {
            compatible = "loongson,2k-pci-msi";
            msi-controller;
            interrupt-parent = <&icu>;
            msi-mask = <0x000000c0 0x40000c00>;
            reg = <0x1fe114a0 0x60>;
        };

        /* HDA controller nodes:
         * If you want to use the "hda" function,enable the "hda"
         * controller by configure general configuration register 0.
         */
        /*hda@0x400d0000 {
            compatible = "loongson,ls-audio";
            reg = <0x400d0000 0xffff>;
            interrupt-parent = <&icu>;
            interrupts = <12>;
        };*/

        dc@0x400c0000 {
            compatible = "loongson,ls-fb";
            reg = <0x400c0000 0x10000
//#ifdef NOGPU
                   0x0d000000 0x2000000>;
//#else
//                   0x20000000 0x8000000>;
//#endif
            interrupt-parent = <&icu>;
            interrupts = <36>;
        };

#ifndef NOGPU
//        gpu@0x40080000 {
//            compatible = "loongson,galcore";
//            reg = <0x40080000 0x40000
//                0x2a000000 0x15000000>;
//            interrupt-parent = <&icu>;
//            interrupts = <37>;
//        };
#endif

        ohci@0x40070000 {
            compatible = "loongson,ls2k-ohci", "usb-ohci", "generic-ohci";
            reg = <0x40070000 0x10000>;
            interrupt-parent = <&icu>;
            interrupts = <59>;
            dma-mask = <0x0 0xffffffff>;
        };

        ehci@0x40060000 {
            compatible = "loongson,ls2k-ehci", "usb-ehci";
            reg = <0x40060000 0x10000>;
            interrupt-parent = <&icu>;
            interrupts = <58>;
            dma-mask = <0xffffffff 0xffffffff>;
        };

        otg@0x40000000 {
            compatible = "loongson,dwc-otg", "dwc-otg";
            reg = <0x40000000 0x40000>;
            interrupt-parent = <&icu>;
            interrupts = <57>;
            dma-mask = <0x0 0xffffffff>;
        };

        ahci@0x400e0000{
            compatible = "snps,spear-ahci";
            reg = <0x400e0000 0x10000>;
            interrupt-parent = <&icu>;
            interrupts = <27>;
            dma-mask = <0x0 0xffffffff>;
        };

        gmac0: ethernet@0x40040000 {
            compatible = "snps,dwmac-3.70a", "ls,ls-gmac";
            reg = <0x40040000 0x10000>;
            interrupt-parent = <&icu>;
            interrupts = <20 21>;
            interrupt-names = "macirq", "eth_wake_irq";
            mac-address = [ 64 48 48 48 48 60 ];/* [>mac 64:48:48:48:48:60 <]*/
            phy-mode = "rgmii";
            bus_id = <0x0>;
            phy_addr = <0xffffffff>;
            dma-mask = <0xffffffff 0xffffffff>;
        };
#if 1
        gmac1: ethernet@0x40050000 {
            compatible = "snps,dwmac-3.70a", "ls,ls-gmac";
            reg = <0x40050000 0x10000>;
            interrupt-parent = <&icu>;
            interrupts = <22 23>;
            interrupt-names = "macirq", "eth_wake_irq";
            mac-address = [ 64 48 48 48 48 61 ];/* [>mac 64:48:48:48:48:61 <]*/
            phy-mode = "rgmii";
            bus_id = <0x1>;
            phy_addr = <0xffffffff>;
            dma-mask = <0xffffffff 0xffffffff>;
        };
#endif


        pcie0_port0@40100000 {
            compatible = "loongson,ls-pcie";
            interrupt-parent = <&icu>;
            interrupts = <40>;
            #address-cells = <3>;
            #size-cells = <2>;
            bus-range = <0x1 0x3>;
#if 1
            ranges = <0x02000000 0x0 0x40100000 0x40100000 0x0 0x8000000  //mem
                        0x01000000 0x0 0x18001000 0x18001000 0x0 0x0ff000>;  //io
#else
              ranges = <0x02000000 0x0 0x40260000 0x40260000 0x0 0x8000000  //mem
                        0x01000000 0x0 0x4028c000 0x4028c000 0x0 0x0ff000>;  //io
#endif
        };
#if 0

        pcie0_port1@50000000 {
            compatible = "loongson,ls-pcie";
            interrupt-parent = <&icu>;
            interrupts = <41>;
            #address-cells = <3>;
            #size-cells = <2>;
            bus-range = <0x4 0x6>;
              ranges = <0x02000000 0x0 0x50000000 0x50000000 0x0 0x4000000  //mem
                        0x01000000 0x0 0x18100000 0x18100000 0x0 0x100000>;  //io
        };

        pcie0_port2@54000000 {
            compatible = "loongson,ls-pcie";
            interrupt-parent = <&icu>;
            interrupts = <42>;
            #address-cells = <3>;
            #size-cells = <2>;
            bus-range = <0x8 0xa>;
              ranges = <0x02000000 0x0 0x54000000 0x54000000 0x0 0x4000000  //mem
                        0x01000000 0x0 0x18200000 0x18200000 0x0 0x100000>;  //io
        };

        pcie0_port3@58000000 {
            compatible = "loongson,ls-pcie";
            interrupt-parent = <&icu>;
            interrupts = <43>;
            #address-cells = <3>;
            #size-cells = <2>;
            bus-range = <0xc 0xe>;
              ranges = <0x02000000 0x0 0x58000000 0x58000000 0x0 0x8000000  //mem
                        0x01000000 0x0 0x18300000 0x18300000 0x0 0x100000>;  //io
        };

        pcie1_port0@60000000 {
            compatible = "loongson,ls-pcie";
            interrupt-parent = <&icu>;
            interrupts = <44>;
            #address-cells = <3>;
            #size-cells = <2>;
            bus-range = <0x10 0x12>;
              ranges = <0x02000000 0x0 0x60000000 0x60000000 0x0 0x18000000  //mem
                        0x01000000 0x0 0x18400000 0x18400000 0x0 0x100000>;  //io
        };

        pcie1_port1@78000000 {
            compatible = "loongson,ls-pcie";
            interrupt-parent = <&icu>;
            interrupts = <45>;
            #address-cells = <3>;
            #size-cells = <2>;
            bus-range = <0x14 0x16>;
              ranges = <0x02000000 0x0 0x78000000 0x78000000 0x0 0x8000000  //mem
                        0x01000000 0x0 0x18500000 0x18500000 0x0 0x100000>;  //io
        };
#endif
        serial0x@0x1fe00000{
            device_type = "serial";
            compatible = "ns16550";
            reg = <0x1fe00000 0x100>;
            clock-frequency = <125000000>;
            interrupt-parent = <&icu>;
            interrupts = <8>;
        };
#if 0
        serial3x@0x1fe00300{
            device_type = "serial";
            compatible = "ns16550";
            reg = <0x1fe00300 0x100>;
            clock-frequency = <125000000>;
            interrupt-parent = <&icu>;
            interrupts = <8>;
        };
        serial4x@0x1fe00400{
            device_type = "serial";
            compatible = "ns16550";
            reg = <0x1fe00400 0x100>;
            clock-frequency = <125000000>;
            interrupt-parent = <&icu>;
            interrupts = <9>;
        };
#endif
        serial5x@0x1fe00500{
            device_type = "serial";
            compatible = "ns16550";
            reg = <0x1fe00500 0x100>;
            clock-frequency = <125000000>;
            interrupt-parent = <&icu>;
            interrupts = <9>;
        };

        pioA:gpio@0x1fe10500{
            compatible = "ls,ls2k-gpio", "ls,ls-gpio";
            reg = <0x1fe10500 0x38>;
            ngpios = <64>;
            gpio-controller;
            #gpio-cells = <2>;
            
            
        };
        

        i2c0: i2c@1fe01000{
            compatible = "loongson,ls-i2c";
            reg = <0x1fe01000 0x8>;
            interrupt-parent = <&icu>;
            interrupts = <30>;
            #address-cells = <1>;
            #size-cells = <0>;
            
            tvp5150@5d{
                compatible = "tvp5150";
                reg = <0x5d>;
            };
/*            rtc@51{
                compatible = "nxp,pcf8563";
                reg = <0x51>;
            };*/
#if 0
            rtc@68{
                compatible = "dallas,ds1338";
                reg = <0x68>;
            };

            tmp421@4d{
                compatible = "tmp422";
                reg = <0x4d>;
            };

            eeprom@57{
                compatible = "atmel,24c16";
                reg = <0x57>;
                pagesize = <16>;
            };
#endif
        };
#if 0
        i2c1: i2c@1fe01800{
            #address-cells = <1>;
            #size-cells = <0>;

            compatible = "loongson,ls-i2c";
            reg = <0x1fe01800 0x8>;
            interrupt-parent = <&icu>;
            interrupts = <31>;
            codec@1a{
                compatible = "codec_uda1342";
                reg = <0x1a>;
            };
        };
#endif
#if 0
        i2c_dvo0:i2c@2{
            compatible = "i2c-gpio";
            gpios = <&pioA 1 0 /* sda */
                 &pioA 0 0 /* scl */
                >;
            /*i2c-gpio,sda-open-drain;*/
            /*i2c-gpio,scl-open-drain;*/
            i2c-gpio,delay-us = <5>;    /* ~100 kHz */
            #address-cells = <1>;
            #size-cells = <0>;
            eeprom@50{
                compatible = "dvi-eeprom-edid";
                reg = <0x50>;
            };
        };

        i2c_dvo1:i2c@3{
            compatible = "i2c-gpio";
            gpios = <&pioA 32 0 /* sda */
                 &pioA 33 0 /* scl */
                >;
            /*i2c-gpio,sda-open-drain;*/
            /*i2c-gpio,scl-open-drain;*/
            i2c-gpio,delay-us = <5>;    /* ~100 kHz */
            eeprom@50{
                compatible = "eeprom-edid";
                reg = <0x50>;
            };
        };

        spi0: spi@1fff0220{
            compatible = "loongson,ls2k-spi";
            #address-cells = <1>;
            #size-cells = <0>;
            reg = <0x1fff0220 0x10>;
            spidev@0{
                compatible = "rohm,dh2228fv";
                spi-max-frequency = <100000000>;
                reg = <0>;
            };
        };
#endif
#if 1
        rtc0: rtc@1fe07800{
            compatible = "loongson,ls-rtc";
            reg = <0x1fe07800 0x100>;
            interrupt-parent = <&icu>;
            interrupts = <60>;
        };
#endif
#if 1
        /* CAN controller nodes:
         * If you want to use the "can" function,enable the "can"
         * controller by configure general configuration register 0.
         */
        can0: can@1fe00c00{
            compatible = "nxp,sja1000";
            reg = <0x1fe00c00 0xff>;
            nxp,external-clock-frequency = <125000000>;
            interrupt-parent = <&icu>;
            interrupts = <24>;
        };
        can1: can@1fe00d00{
            compatible = "nxp,sja1000";
            reg = <0x1fe00d00 0xff>;
            nxp,external-clock-frequency = <125000000>;
            interrupt-parent = <&icu>;
            interrupts = <25>;
        };
#endif
#if 0
        pwm0: pwm@1fe02000{
            compatible = "loongson,ls2k-pwm";
            reg = <0x1fe02000 0x10>;
            interrupt-parent = <&icu>;
            interrupts = <32>;
        };
        pwm1: pwm@1fe02010{
            compatible = "loongson,ls2k-pwm";
            reg = <0x1fe02010 0x10>;
            interrupt-parent = <&icu>;
            interrupts = <33>;
        };
        pwm2: pwm@1fe02020{
            compatible = "loongson,ls2k-pwm";
            reg = <0x1fe02020 0x10>;
            interrupt-parent = <&icu>;
            interrupts = <34>;
        };
        pwm3: pwm@1fe02030{
            compatible = "loongson,ls2k-pwm";
            reg = <0x1fe02030 0x10>;
            interrupt-parent = <&icu>;
            interrupts = <35>;
        };

#endif
        /* APB DMA controller nodes:
         * apbdma node specify the commom property for dma node.
         * the #config-nr must be 2,Used to provide APB sel region
         * and APB DMA controler information.
         */
        apbdma: apbdma@1fe10438{
            compatible = "loongson,ls-apbdma";
            reg = <0x1fe10438 0x8>;
            #config-nr = <2>;
        };
        /* DMA node should specify the apbdma-sel property using a
         * phandle to the controller followed by number of APB sel
         * region(max 9) and number of APB DMA controller(max 4).
        */
        dma0: dma@1fe10c00 {
            compatible = "loongson,ls-apbdma-0";
            reg = <0x1fe10c00 0x8>;
            apbdma-sel = <&apbdma 0x0 0x0>;
            #dma-cells = <1>;
            dma-channels = <1>;
            dma-requests = <1>;
        };
        dma1: dma@1fe10c10 {
            compatible = "loongson,ls-apbdma-1";
            reg = <0x1fe10c10 0x8>;
            apbdma-sel = <&apbdma 0x5 0x1>;
            #dma-cells = <1>;
            dma-channels = <1>;
            dma-requests = <1>;
        };
        dma2: dma@1fe10c20 {
            compatible = "loongson,ls-apbdma-2";
            reg = <0x1fe10c20 0x8>;
            apbdma-sel = <&apbdma 0x6 0x2>;
            #dma-cells = <1>;
            dma-channels = <1>;
            dma-requests = <1>;
        };
        dma3: dma@1fe10c30 {
            compatible = "loongson,ls-apbdma-3";
            reg = <0x1fe10c30 0x8>;
            apbdma-sel = <&apbdma 0x7 0x3>;
            #dma-cells = <1>;
            dma-channels = <1>;
            dma-requests = <1>;
        };
        /*
        dma4: dma@1fe10c40 {
            compatible = "loongson,ls-apbdma-4";
            apbdma-sel = <&apbdma 0x0 0x0>;
            reg = <0x1fe10c40 0x8>;
            #dma-cells = <1>;
            dma-channels = <1>;
            dma-requests = <1>;
        };
        */
#if 0
        sdio@0x1fe0c000 {
            #address-cells = <1>;
            #size-cells = <1>;

            compatible = "loongson,ls2k_sdio";
            reg = <0x1fe0c000 0x1000>;
            interrupt-parent = <&icu>;
            interrupts = <39>;
            interrupt-names = "ls2k_mci_irq";

            dmas = <&dma1 1>;
            dma-names = "sdio_rw";
            dma-mask = <0xffffffff 0xffffffff>;
        };
#endif
#if 0
        i2s: i2s@0x1fe0d000 {
            compatible = "loongson,ls-i2s";
            reg = <0x1fe0d000 0x10>;
        };
        audio: audio@0x1fe0d000 {
            compatible = "loongson,ls-pcm-audio";
            reg = <0x1fe0d000 0x10>;
            interrupt-parent = <&icu>;
            interrupts = <54 55>;
            interrupt-names = "i2s_irq0", "i2s_irq1";

            dmas = <&dma2 1
                    &dma3 1>;
            dma-names = "i2s_play", "i2s_record";
            dma-mask = <0xffffffff 0xffffffff>;
        };
        sound {
            compatible = "loongson,ls-sound";
            loongson,i2s-controller = <&i2s>;
            loongson,audio-codec = <&audio>;
        };
#endif
#if 0
        nand@0x1fe06040{
            #address-cells = <1>;
            #size-cells = <1>;
            compatible = "loongson,ls-nand";
            reg = <0x1fe06040 0x0
                0x1fe06000 0x20>;
            interrupt-parent = <&icu>;
            interrupts = <52>;
            interrupt-names = "nand_irq";

            dmas = <&dma0 1>;
            dma-names = "nand_rw";
            dma-mask = <0xffffffff 0xffffffff>;

            number-of-parts = <0x2>;

            partition@0 {
                label = "kernel_partition";
                reg = <0x0000000 0x01400000>;
            };

            partition@0x01400000 {
                label = "os_partition";
                reg = <0x01400000 0x0>;
            };
        };
#endif
        hwmon@0x1fe07000{
            #address-cells = <1>;
            #size-cells = <1>;

            compatible = "loongson,ls-hwmon";
            reg = <0x1fe07000 0x1>;
            max-id = <0>;
            id = <0>;
        };
    };

    suspend_to_ram {
        suspend_addr = <0x1fc00500>;
    };

    gpio-conf422 {
        compatible = "gpio-leds";

        re0 {
            label = "re0";
            gpios = <&pioA 50 0>;
        };
        de0 {
            label = "de0";
            gpios = <&pioA 51 0>;
            default-state = "on";
        };
        re1 {
            label = "re1";
            gpios = <&pioA 48 0>;
        };
        de1 {
            label = "de1";
            gpios = <&pioA 49 0>;
            default-state = "on";            
        };
    };

    chosen {
        /* the redundant spaces are used for save new boot args */
//        bootargs = "console=ttyS0,115200 root=/dev/sda1                                                                                                                                                                                      ";
    };
};
 

编译pmon，

我开始使用load_dtb 似乎有些问题，最后只好更新一把pmon

print_dtb就有了

 

编译好内核之后，直接用新的内核启动就可以了。在class中多了leds的目录，目录中有这4个引脚。

 因为我需要DE为高电平，RE为低电平，看到打印的结果确实也是。用万用表测量了，也是对应的，没问题了。

大智兄
关注
专栏目录
Linux 内核之“点灯大师”(GPIO LEDs)
weixin_35723192的博客
03-26 946
Linux 学习过程最基本也是最常用的控制LED，看似很简单实际确实很简单。点亮 LED最常规方法是控制GPIO的高低电平实现亮灭变化，深层次一点使用pwm可调节亮度值，再深层一点是程控LED。方法有多种，深刻领悟，活学活用才能领悟不一样的色彩。
使用树莓派学习Linux驱动开发-01 LED驱动程序
qq_30135687的博客
04-10 1448
01 LED驱动程序sysfs操作GPIO的命令配置GPIO0为输出模式配置GPIO0为输入模式添加test_led0驱动程序来操作GPIO0ledtest驱动程序ledtest.cLED0寄存器操作文件board_demo_pi4b.cLED的操作头文件led_ope.h测试LED0文件ledtest.cMakefile编译文件编译步骤 sysfs操作GPIO的命令 在大部分的linux操作系统中都可以通过/sys/class/gpio来直接操作gpio，同样的在树莓派的系统中也是支持的，这是一种使用文件
linux应用GPIO控制led节点
目前从事linux驱动开发，多交流多学习吧
05-23 669
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <fcntl.h> //设置gpio方向 "in" or "out" void SetGpioDirection(int n,char *direction) { char path[100] = {0}; spri
一文搞懂STM32所有GPIO输入、输出模式（推挽输出、开漏输出、上拉输入、浮空输入等）
最新发布
m0_47106200的博客
09-02 2992
开漏输出有两种输出状态：低电平高阻态在开漏输出模式下，PMOS一直处于关断状态，只需要关注NMOS管；（1） 当NMOS导通时，IO口接地，对外输出低电平：（2）当NMOS也关断时，IO口什么都没接，即单片机输出高阻态此时外设相当于接了个寂寞，也可以说是开路：这样看来好像开漏输出没什么用，只能输出低电平，不能输出高电平。但在某些场景下开漏输出很有用，例如I2C通信协议中，作为SCL和SDA的GPIO口设置必须设置为开漏模式。
Linux下GPIO驱动（一） ----一个简单的LED驱动
weixin_30417487的博客
08-24 198
/******************************* * *杂项设备驱动:miscdevice *majior=10; * * *****************************/ #include <linux/kernel.h> #include <linux/module.h> #include <lin...
linux ZYNQ 中使用 GPIO子系统leds-gpio驱动控制EMIO的LED灯
ZYH10140的博客
11-09 1323
emio编号计算， emio控制led灯， linux leds-gpio驱动，linux gpio指令， leds-gpio设备树讲解，axi-gpio控制led灯，linux中使用gpio控制led
linux/drivers/leds/leds-gpio.c学习
__Benco的博客
07-31 712
`gpio_led_suspend()` 和 `gpio_led_resume()`：这两个函数用于在系统挂起和恢复时处理 GPIO LED 的状态。其中最重要的结构体是 `struct gpio_led`，它包含了 GPIO LED 的名称、GPIO 引脚号、默认亮度等信息。1. 头文件引入：该文件引入了一些必要的头文件，包括 ``、``、`` 等。
gpio-led.rar_LINUX LED GPIO_linux gpio测试
09-20
5. **LED驱动**：LED驱动是GPIO驱动的一个特例，主要用于控制LED的亮灭。在Linux下，LED驱动可以是一个内核模块，也可以是用户空间的应用程序。通过设置GPIO引脚的电平，可以控制LED的开和关。 6. **7-led-qd**：这...
Linux-sys-gpio-GPIO-driver-.doc.zip_GPIO linux _doc_gpio sys_lin
09-23
通过学习和实践Linux下的GPIO驱动和sysfs接口，你可以灵活地控制硬件设备，实现各种功能，如按钮检测、LED闪烁、电机控制等。这份文档"Linux sys gpio GPIO driver .doc"提供了宝贵的实践经验，对于理解和应用Linux ...
使用树莓派学习Linux驱动开发-04 总线设备驱动模型编写LED驱动程序（引入设备树指定LED引脚）
qq_30135687的博客
04-19 1058
文章目录前言一、设备树的引入与作用二、使用步骤.总结 前言 本文在《03 总线设备驱动模型编写LED驱动程序》基础之上继续改进，将board_pi4b_led.c资源定义文件删除，转而在设备树中定义LED引脚的指定。 一、设备树的引入与作用 在前三篇内容中的LED驱动程序，LED所使用的GPIO引脚都是定义在源码中的，当需要修改LED所使用的GPIO引脚时都需要重新对源码重新编译，并重新加载驱动，这样非常的不方便。 在内核中，同一芯片（bcm2711）的板子，我们使用的是树莓派4B来进行学习，同一芯片的GP
Linux驱动开发--用IO内存操作GPIO控制LED
04-17
结合本作者博客 Linux简单设备驱动（1）：使用IO内存操作GPIO–LED 的源代码
linux gpio-led
weixin_30835649的博客
07-15 137
http://blog.chinaunix.net/uid-25119314-id-1642009.html [note] static struct gpio_led default_leds[] = { { .name = "myboard:led0", // 随便，比如ledx 　　　　.gpio = 4,　　　　　　　　　//连接led的管脚，在使用前需要先#def...
我的内核学习笔记11：linux leds-gpio驱动应用实例
李迟的专栏
12-08 1万+
linux内核的leds-gpio是使用GPIO控制LED的驱动，只要将板子上LED灯对接的GPIO引脚号进行适当的配置，就能使用这个驱动了，十分方便。网上有很多文章分析这个驱动，就不献丑——或者后面闲时再写写吧。
Linux Kernel 控制 GPIO LED 闪烁 (Blink)
热门推荐
Fred_Wu的专栏
04-14 1万+
Linux Kernel 控制GPIO LED 闪烁(Blink)关于Linux 下面使用gpio 控制led灯 有很多方式. 1.直接操作GPIO : 比如gpio15 ,那么就使用 echo 15 > /sys/class/gpio echo out > /sys/class/gpio/gpio15/direction echo 1 > /sys/class/gpio/
Linux系统中GPIO-LED驱动（RK3399）
qq_54476535的博客
10-31 1517
RK3399有5组GPIO：GPIO0~GPIO4，然后每组GPIO0最多有32个引脚，又分为4个小组，A0~A7，B0~B7，C0~C7，D0~D7--（四个小组）。注意事项：有些GPIO组因为裁剪，未必32个引脚。例子：GPIO4只有C0~C7，D0~D2。功能：所有的GPIO引脚上在上电后的初始状态（默认状态）都是输入模式，可以通过编写设置上下拉，也是可以设置外部中断模式，驱动强度（推挽）是可以设置。寄存器：对GPIO的操作步骤：1、开启相应的GPIO时钟。
GPIO应用于Linux LED子系统和输入事件侦测
cdemtronix的博客
08-24 1173
　　GPIO(General-purpose input/output)即通用输入输出，根据名字就能够了解到在实际应用中可以有很多种用途，最常见的便是用来控制LED灯的亮灭，或用来侦测输入信号的高低变化。英创工控主板都给用户提供了丰富的GPIO资源，ESMARC系列的板卡拥有32位GPIO，为了方便用户能够更方便的进行开发，英创公司进一步在软件上也增加了一些实用的功能。在GPIO用作控制LED灯的...
Linux第76步_“gpio子系统”下的LED驱动
weixin_42550185的博客
03-11 966
使用新字符设备驱动的一般模板和“gpio子系统”，以及设备树，驱动LED。gpio子系统下的点灯，才是我们要掌握的字符驱动开发方法。
【嵌入式Linux】嵌入式Linux驱动开发基础知识之操纵GPIO点亮LED
永远年轻 永远热泪盈眶
04-05 3776
【嵌入式Linux】嵌入式Linux驱动开发基础知识之操纵GPIO点亮LED
Linux内核自带的LED灯驱动：gpio_led_probe函数简析（probe函数）
wojiaxiaohuang2014的博客
04-09 570
Linux内核自带的LED灯驱动：gpio_led_probe函数简析（probe函数）
Linux GPIO LED字符设备驱动程序
该资源提供了一个Linux下的LED字符设备驱动示例，主要涉及Linux内核编程，特别是关于GPIO（General Purpose Input/Output）接口的使用。驱动代码包含在`leds.c`文件中，用于控制GPIO引脚来开关LED灯。驱动提供了...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大智兄

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值