The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 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 | |
| 17 | #include <hardware/hardware.h> |
| 18 | |
| 19 | #include <cutils/properties.h> |
| 20 | |
| 21 | #include <dlfcn.h> |
| 22 | #include <string.h> |
| 23 | #include <pthread.h> |
| 24 | #include <errno.h> |
| 25 | #include <limits.h> |
Dan Willemsen | 4d53a04 | 2017-04-07 14:15:17 -0700 | [diff] [blame] | 26 | #include <stdio.h> |
| 27 | #include <unistd.h> |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 28 | |
| 29 | #define LOG_TAG "HAL" |
Dan Willemsen | 4d53a04 | 2017-04-07 14:15:17 -0700 | [diff] [blame] | 30 | #include <log/log.h> |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 31 | |
Jerry Zhang | 551e1f7 | 2018-06-20 17:04:52 -0700 | [diff] [blame^] | 32 | #if !defined(__ANDROID_RECOVERY__) |
Jiyong Park | 4d67d2e | 2017-05-11 02:15:07 +0900 | [diff] [blame] | 33 | #include <vndksupport/linker.h> |
Jerry Zhang | 551e1f7 | 2018-06-20 17:04:52 -0700 | [diff] [blame^] | 34 | #endif |
Jiyong Park | 4d67d2e | 2017-05-11 02:15:07 +0900 | [diff] [blame] | 35 | |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 36 | /** Base path of the hal modules */ |
Dan Willemsen | 86389d1 | 2014-02-16 10:07:15 -0800 | [diff] [blame] | 37 | #if defined(__LP64__) |
| 38 | #define HAL_LIBRARY_PATH1 "/system/lib64/hw" |
| 39 | #define HAL_LIBRARY_PATH2 "/vendor/lib64/hw" |
Hung-ying Tyan | 48f57ad | 2015-11-12 11:19:45 +0800 | [diff] [blame] | 40 | #define HAL_LIBRARY_PATH3 "/odm/lib64/hw" |
Dan Willemsen | 86389d1 | 2014-02-16 10:07:15 -0800 | [diff] [blame] | 41 | #else |
Brian Swetland | e755bd4 | 2010-09-19 03:41:01 -0700 | [diff] [blame] | 42 | #define HAL_LIBRARY_PATH1 "/system/lib/hw" |
| 43 | #define HAL_LIBRARY_PATH2 "/vendor/lib/hw" |
Hung-ying Tyan | 48f57ad | 2015-11-12 11:19:45 +0800 | [diff] [blame] | 44 | #define HAL_LIBRARY_PATH3 "/odm/lib/hw" |
Dan Willemsen | 86389d1 | 2014-02-16 10:07:15 -0800 | [diff] [blame] | 45 | #endif |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 46 | |
| 47 | /** |
| 48 | * There are a set of variant filename for modules. The form of the filename |
| 49 | * is "<MODULE_ID>.variant.so" so for the led module the Dream variants |
| 50 | * of base "ro.product.board", "ro.board.platform" and "ro.arch" would be: |
| 51 | * |
| 52 | * led.trout.so |
| 53 | * led.msm7k.so |
| 54 | * led.ARMV6.so |
| 55 | * led.default.so |
| 56 | */ |
| 57 | |
The Android Open Source Project | 8232b50 | 2009-03-13 13:04:23 -0700 | [diff] [blame] | 58 | static const char *variant_keys[] = { |
| 59 | "ro.hardware", /* This goes first so that it can pick up a different |
| 60 | file on the emulator. */ |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 61 | "ro.product.board", |
| 62 | "ro.board.platform", |
Mathias Agopian | cab816f | 2009-09-24 15:11:04 -0700 | [diff] [blame] | 63 | "ro.arch" |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 64 | }; |
Mathias Agopian | 3f03e98 | 2009-09-21 22:50:44 -0700 | [diff] [blame] | 65 | |
| 66 | static const int HAL_VARIANT_KEYS_COUNT = |
| 67 | (sizeof(variant_keys)/sizeof(variant_keys[0])); |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 68 | |
| 69 | /** |
Mathias Agopian | 8c4ab1f | 2009-06-11 16:32:05 -0700 | [diff] [blame] | 70 | * Load the file defined by the variant and if successful |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 71 | * return the dlopen handle and the hmi. |
| 72 | * @return 0 = success, !0 = failure. |
| 73 | */ |
| 74 | static int load(const char *id, |
Mathias Agopian | 3f03e98 | 2009-09-21 22:50:44 -0700 | [diff] [blame] | 75 | const char *path, |
| 76 | const struct hw_module_t **pHmi) |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 77 | { |
Andrei V. FOMITCHEV | ec2ddf5 | 2012-10-19 16:26:33 +0200 | [diff] [blame] | 78 | int status = -EINVAL; |
| 79 | void *handle = NULL; |
| 80 | struct hw_module_t *hmi = NULL; |
Justin Yun | 8f30cfc | 2017-11-30 16:45:16 +0900 | [diff] [blame] | 81 | #ifdef __ANDROID_VNDK__ |
| 82 | const bool try_system = false; |
| 83 | #else |
| 84 | const bool try_system = true; |
| 85 | #endif |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 86 | |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 87 | /* |
| 88 | * load the symbols resolving undefined symbols before |
| 89 | * dlopen returns. Since RTLD_GLOBAL is not or'd in with |
| 90 | * RTLD_NOW the external symbols will not be global |
| 91 | */ |
Justin Yun | 8f30cfc | 2017-11-30 16:45:16 +0900 | [diff] [blame] | 92 | if (try_system && |
| 93 | strncmp(path, HAL_LIBRARY_PATH1, strlen(HAL_LIBRARY_PATH1)) == 0) { |
Justin Yun | c571709 | 2017-05-23 16:30:43 +0900 | [diff] [blame] | 94 | /* If the library is in system partition, no need to check |
| 95 | * sphal namespace. Open it with dlopen. |
| 96 | */ |
| 97 | handle = dlopen(path, RTLD_NOW); |
| 98 | } else { |
Jerry Zhang | 551e1f7 | 2018-06-20 17:04:52 -0700 | [diff] [blame^] | 99 | #if defined(__ANDROID_RECOVERY__) |
| 100 | handle = dlopen(path, RTLD_NOW); |
| 101 | #else |
Justin Yun | c571709 | 2017-05-23 16:30:43 +0900 | [diff] [blame] | 102 | handle = android_load_sphal_library(path, RTLD_NOW); |
Jerry Zhang | 551e1f7 | 2018-06-20 17:04:52 -0700 | [diff] [blame^] | 103 | #endif |
Justin Yun | c571709 | 2017-05-23 16:30:43 +0900 | [diff] [blame] | 104 | } |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 105 | if (handle == NULL) { |
| 106 | char const *err_str = dlerror(); |
Steve Block | 60d056b | 2012-01-08 10:17:53 +0000 | [diff] [blame] | 107 | ALOGE("load: module=%s\n%s", path, err_str?err_str:"unknown"); |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 108 | status = -EINVAL; |
| 109 | goto done; |
| 110 | } |
| 111 | |
| 112 | /* Get the address of the struct hal_module_info. */ |
| 113 | const char *sym = HAL_MODULE_INFO_SYM_AS_STR; |
Mathias Agopian | a8a7516 | 2009-04-10 14:24:31 -0700 | [diff] [blame] | 114 | hmi = (struct hw_module_t *)dlsym(handle, sym); |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 115 | if (hmi == NULL) { |
Steve Block | 60d056b | 2012-01-08 10:17:53 +0000 | [diff] [blame] | 116 | ALOGE("load: couldn't find symbol %s", sym); |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 117 | status = -EINVAL; |
| 118 | goto done; |
| 119 | } |
| 120 | |
| 121 | /* Check that the id matches */ |
| 122 | if (strcmp(id, hmi->id) != 0) { |
Steve Block | 60d056b | 2012-01-08 10:17:53 +0000 | [diff] [blame] | 123 | ALOGE("load: id=%s != hmi->id=%s", id, hmi->id); |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 124 | status = -EINVAL; |
| 125 | goto done; |
| 126 | } |
Mathias Agopian | 3f03e98 | 2009-09-21 22:50:44 -0700 | [diff] [blame] | 127 | |
Mathias Agopian | a8a7516 | 2009-04-10 14:24:31 -0700 | [diff] [blame] | 128 | hmi->dso = handle; |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 129 | |
| 130 | /* success */ |
| 131 | status = 0; |
| 132 | |
Mathias Agopian | 3f03e98 | 2009-09-21 22:50:44 -0700 | [diff] [blame] | 133 | done: |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 134 | if (status != 0) { |
| 135 | hmi = NULL; |
| 136 | if (handle != NULL) { |
| 137 | dlclose(handle); |
| 138 | handle = NULL; |
| 139 | } |
Mathias Agopian | 6d125da | 2009-07-15 15:01:10 -0700 | [diff] [blame] | 140 | } else { |
Steve Block | 7567eba | 2011-10-20 13:58:15 +0100 | [diff] [blame] | 141 | ALOGV("loaded HAL id=%s path=%s hmi=%p handle=%p", |
Ernie Hua | 5c7a3bd | 2018-07-10 15:15:40 -0700 | [diff] [blame] | 142 | id, path, hmi, handle); |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | *pHmi = hmi; |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 146 | |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 147 | return status; |
| 148 | } |
| 149 | |
Colin Cross | 85ab5d1 | 2013-12-26 13:47:56 -0800 | [diff] [blame] | 150 | /* |
| 151 | * Check if a HAL with given name and subname exists, if so return 0, otherwise |
| 152 | * otherwise return negative. On success path will contain the path to the HAL. |
| 153 | */ |
| 154 | static int hw_module_exists(char *path, size_t path_len, const char *name, |
| 155 | const char *subname) |
| 156 | { |
| 157 | snprintf(path, path_len, "%s/%s.%s.so", |
Hung-ying Tyan | 48f57ad | 2015-11-12 11:19:45 +0800 | [diff] [blame] | 158 | HAL_LIBRARY_PATH3, name, subname); |
| 159 | if (access(path, R_OK) == 0) |
| 160 | return 0; |
| 161 | |
| 162 | snprintf(path, path_len, "%s/%s.%s.so", |
Colin Cross | 85ab5d1 | 2013-12-26 13:47:56 -0800 | [diff] [blame] | 163 | HAL_LIBRARY_PATH2, name, subname); |
| 164 | if (access(path, R_OK) == 0) |
| 165 | return 0; |
| 166 | |
Justin Yun | 8f30cfc | 2017-11-30 16:45:16 +0900 | [diff] [blame] | 167 | #ifndef __ANDROID_VNDK__ |
Colin Cross | 85ab5d1 | 2013-12-26 13:47:56 -0800 | [diff] [blame] | 168 | snprintf(path, path_len, "%s/%s.%s.so", |
| 169 | HAL_LIBRARY_PATH1, name, subname); |
| 170 | if (access(path, R_OK) == 0) |
| 171 | return 0; |
Justin Yun | 8f30cfc | 2017-11-30 16:45:16 +0900 | [diff] [blame] | 172 | #endif |
Colin Cross | 85ab5d1 | 2013-12-26 13:47:56 -0800 | [diff] [blame] | 173 | |
| 174 | return -ENOENT; |
| 175 | } |
| 176 | |
Dima Zavin | 54921de | 2011-04-18 10:55:37 -0700 | [diff] [blame] | 177 | int hw_get_module_by_class(const char *class_id, const char *inst, |
| 178 | const struct hw_module_t **module) |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 179 | { |
Andrei V. FOMITCHEV | ec2ddf5 | 2012-10-19 16:26:33 +0200 | [diff] [blame] | 180 | int i = 0; |
| 181 | char prop[PATH_MAX] = {0}; |
| 182 | char path[PATH_MAX] = {0}; |
| 183 | char name[PATH_MAX] = {0}; |
| 184 | char prop_name[PATH_MAX] = {0}; |
| 185 | |
Dima Zavin | 54921de | 2011-04-18 10:55:37 -0700 | [diff] [blame] | 186 | |
| 187 | if (inst) |
| 188 | snprintf(name, PATH_MAX, "%s.%s", class_id, inst); |
| 189 | else |
| 190 | strlcpy(name, class_id, PATH_MAX); |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 191 | |
| 192 | /* |
| 193 | * Here we rely on the fact that calling dlopen multiple times on |
| 194 | * the same .so will simply increment a refcount (and not load |
| 195 | * a new copy of the library). |
| 196 | * We also assume that dlopen() is thread-safe. |
| 197 | */ |
The Android Open Source Project | 8232b50 | 2009-03-13 13:04:23 -0700 | [diff] [blame] | 198 | |
Colin Cross | 85ab5d1 | 2013-12-26 13:47:56 -0800 | [diff] [blame] | 199 | /* First try a property specific to the class and possibly instance */ |
| 200 | snprintf(prop_name, sizeof(prop_name), "ro.hardware.%s", name); |
Colin Cross | f7d761c | 2014-01-13 23:43:23 -0800 | [diff] [blame] | 201 | if (property_get(prop_name, prop, NULL) > 0) { |
Colin Cross | 85ab5d1 | 2013-12-26 13:47:56 -0800 | [diff] [blame] | 202 | if (hw_module_exists(path, sizeof(path), name, prop) == 0) { |
| 203 | goto found; |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 204 | } |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 205 | } |
The Android Open Source Project | 8232b50 | 2009-03-13 13:04:23 -0700 | [diff] [blame] | 206 | |
Colin Cross | 85ab5d1 | 2013-12-26 13:47:56 -0800 | [diff] [blame] | 207 | /* Loop through the configuration variants looking for a module */ |
| 208 | for (i=0 ; i<HAL_VARIANT_KEYS_COUNT; i++) { |
| 209 | if (property_get(variant_keys[i], prop, NULL) == 0) { |
| 210 | continue; |
| 211 | } |
| 212 | if (hw_module_exists(path, sizeof(path), name, prop) == 0) { |
| 213 | goto found; |
| 214 | } |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 215 | } |
Mathias Agopian | 3f03e98 | 2009-09-21 22:50:44 -0700 | [diff] [blame] | 216 | |
Colin Cross | 85ab5d1 | 2013-12-26 13:47:56 -0800 | [diff] [blame] | 217 | /* Nothing found, try the default */ |
| 218 | if (hw_module_exists(path, sizeof(path), name, "default") == 0) { |
| 219 | goto found; |
| 220 | } |
| 221 | |
| 222 | return -ENOENT; |
| 223 | |
| 224 | found: |
| 225 | /* load the module, if this fails, we're doomed, and we should not try |
| 226 | * to load a different variant. */ |
| 227 | return load(class_id, path, module); |
The Android Open Source Project | f53ebec | 2009-03-03 19:32:14 -0800 | [diff] [blame] | 228 | } |
Dima Zavin | 54921de | 2011-04-18 10:55:37 -0700 | [diff] [blame] | 229 | |
| 230 | int hw_get_module(const char *id, const struct hw_module_t **module) |
| 231 | { |
| 232 | return hw_get_module_by_class(id, NULL, module); |
| 233 | } |