devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

如何以JNI方式实现安卓APP控制GPIO？_mtk安卓驱动jni之gpio驱动

作者：知新_RL | 2024-06-24 04:30:55

赞

踩

mtk安卓驱动jni之gpio驱动

本文档提供了在 Android 10 设备上通过应用程序（App）控制通用输入输出（GPIO）的详细指南。这涵盖了从创建 gpio驱动到App 配置 以及 SELinux 策略以允许特定访问的所有必要步骤。

1. 驱动实现

添加创建gpio控制驱动bsp\kernel\kernel4.14\drivers\gpio\gpio_led.c，并添加好对应的Makfile编译

  1. #include <linux/init.h>
  2.  
  3. #include <linux/slab.h>
  4.  
  5. #include <linux/module.h>
  6.  
  7. #include <linux/kernel.h>
  8.  
  9. #include <linux/fs.h>
  10.  
  11. #include <linux/cdev.h>
  12.  
  13. #include <linux/device.h>
  14.  
  15. #include <linux/ioctl.h>
  16.  
  17. #include <linux/uaccess.h>
  18.  
  19. #include <linux/string.h>
  20.  
  21. #include <linux/wait.h>
  22.  
  23. #include <linux/types.h>
  24.  
  25. #include <linux/proc_fs.h>
  26.  
  27. #include <linux/of.h>
  28.  
  29. #include <linux/of_gpio.h>
  30.  
  31. #include <linux/gpio.h>
  32.  
  33. #include <linux/delay.h>
  34.  
  35. #include <linux/platform_device.h>
  36.  
  37. #include <linux/err.h>
  38.  
  39. #include <linux/gpio/consumer.h>
  40.  
  41. #include <linux/io.h>
  42.  
  43. #include <linux/miscdevice.h>
  44.  
  45. #include <linux/irq.h>
  46.  
  47. #include <linux/of_irq.h>
  48.  
  49. #include <linux/kernel.h>
  50.  
  51. #include <linux/dmi.h>
  52.  
  53. #include <linux/firmware.h>
  54.  
  55. #include <linux/gpio/consumer.h>
  56.  
  57. #include <linux/input.h>
  58.  
  59. #include <linux/input/mt.h>
  60.  
  61. #include <linux/module.h>
  62.  
  63. #include <linux/delay.h>
  64.  
  65. #include <linux/irq.h>
  66.  
  67. #include <linux/interrupt.h>
  68.  
  69. #include <linux/slab.h>
  70.  
  71. #include <linux/acpi.h>
  72.  
  73. #include <linux/of.h>
  74.  
  75. #include <asm/unaligned.h>
  76.  
  77.  
  78.  
  79. #define GPIO_HIGH _IO('L', 0)
  80.  
  81. #define GPIO_LOW _IO('L', 1)
  82.  
  83.  
  84.  
  85. #define LED_ON 1
  86.  
  87. #define LED_OFF 0
  88.  
  89. #define SIMPIE_LED_MAX 4
  90.  
  91.  
  92.  
  93. //============================== Upper interface value ==============================//
  94.  
  95. // 驱动模块名称定义
  96.  
  97. #define MODULE_NAME "gpio_led"          // 驱动模块的名字
  98.  
  99. #define MISC_NAME "gpio_led_device"     // 用于注册为“misc”设备的名字
  100.  
  101.  
  102.  
  103. // 模块函数接口定义，供上层应用调用的接口。通过MM_DEV_MAGIC区分不同系统接口，通过_IO()加上自己的编号作为接口number。
  104.  
  105. #define MM_DEV_MAGIC 'N'
  106.  
  107.  
  108.  
  109. // LED 控制命令
  110.  
  111. #define RFID_IO1 _IO(MM_DEV_MAGIC, 93)
  112.  
  113. #define RFID_IO2 _IO(MM_DEV_MAGIC, 130)
  114.  
  115. #define RFID_IO3 _IO(MM_DEV_MAGIC, 121)
  116.  
  117. #define RFID_LED _IO(MM_DEV_MAGIC, 138)
  118.  
  119.  
  120.  
  121. static int major;
  122.  
  123. static struct class *cls;
  124.  
  125.  
  126.  
  127. // GPIO 描述数组
  128.  
  129. struct gpio_desc *led_gpio[SIMPIE_LED_MAX];
  130.  
  131.  
  132.  
  133. // cat命令将调用该函数
  134.  
  135. static ssize_t gpio_value_show(struct device *dev, struct device_attribute *attr, char *buf)
  136.  
  137. {
  138.  
  139.     return sprintf(buf, "%d\n", gpiod_get_value(led_gpio[0]));
  140.  
  141. }
  142.  
  143.  
  144.  
  145. // echo命令将调用该函数
  146.  
  147. static ssize_t gpio_value_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len)
  148.  
  149. {
  150.  
  151.     pr_err("[vanxoak]%c\n", buf[0]);
  152.  
  153.     if ('0' == buf[0])
  154.  
  155.     {
  156.  
  157.         gpiod_direction_output(led_gpio[0], 0);
  158.  
  159.         pr_err("[vanxoak]: _%s_ :gpio off\n", __func__);
  160.  
  161.     }
  162.  
  163.     else if ('1' == buf[0])
  164.  
  165.     {
  166.  
  167.         gpiod_direction_output(led_gpio[0], 1);
  168.  
  169.         pr_err("[vanxoak]: _%s_ :gpio on\n", __func__);
  170.  
  171.     }
  172.  
  173.     else
  174.  
  175.         pr_err("I only support 0 or 1 to ctrl gpio on or off\n");
  176.  
  177.     pr_err("[vanxoak]gpio_value_store\n");
  178.  
  179.     return len;
  180.  
  181. }
  182.  
  183.  
  184.  
  185. // 定义一个名为gpio_led的设备属性
  186.  
  187. static DEVICE_ATTR(gpio_led, 0664, gpio_value_show, gpio_value_store);
  188.  
  189.  
  190.  
  191. // 提供给上层控制的接口
  192.  
  193. long gpio_led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  194.  
  195. {
  196.  
  197.     switch (cmd)
  198.  
  199.     {
  200.  
  201.     case RFID_LED:
  202.  
  203.         gpiod_direction_output(led_gpio[0], arg);
  204.  
  205.         break;
  206.  
  207.     case RFID_IO1:
  208.  
  209.         gpiod_direction_output(led_gpio[1], arg);
  210.  
  211.         break;
  212.  
  213.     case RFID_IO2:
  214.  
  215.         gpiod_direction_output(led_gpio[2], arg);
  216.  
  217.         break;
  218.  
  219.     case RFID_IO3:
  220.  
  221.         gpiod_direction_output(led_gpio[3], arg);
  222.  
  223.         break;
  224.  
  225.  
  226.  
  227.     default:
  228.  
  229.         pr_err("[vanxoak] %s default: break\n", __func__);
  230.  
  231.         break;
  232.  
  233.     }
  234.  
  235.     return 0;
  236.  
  237. }
  238.  
  239.  
  240.  
  241. struct file_operations gpio_led_ops = {
  242.  
  243.     .owner = THIS_MODULE,
  244.  
  245.     .unlocked_ioctl = gpio_led_ioctl,
  246.  
  247. };
  248.  
  249.  
  250.  
  251. // LED灯初始化
  252.  
  253. static int simpie_led_init(struct platform_device *pdev)
  254.  
  255. {
  256.  
  257.     int ret = 0;
  258.  
  259.     int i;
  260.  
  261.  
  262.  
  263.     // 申请gpio设备
  264.  
  265.     led_gpio[0] = devm_gpiod_get(&pdev->dev, "led0", GPIOD_OUT_LOW);
  266.  
  267.     led_gpio[1] = devm_gpiod_get(&pdev->dev, "led1", GPIOD_OUT_LOW);
  268.  
  269.     led_gpio[2] = devm_gpiod_get(&pdev->dev, "led2", GPIOD_OUT_LOW);
  270.  
  271.     led_gpio[3] = devm_gpiod_get(&pdev->dev, "led3", GPIOD_OUT_LOW);
  272.  
  273.  
  274.  
  275.     for (i = 0; i < SIMPIE_LED_MAX; i++)
  276.  
  277.     {
  278.  
  279.         if (IS_ERR(led_gpio[i]))
  280.  
  281.         {
  282.  
  283.             ret = PTR_ERR(led_gpio[i]);
  284.  
  285.             return ret;
  286.  
  287.         }
  288.  
  289.         // 输出初始电平
  290.  
  291.         ret = gpiod_direction_output(led_gpio[i], LED_OFF);
  292.  
  293.     }
  294.  
  295.  
  296.  
  297.     device_create_file(&pdev->dev, &dev_attr_gpio_led);
  298.  
  299.     return ret;
  300.  
  301. }
  302.  
  303.  
  304.  
  305. // 驱动入口
  306.  
  307. static int gpio_led_probe(struct platform_device *pdev)
  308.  
  309. {
  310.  
  311.     int ret = 0;
  312.  
  313.     pr_err("[vanxoak]gpio_led_probe start...\n");
  314.  
  315.  
  316.  
  317.     // LED灯gpio初始化及输出配置
  318.  
  319.     ret = simpie_led_init(pdev);
  320.  
  321.  
  322.  
  323.     pr_err("[vanxoak]gpio_led_probe end...\n");
  324.  
  325.  
  326.  
  327.     return 0;
  328.  
  329. }
  330.  
  331.  
  332.  
  333. // 绑定设备
  334.  
  335. static struct of_device_id gpio_led_match_table[] = {
  336.  
  337.     {.compatible = "yz,gpio-led"},
  338.  
  339.     {}};
  340.  
  341.  
  342.  
  343. static int gpio_led_remove(struct platform_device *pdev)
  344.  
  345. {
  346.  
  347.     pr_err("[vanxoak]gpio_led_remove...\n");
  348.  
  349.     return 0;
  350.  
  351. }
  352.  
  353.  
  354.  
  355. static struct platform_driver gpio_led_driver = {
  356.  
  357.     .driver = {
  358.  
  359.         .name = MODULE_NAME,
  360.  
  361.         .owner = THIS_MODULE,
  362.  
  363.         .of_match_table = gpio_led_match_table,
  364.  
  365.     },
  366.  
  367.     .probe = gpio_led_probe,
  368.  
  369.     .remove = gpio_led_remove,
  370.  
  371. };
  372.  
  373.  
  374.  
  375. // gpio初始化入口
  376.  
  377. static int gpio_led_init(void)
  378.  
  379. {
  380.  
  381.     struct device *mydev;
  382.  
  383.  
  384.  
  385.     pr_err("[vanxoak]gpio_led_init start...\n");
  386.  
  387.     platform_driver_register(&gpio_led_driver);
  388.  
  389.  
  390.  
  391.     major = register_chrdev(0, "gpiotest", &gpio_led_ops);
  392.  
  393.  
  394.  
  395.     // 创建gpio_led_class设备
  396.  
  397.     cls = class_create(THIS_MODULE, "gpio_led_class");
  398.  
  399.  
  400.  
  401.     // 在gpio_led_class设备目录下创建一个gpio_led_device属性文件
  402.  
  403.     mydev = device_create(cls, 0, MKDEV(major, 0), NULL, MISC_NAME);
  404.  
  405.     if (sysfs_create_file(&(mydev->kobj), &dev_attr_gpio_led.attr))
  406.  
  407.     {
  408.  
  409.         return -1;
  410.  
  411.     }
  412.  
  413.  
  414.  
  415.     return 0;
  416.  
  417. }
  418.  
  419.  
  420.  
  421. static void gpio_led_exit(void)
  422.  
  423. {
  424.  
  425.     pr_err("[vanxoak]gpio_led_exit...\n");
  426.  
  427.     platform_driver_unregister(&gpio_led_driver);
  428.  
  429.  
  430.  
  431.     device_destroy(cls, MKDEV(major, 0));
  432.  
  433.     class_destroy(cls);
  434.  
  435.     unregister_chrdev(major, "gpiotest");
  436.  
  437. }
  438.  
  439.  
  440.  
  441. module_init(gpio_led_init);
  442.  
  443. module_exit(gpio_led_exit);
  444.  
  445.  
  446.  
  447. MODULE_DESCRIPTION("Device_create Driver");
  448.  
  449. MODULE_LICENSE("GPL");

设备树配置 

  1. gpio_led: yz,gpio-led {
  2.  
  3. status = "disabled";
  4.  
  5. compatible = "yz,gpio-led";
  6.  
  7. led0-gpio = <&ap_gpio 138 GPIO_ACTIVE_HIGH>;
  8.  
  9. led1-gpio = <&ap_gpio 93 GPIO_ACTIVE_HIGH>;
  10.  
  11. led2-gpio = <&ap_gpio 130 GPIO_ACTIVE_HIGH>;
  12.  
  13. led3-gpio = <&ap_gpio 121 GPIO_ACTIVE_HIGH>;
  14.  
  15. };

配置好上面gpio驱动后重新编译更新kernel 可以在/dev目录下找到对应的设备文件

"/dev/gpio_led_device"，通过读写设备文件就可以操作gpio了。

1.2 创建 Native 库

1.2.1设置 JNI 方法

在 App 中定义 JNI 方法以实现与 GPIO 设备的交互。

  1. public class NativeClass {
  2.  
  3.     static {
  4.         try {
  5.             System.loadLibrary("jni_gpiocontrol");
  6.             Log.d("NativeClass", "Native library loaded successfully.");
  7.         } catch (UnsatisfiedLinkError e) {
  8.             Log.e("NativeClass", "Failed to load native library: " + e.getMessage());
  9.             // throw new RuntimeException("Failed to load native library", e);
  10.         }
  11.     }
  12.     // 声明本地方法
  13.     public native int controlGPIO(int cmd, long arg);
  14. }
1.2.2 实现 Native 方法

在app/src/main目录下创建一个cpp文件夹（如果你的项目是用Kotlin编写的，这个步骤仍然适用，因为JNI是用C/C++实现的）。将你的libjni_gpiocontrol.cpp文件放到这个cpp目录中。

注意事项：确保本地方法签名正确，Java方法签名和本地（C/C++）方法实现之间必须完全匹配。

  1. #include <jni.h>
  2.  
  3. #include <fcntl.h>
  4.  
  5. #include <unistd.h>
  6.  
  7. #include <sys/ioctl.h>
  8.  
  9. #include <stdio.h>
  10.  
  11. #include <android/log.h>
  12.  
  13. #include <errno.h>
  14.  
  15. #include <string.h>
  16.  
  17.  
  18.  
  19. #define MM_DEV_MAGIC 'N'
  20.  
  21. #define RFID_LED _IO(MM_DEV_MAGIC, 138)
  22.  
  23. #define RFID_IO1 _IO(MM_DEV_MAGIC, 93)
  24.  
  25. #define RFID_IO2 _IO(MM_DEV_MAGIC, 130)
  26.  
  27. #define RFID_IO3 _IO(MM_DEV_MAGIC, 121)
  28.  
  29.  
  30.  
  31. #define DEVICE_PATH "/dev/gpio_led_device"
  32.  
  33. #define LOG_TAG "GPIOControl"
  34.  
  35.  
  36.  
  37.  
  38.  
  39. extern "C" JNIEXPORT jint JNICALL
  40.  
  41. Java_com_example_gpio_NativeClass_controlGPIO(JNIEnv *env, jobject obj, jint cmd, jlong arg) {
  42.  
  43.  
  44.  
  45.     int device_fd;
  46.  
  47.     long ioctl_result;
  48.  
  49.     unsigned int ioctl_cmd = cmd;
  50.  
  51.  
  52.  
  53.     // Open the device file
  54.  
  55.     device_fd = open(DEVICE_PATH, O_RDWR);
  56.  
  57.     if (device_fd < 0) {
  58.  
  59.         __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "Could not open device: %s", strerror(errno));
  60.  
  61.         return -1;
  62.  
  63.     }
  64.  
  65.  
  66.  
  67.     // Translate cmd to appropriate ioctl command based on input
  68.  
  69.     switch (cmd) {
  70.  
  71.         case 138:
  72.  
  73.             ioctl_cmd = RFID_LED;
  74.  
  75.             break;
  76.  
  77.         case 93:
  78.  
  79.             ioctl_cmd = RFID_IO1;
  80.  
  81.             break;
  82.  
  83.         case 130:
  84.  
  85.             ioctl_cmd = RFID_IO2;
  86.  
  87.             break;
  88.  
  89.         case 121:
  90.  
  91.             ioctl_cmd = RFID_IO3;
  92.  
  93.             break;
  94.  
  95.         default:
  96.  
  97.             __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "Invalid command");
  98.  
  99.             close(device_fd);
  100.  
  101.             return -1;
  102.  
  103.     }
  104.  
  105.  
  106.  
  107.     // Send an ioctl to the device
  108.  
  109.     ioctl_result = ioctl(device_fd, ioctl_cmd, arg);
  110.  
  111.     if (ioctl_result < 0) {
  112.  
  113.         __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "Failed to call ioctl: %s", strerror(errno));
  114.  
  115.         close(device_fd);
  116.  
  117.         return -1;
  118.  
  119.     }
  120.  
  121.  
  122.  
  123.     // Close the device
  124.  
  125.     close(device_fd);
  126.  
  127.  
  128.  
  129.     return 0;
  130.  
  131. }

1.2.3 编译 Native 库

使用 CMake 或 ndk-build 工具编译你的 native 代码为共享库（.so 文件）。

添加app\src\main\cpp\CMakeLists.txt 

  1. cmake_minimum_required(VERSION 3.4.1)
  2.  
  3. project("gpiotest")
  4.  
  5. add_library(jni_gpiocontrol SHARED libjni_gpiocontrol.cpp)
  6.  
  7. find_library( log-lib log )
  8.  
  9. target_link_libraries(jni_gpiocontrol
  10.  
  11.                        ${log-lib} ) 
1.2.4 调用 Native 方法

通过 JNI 接口在 App 中调用实现的 native 方法以控制 GPIO。

  1. public class MainActivity extends AppCompatActivity {
  2.  
  3.     private NativeClass nativeClass;
  4.  
  5.  
  6.  
  7.     @Override
  8.  
  9.     protected void onCreate(Bundle savedInstanceState) {
  10.  
  11.         super.onCreate(savedInstanceState);
  12.  
  13.         setContentView(R.layout.activity_main);
  14.  
  15.  
  16.  
  17.         nativeClass = new NativeClass();
  18.  
  19.  
  20.  
  21.         // 示例：打开LED
  22.  
  23.         int result = nativeClass.controlGPIO(138, 1);
  24.  
  25.         // 根据result处理结果
  26.  
  27.     }
  28.  
  29. }

2. SELinux 配置

由于直接访问硬件设备在 Android 中受到 SELinux 策略的限制，需要修改 SELinux 策略以允许 App 访问 GPIO 设备文件。

定义设备类型：为 GPIO 设备定义一个新的 SELinux 类型（如 gpio_led_device_t）。

在SDK_dir/device/sprd/sharkle/common/sepolicy/device.te 添加

  1. # 定义新的设备类型
  2.  
  3. type gpio_led_device_t, dev_type;

分配文件上下文：为 GPIO 设备文件分配新定义的 SELinux 类型。

SDK_dir/device/sprd/sharkle/common/sepolicy/file_contexts中添加

/dev/gpio_led_device u:object_r:gpio_led_device_t:s0

授予权限：在 SELinux 策略中添加规则，允许 App 访问 GPIO 设备。

SDK_dir/device/sprd/sharkle/common/sepolicy/system_app.te

  1. # 允许 system_app 访问 gpio_led_device
  2.  
  3. allow system_app gpio_led_device_t:chr_file { read write };

重新编译 SELinux 策略：对更改的 SELinux 策略进行编译，并将其部署到设备上。这一步骤的目的是将自定义的安全策略更改应用到Android构建系统的预设SELinux策略中，确保在编译系统镜像时，这些更改会被包含进去。

  1. cp system/sepolicy/public/app.te system/sepolicy/prebuilts/api/29.0/public/app.te
  2.  
  3. cp system/sepolicy/private/coredomain.te system/sepolicy/prebuilts/api/29.0/private/coredomain.te

3. 测试与部署

测试 App：在具有所需硬件支持的 Android 10 设备上测试 App。确保 App 能成功加载 native 库，并能通过 JNI 调用控制 GPIO。

SELinux 策略测试：验证 SELinux 策略更改是否允许 App 无障碍地访问 GPIO 设备。

问题排查：如果遇到访问被拒绝的情况，请检查 SELinux 审计日志以确定是否需要进一步调整策略。

3.1注意事项

安全性：在修改 SELinux 策略以增加访问权限时，务必小心谨慎，避免引入安全漏洞。

设备兼容性：确保你的实现考虑到了不同设备可能存在的硬件和配置差异。

文档和维护：适当记录你的设计和实现过程，包括 JNI 接口、native 代码和 SELinux 策略更改，以便于未来的审计和维护。

通过遵循以上步骤，你可以在遵守 Android 安全模型的同时，实现 App 对 GPIO 的有效控制。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/751658
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号