1. /* 
2.  * Copyright (C) 2008 The Android Open Source Project 
3.  * 
4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
5.  * you may not use this file except in compliance with the License. 
6.  * You may obtain a copy of the License at 
7.  * 
8.  *      http://www.apache.org/licenses/LICENSE-2.0 
9.  * 
10.  * Unless required by applicable law or agreed to in writing, software 
11.  * distributed under the License is distributed on an "AS IS" BASIS, 
12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
13.  * See the License for the specific language governing permissions and 
14.  * limitations under the License. 
15.  */  
16.  #ifndef ANDROID_INCLUDE_HARDWARE_HARDWARE_H  
17.  #define ANDROID_INCLUDE_HARDWARE_HARDWARE_H 
18.  #include <stdint.h>  
19.  #include <sys/cdefs.h>  
20.  #include <cutils/native_handle.h>  
21.  #include <system/graphics.h>   
22. __BEGIN_DECLS  
23.   
24. /* 
25.  * Value for the hw_module_t.tag field 
26.  */  
27.   
28. #define MAKE_TAG_CONSTANT(A,B,C,D) (((A) << 24) | ((B) << 16) | ((C) << 8) | (D))  
29.   
30. #define HARDWARE_MODULE_TAG MAKE_TAG_CONSTANT(‘H‘, ‘W‘, ‘M‘, ‘T‘)  
31. #define HARDWARE_DEVICE_TAG MAKE_TAG_CONSTANT(‘H‘, ‘W‘, ‘D‘, ‘T‘)  
32.   
33. struct hw_module_t;  
34. struct hw_module_methods_t;  
35. struct hw_device_t;  
36.   
37. /** 
38.  * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM 
39.  * and the fields of this data structure must begin with hw_module_t 
40.  * followed by module specific information. 
41.  */  
42.  //每一个硬件模块都每必须有一个名为HAL_MODULE_INFO_SYM的数据结构变量，它的第一个成员的类型必须为hw_module_t  
43.  typedef struct hw_module_t {  
44.            /** tag must be initialized to HARDWARE_MODULE_TAG */  
45.            uint32_t tag;  
47.            /** major version number for the module */  
48.            uint16_t version_major;  
49.   
50.            /** minor version number of the module */  
51.            uint16_t version_minor;  
52.   
53.            /** Identifier of module */  
54.            const char *id;  
55.   
56.            /** Name of this module */  
57.            const char *name;  
58.   
59.           /** Author/owner/implementor of the module */  
60.           const char *author;  
61.   
62.           /** Modules methods模块方法列表,指向hw_module_methods_t */   
63.           struct hw_module_methods_t* methods;  
64.   
65.           /** module‘s dso */  
66.           void* dso;  
67.   
68.           /** padding to 128 bytes, reserved for future use */  
69.           uint32_t reserved[32-7];  
70.   
71.   } hw_module_t;  
72.   

　　  //硬件模块方法列表的定义，这里只定义了一个open函数 

1. typedef struct hw_module_methods_t {                   
2.             /** Open a specific device */  
3.             int (*open)(const struct hw_module_t* module, const char* id, //注意这个open函数明确指出第三个参数的类型为struct hw_device_t**  
4.             struct hw_device_t** device);  
5. } hw_module_methods_t;  
6.   

1. /** 
2.  * Every device data structure must begin with hw_device_t 
3.  * followed by module specific public methods and attributes. 
4.  */  
5. //每一个设备数据结构的第一个成员函数必须是hw_device_t类型，其次才是各个公共方法和属性  
6. typedef struct hw_device_t {  
7.     /** tag must be initialized to HARDWARE_DEVICE_TAG */  
8.     uint32_t tag;  
9.   
10.     /** version number for hw_device_t */  
11.     uint32_t version;  
12.   
13.     /** reference to the module this device belongs to */  
14.     struct hw_module_t* module;  
15.   
16.     /** padding reserved for future use */  
17.     uint32_t reserved[12];  
18.   
19.     /** Close this device */  
20.     int (*close)(struct hw_device_t* device);  
21.   
22. } hw_device_t;  
23.   
24. /** 
25.  * Name of the hal_module_info 
26.  */  
27. #define HAL_MODULE_INFO_SYM         HMI  
28.   
29. /** 
30.  * Name of the hal_module_info as a string 
31.  */  
32. #define HAL_MODULE_INFO_SYM_AS_STR  "HMI"  
33.   
34. /** 
35.  * Get the module info associated with a module by id. 
36.  * 
37.  * @return: 0 == success, <0 == error and *module == NULL 
38.  */  
39. int hw_get_module(const char *id, const struct hw_module_t **module);  
40.   
41. /** 
42.  * Get the module info associated with a module instance by class ‘class_id‘ 
43.  * and instance ‘inst‘. 
44.  * 
45.  * Some modules types necessitate multiple instances. For example audio supports 
46.  * multiple concurrent interfaces and thus ‘audio‘ is the module class 
47.  * and ‘primary‘ or ‘a2dp‘ are module interfaces. This implies that the files 
48.  * providing these modules would be named audio.primary.<variant>.so and 
49.  * audio.a2dp.<variant>.so 
50.  * 
51.  * @return: 0 == success, <0 == error and *module == NULL 
52.  */  
53. int hw_get_module_by_class(const char *class_id, const char *inst,  
54.                            const struct hw_module_t **module);  
55.   
56. __END_DECLS  
57.   
58. #endif  /* ANDROID_INCLUDE_HARDWARE_HARDWARE_H */  

1. /*定义模块ID*/  
2. #define XXX_HARDWARE_MODULE_ID "XXX"  
3.   
4. /*硬件模块结构体*/  
5. //见hardware.h中的hw_module_t定义的说明，xxx_module_t的第一个成员必须是hw_module_t类型，其次才是模块的一此相关信息，当然也可以不定义，  
6. //这里就没有定义模块相关信息  
7. struct xxx_module_t {  
8.     struct hw_module_t common;  
9. };  
10.   
11. /*硬件接口结构体*/  
12. //见hardware.h中的hw_device_t的说明，要求自定义xxx_device_t的第一个成员必须是hw_device_t类型，其次才是其它的一些接口信息.   
13. struct xxx_device_t {  
14.     struct hw_device_t common;  
15.         //以下成员是HAL对上层提供的接口或一些属性  
16.         int fd;  
17.     int (*set_val)(struct xxx_device_t* dev, int val);  
18.     int (*get_val)(struct xxx_device_t* dev, int* val);  
19. };  

1. /*模块实例变量*/  
2. struct xxx_module_t HAL_MODULE_INFO_SYM = {    //变量名必须为HAL_MODULE_INFO_SYM,这是强制要求的，你要写Android的HAL就得遵循这个游戏规则,  
3.                                                //见hardware.h中的hw_module_t的类型信息说明.  
4.         common: {  
5.         tag: HARDWARE_MODULE_TAG,  
6.         version_major: 1,  
7.         version_minor: 0,  
8.         id: XXX_HARDWARE_MODULE_ID,    //头文件中有定义  
9.         name: MODULE_NAME,  
10.         author: MODULE_AUTHOR,  
11.         methods: &xxx_module_methods,  //模块方法列表，在本地定义  
12.     }  
13. };  

1. /*模块方法表*/  
2. static struct hw_module_methods_t xxx_module_methods = {  
3.     open: xxx_device_open  
4. };  

1. static int xxx_device_open(const struct hw_module_t* module, const char* name, struct hw_device_t** device) {  
2.     struct xxx_device_t* dev;  
3.     dev = (struct hello_device_t*)malloc(sizeof(struct xxx_device_t));//动态分配空间  
4.       
5.     if(!dev) {  
6.         LOGE("Hello Stub: failed to alloc space");  
7.         return -EFAULT;  
8.     }  
9.   
10.     memset(dev, 0, sizeof(struct xxx_device_t));  
11.         //对dev->common的内容赋值，  
12.         dev->common.tag = HARDWARE_DEVICE_TAG;  
13.     dev->common.version = 0;  
14.     dev->common.module = (hw_module_t*)module;  
15.     dev->common.close = xxx_device_close;  
16.         //对dev其它成员赋值  
17.         dev->set_val = xxx_set_val;  
18.     dev->get_val = xxx_get_val;  
19.   
20.     if((dev->fd = open(DEVICE_NAME, O_RDWR)) == -1) {  
21.         LOGE("Hello Stub: failed to open /dev/hello -- %s.", strerror(errno));  
22.         free(dev);  
23.         return -EFAULT;  
24.     }  
25.           
26.         //输出&(dev->common),输出的并不是dev,而是&(dev->common)!(common内不是只包含了一个close接口吗?)  
27.     *device = &(dev->common);  
28.     LOGI("Hello Stub: open /dev/hello successfully.");  
29.   
30.     return 0;  
31. }  

1. typedef struct hw_module_methods_t {  
2.     /** Open a specific device */  
3.     int (*open)(const struct hw_module_t* module, const char* id,  
4.             struct hw_device_t** device);  
5.   
6. } hw_module_methods_t;  

1. /*通过硬件抽象层定义的硬件模块打开接口打开硬件设备*/    
2. static inline int hello_device_open(const hw_module_t* module, struct hello_device_t** device) {    
3.      return module->methods->open(module, HELLO_HARDWARE_MODULE_ID, (struct hw_device_t**)device);    
4. }