FirePrime-RK3128 Android app use jni to control GPIO code

Firefly

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>
    
17. 
    
18. 
    
19. 
    
20. 
    
21. 
    
22. static struct UserData{
    
23.                 int gpio;
    
24.                 int state;
    
25. };
    
26. 
    
27. 
    
28. static struct of_device_id luobogpio_of_match[] = {
    
29.         { .compatible = "luobogpio" },
    
30.         { }
    
31. };
    
32. 
    
33. MODULE_DEVICE_TABLE(of, luobogpio_of_match);
    
34. 
    
35. 
    
36. static int luobogpio_open(struct inode *inode, struct file *filp)
    
37. {
    
38.     printk("luobogpio_open\n");
    
39. 
    
40.         return 0;
    
41. }
    
42. 
    
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. }
    
49. 
    
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];
    
55. 
    
56. 
    
57.         printk("luobogpio_ioctl: cmd = %d arg = %ld\n",cmd, arg);
    
58. 
    
59.         switch (cmd){
    
60. 
    
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.                
    
68. 
    
69. 
    
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);
    
96. 
    
97.           break;
    
98.                
    
99.                 default:
    
100.                         printk("unknown ioctl cmd!\n");
     
101.                         ret = -EINVAL;
     
102.                         break;
     
103.         }
     
104.         return ret;
     
105. }
     
106. 
     
107. static int luobogpio_release(struct inode *inode, struct file *filp)
     
108. {
     
109.     printk("luobogpio_release\n");
     
110.    
     
111.         return 0;
     
112. }
     
113. 
     
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. };
     
121. 
     
122. static struct miscdevice luobogpio_dev =
     
123. {
     
124.     .minor = MISC_DYNAMIC_MINOR,
     
125.     .name = "luobogpio",
     
126.     .fops = &luobogpio_fops,
     
127. };
     
128. 
     
129. 
     
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.         }
     
138. 
     
139.         printk("func: %s\n", __func__);
     
140.         return 0;
     
141. }
     
142. 
     
143. static int luobogpio_remove(struct platform_device *pdev)
     
144. {
     
145.         //printk("func: %s\n", __func__);
     
146.         return 0;
     
147. }
     
148. 
     
149. #ifdef CONFIG_PM_SLEEP
     
150. static int luobogpio_suspend(struct device *dev)
     
151. {
     
152.         //printk("func: %s\n", __func__);
     
153.         return 0;
     
154. }
     
155. 
     
156. static int luobogpio_resume(struct device *dev)
     
157. {
     
158.         //printk("func: %s\n", __func__);
     
159.         return 0;
     
160. }
     
161. #endif
     
162. 
     
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. };
     
171. 
     
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. };
     
182. 
     
183. module_platform_driver(luogpio_driver);
     
184. 
     
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){
   
2. 
   
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;
   
9. 
   
10.     ret = ioctl(fd, CMD_GET_GPIO, &userdata);
    
11.     return ret;
    
12. }
    
13. 
    
14. static jint releaseGpio(JNIEnv *env, jobject thiz,jint num){
    
15. 
    
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. }
    
24. 
    
25. static jint openGpioDev(JNIEnv *env, jobject thiz){
    
26. 
    
27. 
    
28.     jint ret=0;
    
29. 
    
30.     fd = open("/dev/luobogpio", O_RDWR);
    
31.     if (fd < 0) {
    
32.         ret=-1;
    
33.     }
    
34.     return ret;
    
35. }
    
36. 
    
37. static jint closeGpioDev(JNIEnv *env, jobject thiz){
    
38. 
    
39. 
    
40.     jint ret=0;
    
41. 
    
42.     ret = close(fd);
    
43.     if (fd < 0) {
    
44.         ret=-1;
    
45.     }
    
46.     return ret;
    
47. }
    
48. 
    
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;
    
55. 
    
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 {
   
2. 
   
3. 
   
4. 
   
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.     }
   
10. 
    
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);