SPI模块的JNI方法提供Java访问HAL层服务接口【转】

来自：http://blog.csdn.net/hanbo622/article/details/38944895

1、在frameworks/base/services/jni下创建spijni文件夹。

2、在spijni目录下创建com_android_server_SpiService.cpp和Android.mk。

com_android_server_SpiService.cpp

[java] view plain copy

1. #define LOG_TAG "SpiService"  
2. #include "jni.h"  
3. #include "JNIHelp.h"  
4. #include "android_runtime/AndroidRuntime.h"  
5. #include <utils/misc.h>  
6. #include <utils/Log.h>  
7. #include <hardware/hardware.h>  
8. #include <hardware/spihal.h>  
9. #include <stdio.h>  
10. #include <fcntl.h>  
11.   
12. namespace android  
13. {  
14.     /* 定义访问HAL层函数结构体 */  
15.     struct spi_device_t *spi_device = NULL;  
16.     /* 定义spi读函数 */  
17.     static jint spi_jni_read(JNIEnv *env, jobject clazz, jbyteArray jread_arr, jint len)  
18.     {  
19.         jbyte *array = NULL;  
20.         jboolean *buf;  
21.         int i = 0;  
22.   
23.         ALOGE("Jni Spi Read ...\n");  
24.         array = env->GetByteArrayElements(jread_arr, NULL);  
25.         if(array == NULL)  
26.         {  
27.             ALOGE("JniSpiRead: getByteArrayElements error!\n");  
28.             return -1;  
29.         }  
30.         buf = (jboolean *)calloc(sizeof(*array), sizeof(jboolean));  
31.         if(buf == NULL)  
32.         {  
33.             ALOGE("JniSpiRead: calloc error!\n");  
34.             return -1;  
35.         }  
36.           
37.         spi_device->spi_read(spi_device, buf, len);  
38.         for(i = 0; i < len; i++)  
39.         {  
40.             ALOGE("Spi Jni Read: data : %#x\n",*(buf + i));  
41.             *(array + i) = (jchar)(*(buf + i));  
42.         }  
43.         env->ReleaseByteArrayElements(jread_arr, array, 0);  
44.         free(buf);  
45.         buf = NULL;  
46.         return 0;  
47.           
48.     }  
49.     /* 定义spi写函数 */  
50.     static jint spi_jni_write(JNIEnv *env, jobject clazz, jbyteArray jwrite_arr, jint len)  
51.     {  
52.         jbyte *array = NULL;  
53.         jboolean *buf;  
54.         int i = 0;  
55.   
56.         ALOGE("Jni Spi Write ...\n");  
57.         array = env->GetByteArrayElements(jwrite_arr, NULL);  
58.         if(array == NULL)  
59.         {  
60.             ALOGE("JniSpiWrite: getByteArrayElements error!\n");  
61.             return -1;  
62.         }  
63.         buf = (jboolean *)calloc(sizeof(*array), sizeof(jboolean));  
64.         if(buf == NULL)  
65.         {  
66.             ALOGE("JniSpiWrite: calloc error!\n");  
67.             return -1;  
68.         }  
69.         for(i = 0; i < len; i++)  
70.         {  
71.             *(buf + i) = (jboolean)(*(array + i));  
72.             ALOGE("Spi Jni Write: data : %#x\n",*(buf + i));  
73.         }  
74.         env->ReleaseByteArrayElements(jwrite_arr, array, 0);  
75.           
76.         spi_device->spi_write(spi_device, buf, len);  
77.         free(buf);  
78.         buf = NULL;  
79.         return 0;  
80.     }  
81.     /* 定义spi打开函数 */  
82.     static inline int spi_jni_open(const hw_module_t * module, struct spi_device_t **device)  
83.     {  
84.         return module->methods->open(module, SPI_HARDWARE_MODULE_ID, (struct hw_device_t **)device);  
85.     }  
86.     /* 定义spi初始化函数 */  
87.     static jboolean spi_jni_init(JNIEnv *env, jclass clazz)  
88.     {  
89.         spi_module_t *Jspi_module;  
90.         ALOGE("Spi JNI: spi initializing ...\n");  
91.         if(hw_get_module(SPI_HARDWARE_MODULE_ID, (const struct hw_module_t **)&Jspi_module) == 0)  
92.         {  
93.             ALOGE("Spi JNI: spi stub found.\n");  
94.             if(spi_jni_open(&(Jspi_module->common), &spi_device) == 0)  
95.             {  
96.                 ALOGE("Spi JNI: spi device is open.\n");  
97.                 if(spi_device)  
98.                 {  
99.                     spi_device->spi_init(spi_device);  
100.                     ALOGE("Spi JNI: spi init successfuly!\n");  
101.                     return true;  
102.                 }  
103.                 ALOGE("Spi JNI: spi init failed.\n");  
104.                 return false;  
105.             }  
106.             ALOGE("Spi JNI: failed to open spi device.\n");  
107.             return false;  
108.         }  
109.         ALOGE("Spi JNI: failed to get spi stub module.\n");  
110.         return false;  
111.     }  
112.     /* JNI方法 */  
113.     static const JNINativeMethod method_table[] =   
114.     {  
115.         {"native_init", "()Z", (void *)spi_jni_init},  
116.         {"native_write", "([BI)I", (void *)spi_jni_write},  
117.         {"native_read", "([BI)I", (void *)spi_jni_read},  
118.     };  
119.     /* 注册JNI方法 */  
120.     static int registerMethods(JNIEnv *env)  
121.     {  
122.         static const char *const kClassName = "com/android/server/SpiService";  
123.         jclass clazz;  
124.         clazz = env->FindClass(kClassName);  
125.         if(clazz == NULL)  
126.         {  
127.             ALOGE("Can't find class %s\n",kClassName);  
128.             return -1;  
129.         }  
130.         if(env->RegisterNatives(clazz,method_table, sizeof(method_table)/sizeof(method_table[0])) != JNI_OK)  
131.         {  
132.             ALOGE("Failed registering methods for %s\n",kClassName);  
133.             return -1;  
134.         }  
135.         return 0;  
136.     }  
137.     extern "C"   
138.       
139.     jint JNI_OnLoad(JavaVM *vm, void *reserved)  
140.     {  
141.         JNIEnv *env = NULL;  
142.         jint result = -1;  
143.         ALOGE("Jni OnLoad ...\n");  
144.         if(vm->GetEnv((void **)&env, JNI_VERSION_1_4) != JNI_OK)  
145.         {  
146.             ALOGE("ERROR: GetEnv failed .\n");  
147.             goto fail;  
148.         }  
149.         assert(env != NULL);  
150.         if(registerMethods(env) != 0)  
151.         {  
152.             ALOGE("ERROR: PlatformLibrary native registeration failed .\n");  
153.             goto fail;  
154.         }  
155.         result = JNI_VERSION_1_4;  
156. fail:  
157.         return result;  
158.     }  
159. };  

Android.mk

[java] view plain copy

1. LOCAL_PATH:= $(call my-dir)  
2. include $(CLEAR_VARS)  
3.   
4. LOCAL_SRC_FILES:= \  
5.     com_android_server_SpiService.cpp \  
6.   
7. LOCAL_C_INCLUDES += \  
8.     $(JNI_H_INCLUDE) \  
9.     frameworks/base/services \  
10.     frameworks/base/core/jni \  
11.     external/skia/include/core \  
12.     libcore/include \  
13.     libcore/include/libsuspend \  
14.     $(call include-path-for, libhardware)/hardware \  
15.     $(call include-path-for, libhardware_legacy)/hardware_legacy \  
16.   
17. LOCAL_SHARED_LIBRARIES := \  
18.     libandroid_runtime \  
19.     libandroidfw \  
20.     libcutils \  
21.     liblog \  
22.     libhardware \  
23.     libhardware_legacy \  
24.     libnativehelper \  
25.     libsystem_server \  
26.     libutils \  
27.     libui \  
28.     libinput \  
29.     libskia \  
30.     libgui \  
31.     libusbhost \  
32.     libsuspend  
33.   
34. ifeq ($(WITH_MALLOC_LEAK_CHECK),true)  
35.     LOCAL_CFLAGS += -DMALLOC_LEAK_CHECK  
36. endif  
37.   
38. LOCAL_MODULE:= libspi_servers  
39.   
40. include $(BUILD_SHARED_LIBRARY)  

3、在源码主目录下编译执行命令：mmm  frameworks/base/services/jni。

4、生成库的路径out/target/product/sabresd_6dq/symbols/system/lib/libspi_servers.so。

5、把生成的该库放到开发板的/system/lib目录下

     加执行权限 chown  root  libspi_servers.so

     chmod  777   libspi_servers.so

 

注意：如果无法打开设备节点/dev/spi1.0则

          加执行权限   chown  root  spi1.0

                             chmod  777   spi1.0

        无法加执行权限时执行：mount -o rw,remount -t ext4 /dev/block/mmcblk0p5 /system

                                                      chmod   777  /system