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");