{"id":74394,"date":"2026-02-09T18:25:27","date_gmt":"2026-02-09T10:25:27","guid":{"rendered":"https:\/\/www.wsisp.com\/helps\/74394.html"},"modified":"2026-02-09T18:25:27","modified_gmt":"2026-02-09T10:25:27","slug":"day73-imx6ull-linux-key-driver-practice-a-complete-analysis-from-gpio-polling-to-device-tree-interr","status":"publish","type":"post","link":"https:\/\/www.wsisp.com\/helps\/74394.html","title":{"rendered":"DAY73 IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interr"},"content":{"rendered":"

IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interrupts + Wait Queues<\/h2>\n

In embedded Linux development, key drivers are a classic case for understanding character devices, Platform bus, interrupt mechanisms, and blocking I\/O. Based on the IMX6ULL development board, this article integrates the core highlights of three blog posts, using \u201cdriver version evolution\u201d as the main thread to comprehensively dissect the optimization path of key drivers\u2014from basic GPIO polling to standard device tree interrupts + wait queues. It balances theoretical depth, code details, and practical implementation, helping developers master the core design philosophy of Linux drivers.<\/p>\n

I. Core Technology Stack and Design Philosophy<\/h3>\n

1.1 Core Technology System<\/h4>\n\nTechnologyDescription<\/tr>\n\n\n\n\n\n\n
Device Tree (DTS\/DTB)<\/td>\nUniformly describes hardware resources like key GPIOs and interrupts, decoupling drivers from hardware via the compatible property.<\/td>\n<\/tr>\n
GPIO Subsystem<\/td>\nEncapsulates low-level register operations, providing standardized APIs like gpio_request and gpio_get_value to simplify hardware operations.<\/td>\n<\/tr>\n
Interrupt Handling<\/td>\nUses \u201cevent triggering\u201d instead of polling, triggering interrupts on key press\/release to reduce CPU usage (request_irq + ISR).<\/td>\n<\/tr>\n
Wait Queue<\/td>\nImplements \u201csleep-wake\u201d mechanism, releasing CPU when the application waits for key events and waking up after interrupts, achieving efficient blocking I\/O.<\/td>\n<\/tr>\n
Platform Bus<\/td>\nAutomatically matches device tree nodes with drivers via the compatible property, standardizing driver initialization (probe function).<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

1.2 Driver Evolution Design Philosophy<\/h4>\n

From \u201cfunctional implementation\u201d to \u201chigh performance + high portability,\u201d the evolution of the three versions perfectly illustrates the Linux driver design principle of \u201clow coupling, high cohesion\u201d:<\/p>\n\nVersionCore ImplementationCPU UsagePortabilityKey Highlights<\/tr>\n\n\n\n\n
V1<\/td>\nPure GPIO Polling<\/td>\nHigh<\/td>\nMedium<\/td>\nMinimal logic, ideal for understanding GPIO operations.<\/td>\n<\/tr>\n
V2<\/td>\nGPIO-to-Interrupt + Wait Queue<\/td>\nLow<\/td>\nMedium<\/td>\nIntroduces blocking I\/O, solving CPU usage issues.<\/td>\n<\/tr>\n
V3<\/td>\nDevice Tree Interrupt + Wait Queue<\/td>\nLow<\/td>\nHigh<\/td>\nFully decouples hardware details, standard Linux practice.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

II. Device Tree (DTS) Writing: Standardizing Hardware Description<\/h3>\n

The device tree serves as the \u201cbridge\u201d between drivers and hardware, uniformly describing key GPIO and interrupt resources without hardcoding hardware details in the driver.<\/p>\n

2.1 DTS Node Example (Added to IMX6ULL Device Tree File)<\/h4>\n

ptkey {
\n compatible = "pt-key"; \/\/ Matches driver's `of_device_id`, the core matching property.
\n ptkey-gpio = <&gpio1 4 GPIO_ACTIVE_LOW>; \/\/ Key GPIO (GPIO1_IO04, active low).
\n interrupt-parent = <&gpio1>; \/\/ Interrupt parent controller (GPIO1).
\n interrupts = <4 IRQ_TYPE_EDGE_FALLING>; \/\/ Interrupt number 4, falling-edge triggered (key press).
\n};<\/p>\n

    \n
  • &gpio1: References the IMX6ULL\u2019s GPIO1 controller node.<\/li>\n
  • GPIO_ACTIVE_LOW: Indicates the GPIO is active low (key press pulls GPIO low).<\/li>\n
  • interrupts: Defines interrupt trigger mode; IRQ_TYPE_EDGE_FALLING means falling-edge triggered.<\/li>\n<\/ul>\n

    2.2 Device Tree Matching Mechanism<\/h4>\n
  • The driver declares supported compatible properties via the of_device_id structure.<\/li>\n
  • During kernel startup, the device tree node is automatically matched with the driver\u2019s compatible property.<\/li>\n
  • Upon successful matching, the Platform bus triggers the driver\u2019s probe function to complete initialization.<\/li>\n

    III. Driver Code Analysis: Detailed Evolution of Three Versions<\/h3>\n

    3.1 V1: Pure GPIO Polling Driver (key.c)<\/h4>\n

    The most basic implementation, polling GPIO levels to determine key status, ideal for beginners to understand the GPIO subsystem.<\/p>\n

    Core Code<\/h5>\n

    #<\/span>define<\/span> DEV_NAME<\/span> "key"<\/span><\/span>
    \nstatic<\/span> int<\/span> key_gpio;<\/span><\/p>\n

    \/\/ Read key status (1=not pressed, 0=pressed).<\/span>
    \nstatic<\/span> inline<\/span> int<\/span> get_key_status<\/span>(<\/span>void<\/span>)<\/span> {<\/span>
    \n return<\/span> gpio_get_value<\/span>(<\/span>key_gpio)<\/span>;<\/span> \/\/ GPIO subsystem API, reads level.<\/span>
    \n}<\/span><\/p>\n

    \/\/ `read` function: Returns key status when the application calls `read`.<\/span>
    \nstatic<\/span> ssize_t<\/span> read<\/span>(<\/span>struct<\/span> file<\/span> *<\/span>file,<\/span> char<\/span> __user *<\/span>buf,<\/span> size_t<\/span> size,<\/span> loff_t<\/span> *<\/span>loff)<\/span> {<\/span>
    \n int<\/span> status =<\/span> get_key_status<\/span>(<\/span>)<\/span>;<\/span>
    \n \/\/ Copies data from kernel space to user space.<\/span>
    \n if<\/span> (<\/span>copy_to_user<\/span>(<\/span>buf,<\/span> &<\/span>status,<\/span> sizeof<\/span>(<\/span>status)<\/span>)<\/span>)<\/span>
    \n return<\/span> –<\/span>EFAULT;<\/span>
    \n return<\/span> sizeof<\/span>(<\/span>status)<\/span>;<\/span>
    \n}<\/span><\/p>\n

    \/\/ `probe` function: Core driver initialization flow.<\/span>
    \nstatic<\/span> int<\/span> probe<\/span>(<\/span>struct<\/span> platform_device<\/span> *<\/span>pdev)<\/span> {<\/span>
    \n struct<\/span> device_node<\/span> *<\/span>pdts;<\/span>
    \n int<\/span> ret =<\/span> misc_register<\/span>(<\/span>&<\/span>misc_dev)<\/span>;<\/span> \/\/ Registers a miscellaneous device, auto-creates `\/dev\/key`.<\/span>
    \n if<\/span> (<\/span>ret)<\/span> goto<\/span> err_misc_register;<\/span><\/p>\n

    pdts =<\/span> of_find_node_by_path<\/span>(<\/span>"\/ptkey"<\/span>)<\/span>;<\/span> \/\/ Finds the device tree node.<\/span>
    \n key_gpio =<\/span> of_get_named_gpio<\/span>(<\/span>pdts,<\/span> "ptkey-gpio"<\/span>,<\/span> 0<\/span>)<\/span>;<\/span> \/\/ Gets GPIO number from the node.<\/span>
    \n ret =<\/span> gpio_request<\/span>(<\/span>key_gpio,<\/span> "key"<\/span>)<\/span>;<\/span> \/\/ Requests GPIO resources to avoid conflicts.<\/span>
    \n gpio_direction_input<\/span>(<\/span>key_gpio)<\/span>;<\/span> \/\/ Configures GPIO as input mode.<\/span><\/p>\n

    printk<\/span>(<\/span>"V1: GPIO polling driver initialized.\\\\n"<\/span>)<\/span>;<\/span>
    \n return<\/span> 0<\/span>;<\/span><\/p>\n

    \/\/ Error handling: Releases allocated resources to avoid memory leaks.<\/span>
    \nerr_misc_register:<\/span>
    \n misc_deregister<\/span>(<\/span>&<\/span>misc_dev)<\/span>;<\/span>
    \n printk<\/span>(<\/span>"Driver initialization failed, ret=%d\\\\n"<\/span>,<\/span> ret)<\/span>;<\/span>
    \n return<\/span> ret;<\/span>
    \n}<\/span><\/p>\n

    Workflow and Drawbacks<\/h5>\n
      \n
    • Workflow: Application calls read in a while(1) loop \u2192 driver reads GPIO level \u2192 returns status.<\/li>\n
    • Drawbacks: High CPU usage (up to 99%), inability to capture transient key actions, poor real-time performance.<\/li>\n<\/ul>\n

      3.2 V2: Interrupt + Wait Queue (key_irq.c)<\/h4>\n

      Core optimization: Replaces polling with interrupts and implements \u201csleep-wake\u201d via wait queues, solving CPU usage issues.<\/p>\n

      3.2.1 Core Mechanism: Wait Queue<\/h5>\n

      Wait queues are the core of Linux blocking I\/O, acting as a \u201cprocess waiting room\u201d:<\/p>\n

        \n
      • When no key event occurs, the application sleeps, releasing CPU.<\/li>\n
      • When a key triggers an interrupt, the driver wakes the sleeping process for efficient event response.<\/li>\n<\/ul>\n
        3.2.2 Core Code Modifications<\/h5>\n

        \/\/ Defines wait queue and condition variable.<\/span>
        \nstatic<\/span> wait_queue_head_t<\/span> wq;<\/span> \/\/ Wait queue head.<\/span>
        \nstatic<\/span> int<\/span> condition =<\/span> 0<\/span>;<\/span> \/\/ Event readiness flag (0=not ready, 1=ready).<\/span>
        \nstatic<\/span> int<\/span> key_irq;<\/span> \/\/ Interrupt number.<\/span><\/p>\n

        \/\/ Interrupt service function (top half): Triggered on key press.<\/span>
        \nstatic<\/span> irqreturn_t<\/span> key_irq_handler<\/span>(<\/span>int<\/span> irq,<\/span> void<\/span> *<\/span>dev)<\/span> {<\/span>
        \n int<\/span> arg =<\/span> *<\/span>(<\/span>int<\/span> *<\/span>)<\/span>dev;<\/span>
        \n if<\/span> (<\/span>100<\/span> !=<\/span> arg)<\/span> return<\/span> IRQ_NONE;<\/span> \/\/ Validates private data to avoid false triggers.<\/span><\/p>\n

        condition =<\/span> 1<\/span>;<\/span> \/\/ Marks event as ready.<\/span>
        \n wake_up_interruptible<\/span>(<\/span>&<\/span>wq)<\/span>;<\/span> \/\/ Wakes up the waiting application process.<\/span>
        \n return<\/span> IRQ_HANDLED;<\/span> \/\/ Informs the kernel the interrupt is handled.<\/span>
        \n}<\/span><\/p>\n

        \/\/ Modified `read` function: Implements blocking I\/O.<\/span>
        \nstatic<\/span> ssize_t<\/span> read<\/span>(<\/span>struct<\/span> file<\/span> *<\/span>file,<\/span> char<\/span> __user *<\/span>buf,<\/span> size_t<\/span> size,<\/span> loff_t<\/span> *<\/span>loff)<\/span> {<\/span>
        \n condition =<\/span> 0<\/span>;<\/span>
        \n \/\/ Sleeps if condition is unmet (0% CPU usage).<\/span>
        \n wait_event_interruptible<\/span>(<\/span>wq,<\/span> condition)<\/span>;<\/span><\/p>\n

        int<\/span> status =<\/span> 1<\/span>;<\/span> \/\/ Marks key press event.<\/span>
        \n copy_to_user<\/span>(<\/span>buf,<\/span> &<\/span>status,<\/span> sizeof<\/span>(<\/span>status)<\/span>)<\/span>;<\/span>
        \n return<\/span> sizeof<\/span>(<\/span>status)<\/span>;<\/span>
        \n}<\/span><\/p>\n

        \/\/ `probe` function: Adds interrupt initialization.<\/span>
        \nstatic<\/span> int<\/span> probe<\/span>(<\/span>struct<\/span> platform_device<\/span> *<\/span>pdev)<\/span> {<\/span>
        \n \/\/ (GPIO initialization omitted, same as V1.)<\/span>
        \n key_irq =<\/span> gpio_to_irq<\/span>(<\/span>key_gpio)<\/span>;<\/span> \/\/ Converts GPIO to interrupt number (depends on GPIO-IRQ binding).<\/span><\/p>\n

        \/\/ Registers interrupt: interrupt number, ISR, trigger mode, name, private data.<\/span>
        \n ret =<\/span> request_irq<\/span>(<\/span>key_irq,<\/span> key_irq_handler,<\/span>
        \n IRQF_TRIGGER_FALLING,<\/span> "key0_irq"<\/span>,<\/span> &<\/span>arg)<\/span>;<\/span>
        \n init_waitqueue_head<\/span>(<\/span>&<\/span>wq)<\/span>;<\/span> \/\/ Initializes wait queue.<\/span><\/p>\n

        printk<\/span>(<\/span>"V2: Interrupt + wait queue driver initialized.\\\\n"<\/span>)<\/span>;<\/span>
        \n return<\/span> 0<\/span>;<\/span>
        \n}<\/span><\/p>\n

        Core Advantages<\/h5>\n
          \n
        • 0% CPU usage when the application is blocked, responding only on key press.<\/li>\n
        • Timely interrupt response, capturing transient key actions with improved real-time performance.<\/li>\n
        • Retains miscellaneous device features, auto-creating \/dev\/key without manual mknod.<\/li>\n<\/ul>\n

          3.3 V3: Interrupt Parsing via Device Tree (key_irq_sub.c)<\/h4>\n

          The gpio_to_irq approach in V2 still relies on \u201cfixed GPIO-interrupt number binding.\u201d V3 resolves interrupt numbers directly from the device tree, fully decoupling hardware details\u2014the standard Linux implementation.<\/p>\n

          Key Improvement: Interrupt Number Resolution<\/h5>\n

          \/\/ V2 approach: Depends on GPIO-interrupt binding <\/span>
          \n\/\/ key_irq = gpio_to_irq(key_gpio); <\/span><\/p>\n

          \/\/ V3 approach: Parses interrupt number from device tree (recommended) <\/span>
          \nkey_irq =<\/span> irq_of_parse_and_map<\/span>(<\/span>pdts,<\/span> 0<\/span>)<\/span>;<\/span> \/\/ pdts: device tree node pointer, 0: interrupt index <\/span>
          \nif<\/span> (<\/span>key_irq <<\/span> 0<\/span>)<\/span> {<\/span>
          \n printk<\/span>(<\/span>"Failed to parse interrupt number\\\\n"<\/span>)<\/span>;<\/span>
          \n return<\/span> –<\/span>EINVAL;<\/span>
          \n}<\/span> <\/p>\n

          Core Advantages<\/h5>\n
            \n
          • No dependency on fixed GPIO-interrupt binding; hardware changes only require device tree updates.<\/li>\n
          • Driver code is generic and portable to other Linux platforms supporting device trees.<\/li>\n
          • Fully aligns with Linux device driver models, adhering to the \u201chardware-description-and-driver-logic-separation\u201d philosophy.<\/li>\n<\/ul>\n

            3.4 Unified Platform Driver Framework<\/h4>\n

            All three versions are built on the standard Platform driver framework, ensuring scalability and compatibility:<\/p>\n

            \/\/ Device tree match table: Matches DTS node's 'compatible' property <\/span>
            \nstatic<\/span> struct<\/span> of_device_id<\/span> key_table[<\/span>]<\/span> =<\/span> {<\/span>
            \n {<\/span>.<\/span>compatible =<\/span> "pt-key"<\/span>}<\/span>,<\/span>
            \n {<\/span>}<\/span> \/\/ Sentinel <\/span>
            \n}<\/span>;<\/span> <\/p>\n

            \/\/ Platform driver structure <\/span>
            \nstatic<\/span> struct<\/span> platform_driver<\/span> pdrv =<\/span> {<\/span>
            \n .<\/span>probe =<\/span> probe,<\/span> \/\/ Executed on successful match <\/span>
            \n .<\/span>remove =<\/span> remove,<\/span> \/\/ Executed on driver unload <\/span>
            \n .<\/span>driver =<\/span> {<\/span>
            \n .<\/span>name =<\/span> DEV_NAME,<\/span>
            \n .<\/span>of_match_table =<\/span> key_table,<\/span> \/\/ Device tree match table <\/span>
            \n }<\/span>
            \n}<\/span>;<\/span> <\/p>\n

            \/\/ Driver entry\/exit (simplified via macros) <\/span>
            \nmodule_platform_driver<\/span>(<\/span>pdrv)<\/span>;<\/span>
            \nMODULE_LICENSE<\/span>(<\/span>"GPL"<\/span>)<\/span>;<\/span> \/\/ Open-source license declaration <\/span><\/p>\n

            IV. Application: Efficient Blocking I\/O<\/h3>\n

            The application avoids polling by using read to block until key events occur, ensuring simplicity and efficiency.<\/p>\n

            4.1 Application Code<\/h4>\n

            #<\/span>include<\/span> <stdio.h><\/span> <\/span>
            \n#<\/span>include<\/span> <fcntl.h><\/span> <\/span>
            \n#<\/span>include<\/span> <unistd.h><\/span> <\/span><\/p>\n

            int<\/span> main<\/span>(<\/span>int<\/span> argc,<\/span> const<\/span> char<\/span> *<\/span>argv[<\/span>]<\/span>)<\/span> {<\/span>
            \n int<\/span> fd =<\/span> open<\/span>(<\/span>"\/dev\/key"<\/span>,<\/span> O_RDWR)<\/span>;<\/span>
            \n if<\/span> (<\/span>fd <<\/span> 0<\/span>)<\/span> {<\/span>
            \n perror<\/span>(<\/span>"Failed to open \/dev\/key"<\/span>)<\/span>;<\/span>
            \n return<\/span> 1<\/span>;<\/span>
            \n }<\/span> <\/p>\n

            int<\/span> status =<\/span> 0<\/span>;<\/span>
            \n while<\/span> (<\/span>1<\/span>)<\/span> {<\/span>
            \n \/\/ Blocks until key event; process sleeps when idle <\/span>
            \n int<\/span> ret =<\/span> read<\/span>(<\/span>fd,<\/span> &<\/span>status,<\/span> sizeof<\/span>(<\/span>status)<\/span>)<\/span>;<\/span>
            \n printf<\/span>(<\/span>"Key pressed! ret=%d, status=%d\\\\n"<\/span>,<\/span> ret,<\/span> status)<\/span>;<\/span>
            \n }<\/span> <\/p>\n

            close<\/span>(<\/span>fd)<\/span>;<\/span>
            \n return<\/span> 0<\/span>;<\/span>
            \n}<\/span> <\/p>\n

            4.2 Performance Comparison<\/h4>\n\nVersionCPU UsageResponse Behavior<\/tr>\n\n\n\n
            V1<\/td>\n~99%<\/td>\nPolling, potential missed events<\/td>\n<\/tr>\n
            V2\/V3<\/td>\n0% (sleep)<\/td>\nInterrupt-triggered, real-time<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

            V. Practical Verification: Compilation to Execution<\/h3>\n

            5.1 Compilation Setup<\/h4>\n

            (1) Driver Module Compilation (Makefile)<\/h5>\n

            # Select driver version (choose one)
            \nobj-m += key.o # V1: GPIO polling
            \n# obj-m += key_irq.o # V2: Interrupt + wait queue
            \n# obj-m += key_irq_sub.o # V3: Device tree interrupt parsing
            \nKERNELDIR ?= \/home\/linux\/IMX6ULL\/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
            \nPWD := $(shell pwd) <\/p>\n

            all:
            \n $(MAKE) -C $(KERNELDIR) M=$(PWD) modules CROSS_COMPILE=arm-linux-gnueabihf- ARCH=arm <\/p>\n

            clean:
            \n $(MAKE) -C $(KERNELDIR) M=$(PWD) clean <\/p>\n

            Run: make to generate .ko driver module.<\/p>\n

            (2) Application Compilation<\/h5>\n

            arm-linux-gnueabihf-gcc key_app.c -o key_app <\/p>\n

            (3) Device Tree Compilation<\/h5>\n

            make<\/span> ARCH<\/span>=<\/span>arm CROSS_COMPILE<\/span>=<\/span>arm-linux-gnueabihf- dtbs <\/p>\n

            Generates updated device tree (e.g., imx6ull-14×14-evk.dtb).<\/p>\n

            5.2 Driver Loading and Validation (V3 Recommended)<\/h4>\n
          • Copy imx6ull-14×14-evk.dtb, key_irq_sub.ko, and key_app to the board.<\/li>\n
          • Power on the board and load the new device tree.<\/li>\n
          • Load the driver module:insmod key_irq_sub.ko
            \nls<\/span> \/dev\/key # Verify device node creation <\/span>\n <\/li>\n
          • Run the application:.\/key_app\n <\/li>\n
          • Test: Press the key; app prints \u201cKey pressed! ret=4, status=1\u201d.<\/li>\n
          • Check kernel logs:dmesg<\/span> |<\/span> grep<\/span> -E "probe|irq"<\/span>
            \n Expected output:key platform_driver_register success
            \n######################### key_driver probe
            \nirq = 123 dev = 100 # Interrupt number and private data\n <\/li>\n
          • Unload the driver:rmmod key_irq_sub.ko\n <\/li>\n

            VI. Troubleshooting Guide<\/h3>\n

            6.1 Driver Match Failure (probe Not Executed)<\/h4>\n
              \n
            • compatible mismatch: Ensure of_device_id in the driver exactly matches the DTS node.<\/li>\n
            • Incorrect DTS node path: Verify of_find_node_by_path("\/ptkey") matches the DTS path.<\/li>\n
            • Device tree not updated: Confirm the compiled DTB file is flashed.<\/li>\n<\/ul>\n

              6.2 Interrupt Registration Failure (request_irq Returns Negative)<\/h4>\n
                \n
              • Incorrect interrupt number: Check irq_of_parse_and_map return value; validate DTS interrupt configuration.<\/li>\n
              • Interrupt conflict: Use cat \/proc\/interrupts to check occupied interrupts.<\/li>\n
              • Trigger mode error: Ensure the interrupt trigger matches hardware (e.g., falling edge for keys).<\/li>\n<\/ul>\n

                6.3 Application Not Sleeping (100% CPU Usage)<\/h4>\n
                  \n
                • Uninitialized wait queue: Call init_waitqueue_head(&wq).<\/li>\n
                • ISR not waking queue: Ensure condition=1 and wake_up_interruptible(&wq) are called.<\/li>\n
                • Condition variable not reset: Set condition=0 in read before waiting.<\/li>\n<\/ul>\n

                  6.4 Unresponsive Key<\/h4>\n
                    \n
                  • GPIO misconfiguration: Confirm gpio_direction_input sets GPIO as input.<\/li>\n
                  • Hardware wiring error: GPIO should be high when idle, low when pressed.<\/li>\n
                  • Incorrect interrupt trigger: For key-release events, use IRQF_TRIGGER_RISING.<\/li>\n<\/ul>\n

                    VII. Key Takeaways<\/h3>\n

                    7.1 Essential API Reference<\/h4>\n\nAPI FunctionPurpose<\/tr>\n\n\n\n\n\n\n\n\n\n\n
                    of_find_node_by_path<\/td>\nLocates device tree node by path<\/td>\n<\/tr>\n
                    of_get_named_gpio<\/td>\nRetrieves GPIO number from DTS node<\/td>\n<\/tr>\n
                    gpio_request<\/td>\nReserves GPIO resources<\/td>\n<\/tr>\n
                    gpio_to_irq<\/td>\nConverts GPIO to interrupt (V2)<\/td>\n<\/tr>\n
                    irq_of_parse_and_map<\/td>\nParses interrupt from DTS (V3 recommended)<\/td>\n<\/tr>\n
                    request_irq<\/td>\nRegisters interrupt handler<\/td>\n<\/tr>\n
                    init_waitqueue_head<\/td>\nInitializes wait queue<\/td>\n<\/tr>\n
                    wait_event_interruptible<\/td>\nPuts process to sleep until condition<\/td>\n<\/tr>\n
                    wake_up_interruptible<\/td>\nWakes sleeping process<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                    7.2 Design Principles<\/h4>\n
                  • Decoupling: Device tree describes hardware; drivers focus on logic.<\/li>\n
                  • Efficiency: Interrupts replace polling; blocking I\/O maximizes CPU utilization.<\/li>\n
                  • Standardization: Follows Linux driver models (Platform bus, misc devices) for compatibility.<\/li>\n

                    VIII. Conclusion<\/h3>\n

                    This guide demonstrates the evolution of a Linux key driver from \u201cbasic functionality\u201d to \u201chigh-performance + high portability\u201d:<\/p>\n

                      \n
                    • V1: Introduces GPIO subsystem basics.<\/li>\n
                    • V2: Core interrupt and wait queue mechanisms to eliminate CPU waste.<\/li>\n
                    • V3: Device tree standardization for full hardware-driver decoupling.<\/li>\n<\/ul>\n

                      This methodology applies to all Linux input devices (e.g., touch keys, encoders, IR receivers) and forms the foundation for advanced driver development (e.g., input subsystems, touchscreen drivers).<\/p>\n","protected":false},"excerpt":{"rendered":"

                      IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interrupts Wait Queues
                      \nIn embedded Linux development, key drivers are a classic case for understanding character devices, Platform bus, interrupt mech<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[58,270,269,100,43,78],"topic":[],"class_list":["post-74394","post","type-post","status-publish","format-standard","hentry","category-server","tag-linux","tag-270","tag-269","tag-100","tag-43","tag-78"],"yoast_head":"\nDAY73 IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interr - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.wsisp.com\/helps\/74394.html\" \/>\n<meta property=\"og:locale\" content=\"zh_CN\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"DAY73 IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interr - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\" \/>\n<meta property=\"og:description\" content=\"IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interrupts Wait Queues In embedded Linux development, key drivers are a classic case for understanding character devices, Platform bus, interrupt mech\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.wsisp.com\/helps\/74394.html\" \/>\n<meta property=\"og:site_name\" content=\"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\" \/>\n<meta property=\"article:published_time\" content=\"2026-02-09T10:25:27+00:00\" \/>\n<meta name=\"author\" content=\"admin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u4f5c\u8005\" \/>\n\t<meta name=\"twitter:data1\" content=\"admin\" \/>\n\t<meta name=\"twitter:label2\" content=\"\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 \u5206\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/74394.html\",\"url\":\"https:\/\/www.wsisp.com\/helps\/74394.html\",\"name\":\"DAY73 IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interr - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\",\"isPartOf\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/#website\"},\"datePublished\":\"2026-02-09T10:25:27+00:00\",\"dateModified\":\"2026-02-09T10:25:27+00:00\",\"author\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/74394.html#breadcrumb\"},\"inLanguage\":\"zh-Hans\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.wsisp.com\/helps\/74394.html\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/74394.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"\u9996\u9875\",\"item\":\"https:\/\/www.wsisp.com\/helps\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"DAY73 IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interr\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#website\",\"url\":\"https:\/\/www.wsisp.com\/helps\/\",\"name\":\"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\",\"description\":\"\u9999\u6e2f\u670d\u52a1\u5668_\u9999\u6e2f\u4e91\u670d\u52a1\u5668\u8d44\u8baf_\u670d\u52a1\u5668\u5e2e\u52a9\u6587\u6863_\u670d\u52a1\u5668\u6559\u7a0b\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.wsisp.com\/helps\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"zh-Hans\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41\",\"name\":\"admin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"zh-Hans\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery\",\"contentUrl\":\"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery\",\"caption\":\"admin\"},\"sameAs\":[\"http:\/\/wp.wsisp.com\"],\"url\":\"https:\/\/www.wsisp.com\/helps\/author\/admin\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"DAY73 IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interr - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.wsisp.com\/helps\/74394.html","og_locale":"zh_CN","og_type":"article","og_title":"DAY73 IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interr - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","og_description":"IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interrupts Wait Queues In embedded Linux development, key drivers are a classic case for understanding character devices, Platform bus, interrupt mech","og_url":"https:\/\/www.wsisp.com\/helps\/74394.html","og_site_name":"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","article_published_time":"2026-02-09T10:25:27+00:00","author":"admin","twitter_card":"summary_large_image","twitter_misc":{"\u4f5c\u8005":"admin","\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4":"10 \u5206"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.wsisp.com\/helps\/74394.html","url":"https:\/\/www.wsisp.com\/helps\/74394.html","name":"DAY73 IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interr - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","isPartOf":{"@id":"https:\/\/www.wsisp.com\/helps\/#website"},"datePublished":"2026-02-09T10:25:27+00:00","dateModified":"2026-02-09T10:25:27+00:00","author":{"@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41"},"breadcrumb":{"@id":"https:\/\/www.wsisp.com\/helps\/74394.html#breadcrumb"},"inLanguage":"zh-Hans","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.wsisp.com\/helps\/74394.html"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.wsisp.com\/helps\/74394.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"\u9996\u9875","item":"https:\/\/www.wsisp.com\/helps"},{"@type":"ListItem","position":2,"name":"DAY73 IMX6ULL Linux Key Driver Practice: A Complete Analysis from GPIO Polling to Device Tree Interr"}]},{"@type":"WebSite","@id":"https:\/\/www.wsisp.com\/helps\/#website","url":"https:\/\/www.wsisp.com\/helps\/","name":"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","description":"\u9999\u6e2f\u670d\u52a1\u5668_\u9999\u6e2f\u4e91\u670d\u52a1\u5668\u8d44\u8baf_\u670d\u52a1\u5668\u5e2e\u52a9\u6587\u6863_\u670d\u52a1\u5668\u6559\u7a0b","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.wsisp.com\/helps\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"zh-Hans"},{"@type":"Person","@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41","name":"admin","image":{"@type":"ImageObject","inLanguage":"zh-Hans","@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/image\/","url":"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery","contentUrl":"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery","caption":"admin"},"sameAs":["http:\/\/wp.wsisp.com"],"url":"https:\/\/www.wsisp.com\/helps\/author\/admin"}]}},"_links":{"self":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts\/74394","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/comments?post=74394"}],"version-history":[{"count":0,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts\/74394\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/media?parent=74394"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/categories?post=74394"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/tags?post=74394"},{"taxonomy":"topic","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/topic?post=74394"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}