Location>code7788 >text

Lesson 2 - Input (key) Control Output (LED) - Device Tree

Popularity：956 ℃/2025-03-03 15:29:16

In the first lesson, I learned how to install an NCS development environment, how to build a new project, and how to build and download it to the development board. And run the official LED flashing routine.

Equipment Tree

We continue to follow the official Developer Academy tutorial to learn the second lesson. The official course contains the following knowledge points:

Equipment Tree
Device Driver Model
GPIO's general API

Personally thinkEquipment TreeIt should be considered a difficult point, because it is a brand new knowledge point for those who have never been exposed to Linux driver development.

A device tree is a tree-like structure. The file format is*.dts

Here is an example DTS file:

/dts-v1/;

 / {
     aliases {
         serial0 = &uart0; // Alias ​​serial0 points to label uart0
     };

     soc {
         uart0: serial@ff000000 { // Node name serial@ff000000, tag uart0
             compatible = "ns16550a";
             reg = <0xff000000 0x1000>;
         };
     };
 };

There are several concepts in the device tree that must be clarified:Node name，Label，Aliasandproperty.

1. Node Name

  • Definition: The unique identifier of each device tree node, usually consisting of two parts: type and address (or other identifier), and the format is@

Example: uart@ff000000 represents a UART device located at address 0xff000000.

  • Function: Uniquely identify the child node under the same parent node.

The kernel matches the driver through node name (combined with the compatible attribute).

  • Rule: The child node names under the same parent node must be unique.

The address part (@ after content) can be omitted, but the name must be guaranteed to be unique (such as the i2c controller may not require an address).

2. Label

  • Definition: The symbol attached before the node definition is used to easily refer to the node in the device tree. The syntax is

Example: uart0: serial@ff000000, the tag uart0 can be referenced by other parts through &uart0.

  • Function: Simplify node references and avoid lengthy paths (such as /soc/serial@ff000000).
    Improve the readability and maintenance of device tree source files (.dts).

  • Rule: Tags must be unique throughout the device tree.

After compilation (generate .dtb files), the tag will be replaced with the full path or phalle of the node and will not be retained.

3. Aliases

  • Definition: The global short name defined in the aliases node, syntax is = &

Example: aliases { serial0 = &uart0; }, refer to the node corresponding to the label uart0 through the serial0 alias.

  • Function: Provides a stable device identifier (such as the system may rely on serial0 as the default console).
    The runtime can quickly find devices through aliases (such as the kernel uses of_alias_get() to obtain nodes).

  • Rule: Alias ​​are defined in the aliases node, each alias is globally unique.
    Alias ​​are usually used in conjunction with tags to point to specific nodes.

Comparison and relationship

characteristic Node name Label Alias
Uniqueness Only under the same parent node Globally unique Globally unique
grammar <type>@<address> <label>:node{...} aliases { name = &label; }
Keep after compilation yes No (replace with path or phalla) Yes (remained in .dtb)
Main uses Node ID matches driver Convenient references inside the device tree Access the device by name at runtime

Summarize

  • The node name is a unique identifier for the hardware.

  • Tags simplify references inside the device tree and improve readability.

  • The alias provides a globally friendly name for accessing the device at runtime.

Bindings of device tree

Equipment treeBindingsis a specification that describes how device tree nodes match hardware or drivers, usuallyYAMLForm definition of file. These files standardize the properties, constraints, and compatibility requirements of device tree nodes, help developers correctly describe the hardware and ensure that the kernel drivers correctly match the device. Here are the core concepts of device tree binding and detailed descriptions of YAML files:

1. The function of binding files

  • Define the node specification:Specifies what attributes, child nodes, and their formats are required for a certain device tree node (such as sensors, peripheral controllers).

  • Driver matching:Associate the device tree node with the kernel driver through the compatible property.

  • Verify the device tree:Use tools such as dt-validate and dt-schema to check if the device tree complies with bound constraints.

2. Structure of YAML binding file

A typical binding file contains the following parts:

  1. Compatibility ID (compatible）
    Defines the compatibility string for device nodes to match the driver.

Example:

compatible:
   - const: "vendor,device-id" # Required compatibility string
   - enum: # Optional other compatibility strings
       - "vendor,device-v2"
       - "vendor,device-legacy"
  1. property(properties）
    Specifies the properties and their constraints (type, scope, description, etc.) that must or optionally nodes.
properties:
   reg:
     description: "Register address and length"
     type: array
     Items:
       - description: "Base Address"
         type: int
       - description: "Length"
         type: int
   clock-frequency:
     description: "Clock frequency (Hz)"
     type: int
     default: 1000000 # Default value (optional)
  1. Child nodes
    Define the requirements and structure of child nodes.
patternProperties:
   "^gpio-[a-z0-9]+$": # Regularly match child node names (such as gpio-led)
     type: object
     properties:
       label:
         type: string
       pin:
         type: int
  1. Required fields (required）
    Mark the attribute or child node that must exist.

required:
  - reg
  - interrupts
  1. Example (examples）
    Provides a legitimate device tree node example.

Example:


examples:
  - |
    mydevice@0 {
        compatible = "vendor,device-id";
        reg = <0x1000 0x100>;
        interrupts = <1 IRQ_TYPE_EDGE_RISING>;
    };
  1. Complete YAML binding example
# Bind file: vendor,
 $schema: /meta-schemas/#
 title: Vendor Device Binding

 Description: >
   Documentation for Vendor's XYZ Device.

 compatible:
   - const: "vendor,device-id"

 properties:
   reg:
     description: "Register address and length"
     type: array
     Items:
       - description: "Base Address"
         type: int
       - description: "Length"
         type: int
     minItems: 1
     maxItems: 2

   clock-frequency:
     Description: "Device clock frequency (Hz)"
     type: int
     default: 1000000

   interrupt-names:
     type: string
     enum: [ "tx", "rx", "error" ]

 required:
   - reg
   - interrupts

 examples:
   - |
     // Example of legal nodes
     device@1000 {
         compatible = "vendor,device-id";
         reg = <0x1000 0x100>;
         interrupts = <1 IRQ_TYPE_EDGE_RISING>;
         clock-frequency = <2000000>;
     };
<Previous Next>