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