微波EDA网，见证研发工程师的成长！
首页 > 研发问答 > 嵌入式设计讨论 > 嵌入式系统设计讨论 > 3.MTX20开发板串口测试方法，adb+wifi，添加新的驱动和应用程序验证。

3.MTX20开发板串口测试方法，adb+wifi，添加新的驱动和应用程序验证。

时间：10-02 整理：3721RD 点击：
嵌入式开发调试方法很重要，我们先来看看MTX20板子的调试方式。
一）串口log，本来以为96boards的板子应该是一样，可实际结果不一样（MTX20使用android系统，另外一块板子使用linux系统，难道是这个原因?），注意USB转TTL线是1.8V。



PC端串口调试助手设置如下，可选择的最大波特率，比较特殊。说明一下此时串口输出的log比较多，还没有完全搞清楚输出机制，不一定每次开机都可以有串口log输出原因未知。


二）adb+wifi调试
adb+usb方式很简单，注意MTX20开发板USB Device和HOST模式切换。
adb+wifi设置步骤：
1.adb+usb输入情况下：
adb shell
getprop service.adb.tcp.port 5555
setprop service.adb.tcp.port 5555
stop adbd
（此时adb连接自动断开）
2.不断电，将usb切换到host模式
设置wifi静态ip地址： 192.168.9.233
3.设置setting-》Developer options-》USB debugging开启
4.adb+wifi连接：
adb connect 192.168.9.233:5555
adb shell可以正常连接开发板。
三）添加新驱动和应用测试
1.驱动源代码和位置

  1. #include <linux/init.h>
  2. #include <linux/module.h>
  3. #include <linux/device.h>
  4. #include <linux/platform_device.h>
  5. #include <linux/sysfs.h>
  6. #include <linux/slab.h>
  7. #include <linux/kernel.h>
  8. #include <linux/kobject.h>
  9. #include <linux/string.h>
  10. #include <linux/of.h>

  12. #include <linux/cdev.h>  
  13. #include <linux/fs.h>  
  14. #include <linux/vmalloc.h>

  16. struct xble_device_data {
  17.         struct block_device *binding;
  18.         int inuse;
  19. };

  21. #define mtx20_unflatten_dts_TIP "mtx20_unflatten_dts_tip"
  22. #define DEV_NAME        "ds1302_cdev"  
  23. char mtx20_unflatten_dts_code[64] = "mtx20_unflatten_dts, mtx20_unflatten_dts_show";
  24. int     ds1302_major = 217;  
  25. dev_t   ds1302_devno;  
  26. struct ds1302_cdev_t {  
  27.     struct cdev cdev;  
  28. } ds1302_dev;  

  30. static struct class *xble_class;
  31. static struct xble_device_data *xble_devices;
  32. static DEFINE_MUTEX(xble_mutex);
  33. static int max_xble_minors = 2;

  35. module_param(max_xble_minors, int, 0);
  36. MODULE_PARM_DESC(max_xble_minors, "Maximum number of xble devices (1-65536)");
  37. int g_nNum = 99;

  39. int ds1302_open(struct inode *inode, struct file *filep)  
  40. {
  41.         int nNum = 99;
  42.         pr_warn("20170116 open nNum=%d g_nNum=%d\n", nNum, g_nNum);
  43.         printk( "20170116 open =11= g_nNum=%d\n", g_nNum);
  44.         return 0;  
  45. }  
  46.   
  47. static const struct file_operations ds1302_fops = {  
  48.     .owner = THIS_MODULE,  
  49.     .open = ds1302_open,  
  50. };  
  51. static ssize_t show(struct device_driver *driver, char *buf)
  52. {
  53.         if(NULL ！= buf)
  54.         {
  55.                 /* Newline is not appended on purpose, for convenience of reader programs */
  56.                 snprintf(buf, PAGE_SIZE, "%s\n", mtx20_unflatten_dts_code);
  57.                 return strlen(buf);
  58.         }

  60.         return 0;
  61. }
  62. DRIVER_ATTR(mtx20_unflatten_dts, 0444, show, NULL);

  64. static struct attribute *mtx20_unflatten_dts_attrs[] = {
  65.         &driver_attr_mtx20_unflatten_dts.attr,
  66.         NULL,
  67. };

  69. static struct attribute_group mtx20_unflatten_dts_group = {
  70.         .name ="mtx20_unflatten_dts",
  71.         .attrs = mtx20_unflatten_dts_attrs,
  72. };

  74. static const struct attribute_group *mtx20_unflatten_dts_groups[] = {
  75.         &mtx20_unflatten_dts_group,
  76.         NULL,
  77. };

  79. static char *xble_devnode(struct device *dev, umode_t *mode)
  80. {
  81.         return kasprintf(GFP_KERNEL, "xble/%s", dev_name(dev));
  82. }
  83. static int mtx20_unflatten_dts_probe(struct platform_device *pdev)
  84. {
  85.         int nNum;
  86.         int         ret;  
  87.         const char *m_string;
  88.         printk("-0000-mtx20_unflatten_dts_probe\n");
  89.         if(NULL == pdev)
  90.         {
  91.                 printk("xiaomi_test: mtx20_unflatten_dts_probe failed, pdev is NULL\n");
  92.                 return 0;
  93.         }
  94.         pr_warn("mtx20_unflatten_dts_probe 0004\n");

  96.         if(NULL == pdev->dev.of_node)
  97.         {
  98.                 printk( "xiaomi_test: mtx20_unflatten_dts_probe failed, of_node is NULL\n");
  99.                 return 0;
  100.         }
  101.         /* mtx20_unflatten_dts_TIP*/
  102.         if(of_property_read_bool(pdev->dev.of_node, mtx20_unflatten_dts_TIP))
  103.         {
  104.                 printk( "mtx20_unflatten_dts_probe: dtsi<%s> is existing\n", mtx20_unflatten_dts_TIP);
  105.         }
  106.         if (of_property_read_u32(pdev->dev.of_node, "linux,code", &nNum))
  107.         {
  108.                 printk(KERN_INFO "=11= nNum=%d\n", nNum);
  109.         }
  110.         else
  111.         {
  112.                 printk(KERN_INFO "=0101= nNum=%d\n", nNum);
  113.         }
  114.         g_nNum = nNum;
  115.         if (of_property_read_string(pdev->dev.of_node, "linux,string", &m_string))
  116.         {
  117.                 printk(KERN_INFO "=11= m_string=%s\n", m_string);
  118.         }
  119.         else
  120.         {
  121.                 printk(KERN_INFO "=12= m_string=%s\n", m_string);
  122.         }
  123.                 printk(KERN_INFO "=0102= nNum=%d\n", nNum);



  127.     if (ds1302_major) {  
  128.         ds1302_devno = MKDEV(ds1302_major, 0);  
  129.         register_chrdev_region(ds1302_devno, 1, DEV_NAME);  
  130.     } else {  
  131.         alloc_chrdev_region(&ds1302_devno, 0, 1, DEV_NAME);  
  132.     }  
  133.         printk("-00001-mtx20_unflatten_dts_probe max_xble_minors=%d\n", max_xble_minors);
  134.                 printk(KERN_INFO "=0103= nNum=%d\n", nNum);
  135.         xble_devices = vzalloc(sizeof(struct xble_device_data) * max_xble_minors);
  136.         if (！xble_devices) {
  137.                 printk(KERN_ERR "Not enough memory for xble device structures\n");
  138.                 ret = -ENOMEM;
  139.         printk("-000011-mtx20_unflatten_dts_probe max_xble_minors=%d\n", max_xble_minors);
  140.                 goto error;
  141.         }
  142.                 printk(KERN_INFO "=0104= nNum=%d\n", nNum);
  143.    cdev_init(&ds1302_dev.cdev, &ds1302_fops);  
  144.     ds1302_dev.cdev.owner = THIS_MODULE;  
  145.   
  146.     if ((ret = cdev_add(&ds1302_dev.cdev, ds1302_devno, 1) < 0)) {  
  147.         unregister_chrdev_region(ds1302_devno, 1);  
  148.         goto error;  
  149.     }  
  150.                 printk(KERN_INFO "=0105= nNum=%d\n", nNum);
  151.                 xble_class = class_create(THIS_MODULE, "xble");
  152.         if (IS_ERR(xble_class)) {
  153.                 printk(KERN_ERR "Error creating xble class.\n");
  154.                 cdev_del(&ds1302_dev.cdev);
  155.                 ret = PTR_ERR(xble_class);
  156.                 goto error_region;
  157.         }
  158.                 printk(KERN_INFO "=0106= nNum=%d\n", nNum);
  159.         xble_class->devnode = xble_devnode;
  160.         device_create(xble_class, NULL, MKDEV(ds1302_major, 0), NULL, "xblectl");
  161.                 printk(KERN_INFO "=0107= nNum=%d\n", nNum);
  162. error_region:
  163.         unregister_chrdev_region(ds1302_devno, max_xble_minors);
  164. error:
  165.         vfree(xble_devices);

  167.         return 0;
  168. }

  170. static struct of_device_id mtx20_unflatten_dts_info_match_table[] = {
  171.         { .compatible = "mediatek,mtx20_unflatten_dts",},
  172.         { },
  173. };

  175. static struct platform_driver mtx20_unflatten_dts = {
  176.         .driver = {
  177.                 .name  = "mtx20_unflatten_dts",
  178.                 .owner  = THIS_MODULE,
  179.                 .groups = mtx20_unflatten_dts_groups,
  180.                 .of_match_table = mtx20_unflatten_dts_info_match_table,
  181.         },

  183.         .probe = mtx20_unflatten_dts_probe,
  184.         .remove = NULL,
  185. };

  187. static int __init mtx20_unflatten_dts_init(void)
  188. {
  189.         pr_warn("mtx20_unflatten_dts_init 0004\n");
  190.         return platform_driver_register(&mtx20_unflatten_dts);
  191. }

  193. static void __exit mtx20_unflatten_dts_exit(void)
  194. {
  195.         device_destroy(xble_class, ds1302_devno);
  196.         class_destroy(xble_class);
  197.   cdev_del(&ds1302_dev.cdev);  
  198.   unregister_chrdev_region(ds1302_devno, 1);  
  199.         platform_driver_unregister(&mtx20_unflatten_dts);
  200. }

  202. module_init(mtx20_unflatten_dts_init);
  203. module_exit(mtx20_unflatten_dts_exit);
  204. MODULE_LICENSE("GPL");

复制代码

位置：android6.0.0/kernel-3.18/drivers/pinctrl/mediatek下，这个位置可以任意只要可以编译即可。
2.dts设置

  1.   mtx20_unflatten_dts: mtx20_unflatten_dts@10030000 {
  2.                         compatible = "mediatek,mtx20_unflatten_dts";
  3.                         #address-cells = <3>;
  4.                         #size-cells = <1>;
  5.                         mtx20_unflatten_dts_tip;
  6.                         linux,code = <20170111>;
  7.                         linux,string = "MediaTek X20-0000-";
  8.                 };

复制代码

android-6.0.0/kernel-3.18/arch/arm64/boot/dts下mt6797.dtsi文件中。
3.linux kernel编译开关设置
android-6.0.0/kernel-3.18/arch/arm64下Kconfig文件中添加
select MTX20_UNFLATTEN_DTS
然后编译更新boot.img。
4.应用程序源代码

  1. #include <stdlib.h>
  2. #include <time.h>
  3. #include <string.h>
  4. #include <wchar.h>
  5. #include <fcntl.h>
  6. #include <stdio.h>
  7. #include <unistd.h>
  8. #include <utils/Log.h>

  10. #define CHIP_ADDR 0x50   //24CXX
  11. //#define I2C_DEV "/sys/class/xble/xblectl"
  12. #define I2C_DEV "/dev/xblectl"
  13. //static int read_eeprom(int fd,char buff[],int addr,int count)
  14. //{
  15. //     int res;
  16. //     lseek(fd, 64, SEEK_SET);
  17. //     if (write(fd,&addr,1)！=1)
  18. //     {
  19. //    printf("Can't write %s's addr %d\n",I2C_DEV,addr);
  20. //    return -1;
  21. //     }
  22. //     res = read(fd,buff,count);
  23. //     printf("read %d bytes at 0x%02x\n\r",res,addr);
  24. //     return res;
  25. //}
  26. //static int write_eeprom(int fd,char buff[],int addr,int count)
  27. //{
  28. //   int res;
  29. //   int i;
  30. //   static char sendbuffer[PAGE_SIZE+1];
  31. //  
  32. //   memcpy(sendbuffer+1,buff,count);
  33. //   sendbuffer[0]=addr;
  34. //   
  35. //   res = write(fd,&sendbuffer,count+1);
  36. //   printf("write %d bytes at 0x%02x buff[0]=%c\n",res,sendbuffer[0], buff[0]);
  37. //   return res;
  38. //}
  39. int main(void)
  40. {
  41. int fd,i,res;
  42. unsigned char str1[PAGE_SIZE] = "aaaaaaaaaaaaaaaaaaaaaaaaa";
  43. unsigned char s2[PAGE_SIZE] = "11111111111111111111111111111111";
  44. unsigned char buf[PAGE_SIZE] = {0};

  46. fd=open(I2C_DEV,O_RDWR);
  47. if(fd<0)
  48.    {
  49.     printf("Can't Open %s ！\n\r",I2C_DEV);
  50.     return -1;
  51.    }

  53.         //LOGE("==20170109 open =buf = %s\n 0x4d=<%c>\n", buf, 0x4d);

  55.   printf("=^^^^^^^^^^^^=buf = %s\n 0x4d=<%c>\r", buf, 0x4d);
  56.   close(fd);
  57.   return 0;
  58. }

复制代码


5应用程序编译，随意找一个目录，修改一下Android.mk文件，把我们的程序添加进去，编译即可。


6.测试



这三部分掌握后，基本上就可以为MTX20开发板添加任何驱动和应用程序。
上一篇：开发环境
下一篇：nand flash 的坏块问题

wifi android 相关文章：

栏目分类
热门文章

Copyright © 2017-2020 微波EDA网 版权所有

网站地图

Top