Firefly Open Source Community

Title: FirePrime-RK3128 Android app use jni to control GPIO code [Print This Page]
Author: Firefly    Time: 10/12/2015 17:11
Title: FirePrime-RK3128 Android app use jni to control GPIO code
Sharing by carlinluo

Driver
  1. #include <dt-bindings/gpio/gpio.h>
  2. #include <linux/gpio.h>
  3. #include <linux/of_gpio.h>
  4. #include <linux/module.h>
  5. #include <linux/kernel.h>
  6. #include <linux/init.h>
  7. #include <linux/platform_device.h>
  8. #include <linux/fb.h>
  9. #include <linux/backlight.h>
  10. #include <linux/err.h>
  11. #include <linux/pwm.h>
  12. #include <linux/pwm_backlight.h>
  13. #include <linux/slab.h>
  14. #include <linux/device.h>
  15. #include <linux/miscdevice.h>
  16. #include <asm/uaccess.h>





  22. static struct UserData{
  23.                 int gpio;
  24.                 int state;
  25. };


  28. static struct of_device_id luobogpio_of_match[] = {
  29.         { .compatible = "luobogpio" },
  30.         { }
  31. };

  33. MODULE_DEVICE_TABLE(of, luobogpio_of_match);


  36. static int luobogpio_open(struct inode *inode, struct file *filp)
  37. {
  38.     printk("luobogpio_open\n");

  40.         return 0;
  41. }

  43. static ssize_t luobogpio_read(struct file *filp, char __user *ptr, size_t size, loff_t *pos)
  44. {
  45.         if (ptr == NULL)
  46.                 printk("%s: user space address is NULL\n", __func__);
  47.         return sizeof(int);
  48. }

  50. static long luobogpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
  51. {
  52.         long ret = 0;        
  53.         struct UserData userdata;
  54.         unsigned char label[10];


  57.         printk("luobogpio_ioctl: cmd = %d arg = %ld\n",cmd, arg);

  59.         switch (cmd){

  61.         case 0:
  62.                                 printk("gpio_request\n");
  63.                                 
  64.                                 if (copy_from_user((void*)&userdata,(void __user *)arg, sizeof(struct UserData)))
  65.                 return -EFAULT;
  66.                 printk("copy_from_user  gpio=%d ,state=%d\n",userdata.gpio,userdata.state);
  67.                


  70.                 sprintf(label,"gpio-%d",userdata.gpio);
  71.                 printk("----->%s\n",label);
  72.                                 ret = gpio_request(userdata.gpio, label);
  73.                                 if (ret) {
  74.                                            printk("failed to request GPIO%d for you ret:%d\n",userdata.gpio,ret);
  75.                                  }
  76.                           break;
  77.          case 1:
  78.                   
  79.                             printk("gpio_direction_output\n");
  80.                           
  81.                             if (copy_from_user((void*)&userdata,(void __user *)arg, sizeof(struct UserData)))
  82.                 return -EFAULT;
  83.                 printk("copy_from_user  gpio=%d ,state=%d\n",userdata.gpio,userdata.state);
  84.                             ret=gpio_direction_output(userdata.gpio, userdata.state);
  85.                                   if (ret) {
  86.                                 printk("failed to gpio_direction_output  for you ret:%d\n",userdata.gpio);
  87.                                  }
  88.           break;
  89.                         
  90.           case 5:
  91.                                 printk("gpio_free\n");
  92.                                   if (copy_from_user((void*)&userdata,(void __user *)arg, sizeof(struct UserData)))
  93.                 return -EFAULT;
  94.                 printk("copy_from_user  gpio=%d ,state=%d\n",userdata.gpio,userdata.state);
  95.                                 gpio_free(userdata.gpio);

  97.           break;
  98.                
  99.                 default:
  100.                         printk("unknown ioctl cmd!\n");
  101.                         ret = -EINVAL;
  102.                         break;
  103.         }
  104.         return ret;
  105. }

  107. static int luobogpio_release(struct inode *inode, struct file *filp)
  108. {
  109.     printk("luobogpio_release\n");
  110.    
  111.         return 0;
  112. }

  114. static struct file_operations luobogpio_fops = {
  115.         .owner   = THIS_MODULE,
  116.         .open    = luobogpio_open,
  117.         .read    = luobogpio_read,
  118.         .unlocked_ioctl   = luobogpio_ioctl,
  119.         .release = luobogpio_release,
  120. };

  122. static struct miscdevice luobogpio_dev =
  123. {
  124.     .minor = MISC_DYNAMIC_MINOR,
  125.     .name = "luobogpio",
  126.     .fops = &luobogpio_fops,
  127. };


  130. static int luobogpio_probe(struct platform_device *pdev)
  131. {
  132.     int ret=-1;
  133.         ret = misc_register(&luobogpio_dev);
  134.         if (ret < 0){
  135.                 printk("ac_usb_switch register err!\n");
  136.                 return ret;
  137.         }

  139.         printk("func: %s\n", __func__);
  140.         return 0;
  141. }

  143. static int luobogpio_remove(struct platform_device *pdev)
  144. {
  145.         //printk("func: %s\n", __func__);
  146.         return 0;
  147. }

  149. #ifdef CONFIG_PM_SLEEP
  150. static int luobogpio_suspend(struct device *dev)
  151. {
  152.         //printk("func: %s\n", __func__);
  153.         return 0;
  154. }

  156. static int luobogpio_resume(struct device *dev)
  157. {
  158.         //printk("func: %s\n", __func__);
  159.         return 0;
  160. }
  161. #endif

  163. static const struct dev_pm_ops luobogpio_pm_ops = {
  164. #ifdef CONFIG_PM_SLEEP
  165.         .suspend = luobogpio_suspend,
  166.         .resume = luobogpio_resume,
  167.         .poweroff = luobogpio_suspend,
  168.         .restore = luobogpio_resume,
  169. #endif
  170. };

  172. static struct platform_driver luogpio_driver = {
  173.         .driver                = {
  174.                 .name                = "luobogpio",
  175.                 .owner                = THIS_MODULE,
  176.                 .pm                = &luobogpio_pm_ops,
  177.                 .of_match_table        = of_match_ptr(luobogpio_of_match),
  178.         },
  179.         .probe                = luobogpio_probe,
  180.         .remove                = luobogpio_remove,
  181. };

  183. module_platform_driver(luogpio_driver);

  185. MODULE_DESCRIPTION("luobogpio Driver");
  186. MODULE_LICENSE("GPL");
  187. MODULE_ALIAS("platform:luobogpio");
Copy the code


JNI
  1. static jint getGpio(JNIEnv *env, jobject thiz,jint num){

  3.     jint ret=-1;
  4.     UserData userdata;
  5.     memset(&userdata,0x00, sizeof(UserData));
  6.     //strlcpy(userdata.name, "gpio",10);
  7.     userdata.gpio=num;
  8.     userdata.state=0;

  10.     ret = ioctl(fd, CMD_GET_GPIO, &userdata);
  11.     return ret;
  12. }

  14. static jint releaseGpio(JNIEnv *env, jobject thiz,jint num){

  16.     jint ret=-1;
  17.     UserData userdata;
  18.     memset(&userdata,0x00, sizeof(UserData));
  19.     userdata.gpio=num;
  20.     userdata.state=0;
  21.     ret = ioctl(fd, CMD_RELEASE_GPIO, &userdata);
  22.     return ret;
  23. }

  25. static jint openGpioDev(JNIEnv *env, jobject thiz){


  28.     jint ret=0;

  30.     fd = open("/dev/luobogpio", O_RDWR);
  31.     if (fd < 0) {
  32.         ret=-1;
  33.     }
  34.     return ret;
  35. }

  37. static jint closeGpioDev(JNIEnv *env, jobject thiz){


  40.     jint ret=0;

  42.     ret = close(fd);
  43.     if (fd < 0) {
  44.         ret=-1;
  45.     }
  46.     return ret;
  47. }

  49. static jint setGpioState(JNIEnv *env, jobject thiz,jint num,jint state) {
  50.     jint err=-1;
  51.     UserData userdata;
  52.     memset(&userdata,0x00, sizeof(UserData));
  53.     userdata.gpio=num;
  54.     userdata.state=state;

  56.     err = ioctl(fd, CMD_SET_GPIO, &userdata);
  57.     if(err<0){
  58.         err=-1;
  59.     }
  60.     return err;
  61. }
Copy the code


APP

  1. public class LuoboHardware {



  5.     static {
  6.         // The runtime will add "lib" on the front and ".o" on the end of
  7.         // the name supplied to loadLibrary.
  8.         System.loadLibrary("app");
  9.     }

  11.     public native int add(int a, int b);
  12.     public native int openGpioDev();
  13.     public native int closeGpioDev();
  14.     public native int getGpio(int num);
  15.     public native int releaseGpio(int num);
  16.     public native int setGpioState(int num,int state);
  17. }
Copy the code




Wrote a simple app, you can control GPIO by the following method , DO remember to give permissions to driven node first.

adb root ->adb shell chmod 777 dev/luobogpio   
    public native int openGpioDev();
    public native int closeGpioDev();
    public native int getGpio(int num);
    public native int releaseGpio(int num);
    public native int setGpioState(int num,int state);



Welcome Firefly Open Source Community (https://bbs.t-firefly.com/) Powered by Discuz! X3.1