Linux系统中驱动入门设备树DTS（经典）

ls  /proc/device-tree/

Bash

 config  DTS_TEST

         tristate "dts test"

         default y

         help

             This is the dts test

JavaScript

 obj-$(CONFIG_DTS_TEST) += dts_test.o

C

 source  "drivers/dts_test/Kconfig"

 obj-$(CONFIG_DTS_TEST)                += dts_test/

C++

 #include  <linux/init.h>

 #include <linux/module.h>

 #include <linux/platform_device.h>

 #include <linux/of.h>

 #include <linux/of_gpio.h>

 #include <linux/miscdevice.h>

 #include <linux/fs.h>

 #include <linux/errno.h>

 #include <linux/gpio/consumer.h>

 #include <linux/interrupt.h>

 #include <linux/irq.h>

 #include <linux/gpio_keys.h>

 #include <linux/of_irq.h>

 #include <linux/gpio.h>

 #include <linux/property.h>

 #include <asm/io.h>

 #include <asm/uaccess.h>

 #include <linux/slab.h>

 #include <linux/device.h>

 #define DRIVER_NAME "imx6ul,dts-tree"

 static int devtree_probe(struct platform_device * pdev)

 {

     struct fwnode_handle *child;

     const char *p1,*p2[3];

     u32 p3[2],value;

     u8 testmac[6];

     int i=0;

     printk(KERN_INFO  "\n**********devtree_probe******************\n");

      device_property_read_string(&pdev->dev,"test-string",&p1);

     printk("devtree_probe  node  test-string is: %s\n",p1);

      device_property_read_string_array(&pdev->dev,  "test-strings", p2, 3);

     printk("devtree_probe node  test-strings is: %s%s%s\n",p2[0],p2[1],p2[2]);

      device_property_read_u32(&pdev->dev,"test-u32",&value);

     printk("devtree_probe node  test-u32 is: <%d>\n",value);

      device_property_read_u32_array(&pdev->dev,  "test-u32s", p3, 2);

     printk("devtree_probe node  test-u32s is: <%d>,<%d>\n",p3[0],p3[1]);

      device_property_read_string(&pdev->dev,"compatible",&p1);

     printk("devtree_probe node  compatible is: %s\n",p1);

      device_property_read_string(&pdev->dev,"status",&p1);

     printk("devtree_probe  node  status is: %s\n",p1);

     printk(" \n * devtree_probe  child node \n");

      device_for_each_child_node(&pdev->dev, child){

         printk("*************childnode%d*************\n",i++);     

          fwnode_property_read_string(child,"test-string",&p1);

         printk("childnode  test-string is: %s\n",p1);

          fwnode_property_read_string_array(child,"test-strings",p2,3);

         printk("childnode  test-strings is:  %s%s%s\n",p2[0],p2[1],p2[2]);

          fwnode_property_read_u32_array(child,"test-u32",&value,1);

         printk("childnode test-u32  is: <%d>\n",value);

          fwnode_property_read_u32_array(child,"test-u32s",p3,2);

         printk("childnode  test-u32s is:  <%d>,<%d>\n",p3[0],p3[1]);

          fwnode_property_read_u8_array(child,"test-u8s",testmac,6);

         printk("childnode  test-u32s is:  [%x,%x,%x,%x,%x,%x]\n",testmac[0],testmac[1],testmac[2],testmac[3],testmac[4],testmac[5]); 

     }

     return 0;

 }

 static int devtree_remove(struct platform_device * pdev)

 {

     printk(KERN_INFO  "devtree_remove\n");

     return 0;

 }

 static const struct of_device_id of_devtree_dt_match[] = {

     {.compatible = DRIVER_NAME},

     {},

 };

 MODULE_DEVICE_TABLE(of,of_devtree_dt_match);

 static struct platform_driver devtree_test_driver = {

     .probe  = devtree_probe,

     .remove = devtree_remove,

     .driver = {

         .name = DRIVER_NAME,

         .owner = THIS_MODULE,

         .of_match_table = of_devtree_dt_match,

         },

 };

 static int devtree_test_init(void)

 {

     int num=0,i=0,value;

     const char *p1;

     struct device_node  *node1,*childnode1;

     u32 p2[2];

     u8 testmac[6];

     pr_warn(KERN_INFO  "^^^^^^^^^^^^^^^^^^^devtree_test_init^^^^^^^^^^^ \n");

     printk(KERN_INFO  "^^^^^^^^^^^^^^^^^^^devtree_test_init^^^^^^^^^^^ \n");

     printk("\n*************devtree  init start ***************\n");

     node1 =  of_find_node_by_path("/dts-tree1");

     if(node1 == NULL){

         printk("of_find_node_by_path  failed\n");

         return -ENODEV;

     }

     else{

          printk("of_find_node_by_path dts-tree1 ok\n");

     }

     //read string

     of_property_read_string(node1,  "test-string", &p1);

     printk("dts-tree1 node  :test-string is: %s\n",p1);

     //read strings

     num =  of_property_count_strings(node1, "test-strings");

     printk("dts-tree1 node  test-strings num is: %d\n",num);

     for(i=0;i<num;i++){

          of_property_read_string_index(node1,"test-strings",i,&p1);

         printk("%s",p1);

     }

     //read string  "compatible"

     of_property_read_string(node1,  "compatible", &p1);

     printk("dts-tree1 node  compatible is: %s\n",p1);

     //read string "status"

     of_property_read_string(node1,  "status", &p1);

     printk("dts-tree1 node   status is: %s\n",p1);

     //read u32 "test-u32"

      of_property_read_u32(node1,"test-u32",&value);

     printk("dts-tree1 node  test-u32 is: <%d>\n",value);

     //read  u32s test-u32s

     of_property_read_u32_array(node1,  "test-u32s", p2, 2);

     printk("dts-tree1 node  test-u32s is:  <%d>,<%d>\n",p2[0],p2[1]);

     //read u8s test-u8s

     of_property_read_u8_array(node1,  "test-u8s", testmac, 6);

     printk("dts-tree1 node  test-u8s is:  <%x>,<%x>,<%x>,<%x>,<%x>,<%x>\n",testmac[0],testmac[1],testmac[2],testmac[3],testmac[4],testmac[5]);

     //get "dts_child_node1"  device node 

     childnode1 =  of_get_child_by_name(node1,"dts_child_node1");

     if(childnode1 == NULL){

          printk("of_get_child_by_name failed\n");

         return -ENODEV;

     }

     printk("of_get_child_by_name  dts_child_node1 ok\n");

     of_property_read_string(childnode1,  "test-string", &p1);

     printk("dts_child_node1 node  test-string is: %s\n",p1);

     return  platform_driver_register(&devtree_test_driver);

 }

 static void devtree_test_exit(void)

 {

     printk(KERN_INFO  "\ndevtree_test_exit\n");

      platform_driver_unregister(&devtree_test_driver);

 }

 module_init(devtree_test_init);

 module_exit(devtree_test_exit);

 MODULE_LICENSE("GPL");

 MODULE_AUTHOR("zheng");