hardware.c

   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>
  26
  27 #define LOG_TAG "HAL"
  28 #include <utils/Log.h>
  29
  30 /** Base path of the hal modules */
  31 #if defined(__LP64__)
  32 #define HAL_LIBRARY_PATH1 "/system/lib64/hw"
  33 #define HAL_LIBRARY_PATH2 "/vendor/lib64/hw"
  34 #define HAL_LIBRARY_PATH3 "/odm/lib64/hw"
  35 #else
  36 #define HAL_LIBRARY_PATH1 "/system/lib/hw"
  37 #define HAL_LIBRARY_PATH2 "/vendor/lib/hw"
  38 #define HAL_LIBRARY_PATH3 "/odm/lib/hw"
  39 #endif
  40
  41 /**
  42  * There are a set of variant filename for modules. The form of the filename
  43  * is "<MODULE_ID>.variant.so" so for the led module the Dream variants
  44  * of base "ro.product.board", "ro.board.platform" and "ro.arch" would be:
  45  *
  46  * led.trout.so
  47  * led.msm7k.so
  48  * led.ARMV6.so
  49  * led.default.so
  50  */
  51
  52 static const char *variant_keys[] = {
  53     "ro.hardware",  /* This goes first so that it can pick up a different
  54                        file on the emulator. */
  55     "ro.product.board",
  56     "ro.board.platform",
  57     "ro.arch"
  58 };
  59
  60 static const int HAL_VARIANT_KEYS_COUNT =
  61     (sizeof(variant_keys)/sizeof(variant_keys[0]));
  62
  63 /**
  64  * Load the file defined by the variant and if successful
  65  * return the dlopen handle and the hmi.
  66  * @return 0 = success, !0 = failure.
  67  */
  68 static int load(const char *id,
  69         const char *path,
  70         const struct hw_module_t **pHmi)
  71 {
  72     int status = -EINVAL;
  73     void *handle = NULL;
  74     struct hw_module_t *hmi = NULL;
  75
  76     /*
  77      * load the symbols resolving undefined symbols before
  78      * dlopen returns. Since RTLD_GLOBAL is not or'd in with
  79      * RTLD_NOW the external symbols will not be global
  80      */
  81     handle = dlopen(path, RTLD_NOW);
  82     if (handle == NULL) {
  83         char const *err_str = dlerror();
  84         ALOGE("load: module=%s\n%s", path, err_str?err_str:"unknown");
  85         status = -EINVAL;
  86         goto done;
  87     }
  88
  89     /* Get the address of the struct hal_module_info. */
  90     const char *sym = HAL_MODULE_INFO_SYM_AS_STR;
  91     hmi = (struct hw_module_t *)dlsym(handle, sym);
  92     if (hmi == NULL) {
  93         ALOGE("load: couldn't find symbol %s", sym);
  94         status = -EINVAL;
  95         goto done;
  96     }
  97
  98     /* Check that the id matches */
  99     if (strcmp(id, hmi->id) != 0) {
 100         ALOGE("load: id=%s != hmi->id=%s", id, hmi->id);
 101         status = -EINVAL;
 102         goto done;
 103     }
 104
 105     hmi->dso = handle;
 106
 107     /* success */
 108     status = 0;
 109
 110     done:
 111     if (status != 0) {
 112         hmi = NULL;
 113         if (handle != NULL) {
 114             dlclose(handle);
 115             handle = NULL;
 116         }
 117     } else {
 118         ALOGV("loaded HAL id=%s path=%s hmi=%p handle=%p",
 119                 id, path, *pHmi, handle);
 120     }
 121
 122     *pHmi = hmi;
 123
 124     return status;
 125 }
 126
 127 /*
 128  * Check if a HAL with given name and subname exists, if so return 0, otherwise
 129  * otherwise return negative.  On success path will contain the path to the HAL.
 130  */
 131 static int hw_module_exists(char *path, size_t path_len, const char *name,
 132                             const char *subname)
 133 {
 134     snprintf(path, path_len, "%s/%s.%s.so",
 135              HAL_LIBRARY_PATH3, name, subname);
 136     if (access(path, R_OK) == 0)
 137         return 0;
 138
 139     snprintf(path, path_len, "%s/%s.%s.so",
 140              HAL_LIBRARY_PATH2, name, subname);
 141     if (access(path, R_OK) == 0)
 142         return 0;
 143
 144     snprintf(path, path_len, "%s/%s.%s.so",
 145              HAL_LIBRARY_PATH1, name, subname);
 146     if (access(path, R_OK) == 0)
 147         return 0;
 148
 149     return -ENOENT;
 150 }
 151
 152 int hw_get_module_by_class(const char *class_id, const char *inst,
 153                            const struct hw_module_t **module)
 154 {
 155     int i = 0;
 156     char prop[PATH_MAX] = {0};
 157     char path[PATH_MAX] = {0};
 158     char name[PATH_MAX] = {0};
 159     char prop_name[PATH_MAX] = {0};
 160
 161
 162     if (inst)
 163         snprintf(name, PATH_MAX, "%s.%s", class_id, inst);
 164     else
 165         strlcpy(name, class_id, PATH_MAX);
 166
 167     /*
 168      * Here we rely on the fact that calling dlopen multiple times on
 169      * the same .so will simply increment a refcount (and not load
 170      * a new copy of the library).
 171      * We also assume that dlopen() is thread-safe.
 172      */
 173
 174     /* First try a property specific to the class and possibly instance */
 175     snprintf(prop_name, sizeof(prop_name), "ro.hardware.%s", name);
 176     if (property_get(prop_name, prop, NULL) > 0) {
 177         if (hw_module_exists(path, sizeof(path), name, prop) == 0) {
 178             goto found;
 179         }
 180     }
 181
 182     /* Loop through the configuration variants looking for a module */
 183     for (i=0 ; i<HAL_VARIANT_KEYS_COUNT; i++) {
 184         if (property_get(variant_keys[i], prop, NULL) == 0) {
 185             continue;
 186         }
 187         if (hw_module_exists(path, sizeof(path), name, prop) == 0) {
 188             goto found;
 189         }
 190     }
 191
 192     /* Nothing found, try the default */
 193     if (hw_module_exists(path, sizeof(path), name, "default") == 0) {
 194         goto found;
 195     }
 196
 197     return -ENOENT;
 198
 199 found:
 200     /* load the module, if this fails, we're doomed, and we should not try
 201      * to load a different variant. */
 202     return load(class_id, path, module);
 203 }
 204
 205 int hw_get_module(const char *id, const struct hw_module_t **module)
 206 {
 207     return hw_get_module_by_class(id, NULL, module);
 208 }