From f53ebec38718ff5d6b2aff2fa62b92a75d007ca5 Mon Sep 17 00:00:00 2001 From: The Android Open Source Project Date: Tue, 3 Mar 2009 19:32:14 -0800 Subject: [PATCH] auto import from //depot/cupcake/@135843 --- Android.mk | 35 +++ MODULE_LICENSE_APACHE2 | 0 NOTICE | 190 +++++++++++++++++ hardware.c | 167 +++++++++++++++ include/hardware/copybit.h | 216 +++++++++++++++++++ include/hardware/hardware.h | 148 +++++++++++++ include/hardware/overlay.h | 225 ++++++++++++++++++++ include/hardware/sensors.h | 375 +++++++++++++++++++++++++++++++++ modules/README.android | 23 ++ modules/overlay/Android.mk | 26 +++ modules/overlay/README.android | 3 + modules/overlay/overlay.cpp | 321 ++++++++++++++++++++++++++++ 12 files changed, 1729 insertions(+) create mode 100644 Android.mk create mode 100644 MODULE_LICENSE_APACHE2 create mode 100644 NOTICE create mode 100644 hardware.c create mode 100644 include/hardware/copybit.h create mode 100644 include/hardware/hardware.h create mode 100644 include/hardware/overlay.h create mode 100644 include/hardware/sensors.h create mode 100644 modules/README.android create mode 100644 modules/overlay/Android.mk create mode 100644 modules/overlay/README.android create mode 100644 modules/overlay/overlay.cpp diff --git a/Android.mk b/Android.mk new file mode 100644 index 00000000..b2e9caf9 --- /dev/null +++ b/Android.mk @@ -0,0 +1,35 @@ +# Copyright 2006 The Android Open Source Project + +# Setting LOCAL_PATH will mess up all-subdir-makefiles, so do it beforehand. +SAVE_MAKEFILES := $(call all-subdir-makefiles) + +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_SHARED_LIBRARIES := libcutils + +LOCAL_INCLUDES += $(LOCAL_PATH) + +ifneq ($(TARGET_SIMULATOR),true) + LOCAL_CFLAGS += -DQEMU_HARDWARE + QEMU_HARDWARE := true +endif + +ifneq ($(TARGET_SIMULATOR),true) +LOCAL_SHARED_LIBRARIES += libdl +endif + +include $(SAVE_MAKEFILES) + +LOCAL_SRC_FILES += hardware.c + +# need "-lrt" on Linux simulator to pick up clock_gettime +ifeq ($(TARGET_SIMULATOR),true) + ifeq ($(HOST_OS),linux) + LOCAL_LDLIBS += -lrt -lpthread -ldl + endif +endif + +LOCAL_MODULE:= libhardware + +include $(BUILD_SHARED_LIBRARY) diff --git a/MODULE_LICENSE_APACHE2 b/MODULE_LICENSE_APACHE2 new file mode 100644 index 00000000..e69de29b diff --git a/NOTICE b/NOTICE new file mode 100644 index 00000000..c5b1efa7 --- /dev/null +++ b/NOTICE @@ -0,0 +1,190 @@ + + Copyright (c) 2005-2008, The Android Open Source Project + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + diff --git a/hardware.c b/hardware.c new file mode 100644 index 00000000..86bce245 --- /dev/null +++ b/hardware.c @@ -0,0 +1,167 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include + +#include +#include +#include +#include +#include + +#define LOG_TAG "HAL" +#include + +/** Base path of the hal modules */ +#define HAL_LIBRARY_PATH "/system/lib/hw" + +/** + * There are a set of variant filename for modules. The form of the filename + * is ".variant.so" so for the led module the Dream variants + * of base "ro.product.board", "ro.board.platform" and "ro.arch" would be: + * + * led.trout.so + * led.msm7k.so + * led.ARMV6.so + * led.default.so + */ + +#define HAL_DEFAULT_VARIANT "default" +#define HAL_VARIANT_KEYS_COUNT 4 +static const char *variant_keys[HAL_VARIANT_KEYS_COUNT] = { + "ro.product.board", + "ro.board.platform", + "ro.arch", + HAL_DEFAULT_VARIANT +}; + +/** + * Load the file defined by the path and if succesfull + * return the dlopen handle and the hmi. + * @return 0 = success, !0 = failure. + */ +static int load(const char *id, + const char *path, + void **pHandle, + const struct hw_module_t **pHmi) +{ + int status; + void *handle; + const struct hw_module_t *hmi; + + LOGV("load: E id=%s path=%s", id, path); + + /* + * load the symbols resolving undefined symbols before + * dlopen returns. Since RTLD_GLOBAL is not or'd in with + * RTLD_NOW the external symbols will not be global + */ + handle = dlopen(path, RTLD_NOW); + if (handle == NULL) { + char const *err_str = dlerror(); + LOGW("load: module=%s error=%s", path, err_str); + status = -EINVAL; + goto done; + } + + /* Get the address of the struct hal_module_info. */ + const char *sym = HAL_MODULE_INFO_SYM_AS_STR; + hmi = (const struct hw_module_t *)dlsym(handle, sym); + if (hmi == NULL) { + char const *err_str = dlerror(); + LOGE("load: couldn't find symbol %s", sym); + status = -EINVAL; + goto done; + } + + /* Check that the id matches */ + if (strcmp(id, hmi->id) != 0) { + LOGE("load: id=%s != hmi->id=%s", id, hmi->id); + status = -EINVAL; + goto done; + } + + /* success */ + status = 0; + +done: + if (status != 0) { + hmi = NULL; + if (handle != NULL) { + dlclose(handle); + handle = NULL; + } + } + + *pHmi = hmi; + *pHandle = handle; + + LOGV("load: X id=%s path=%s hmi=%p pHandle=%p status=%d", + id, path, *pHmi, *pHandle, status); + return status; +} + +int hw_get_module(const char *id, const struct hw_module_t **module) +{ + int status; + const struct hw_module_t *hmi = NULL; + char path[PATH_MAX]; + char variant[PATH_MAX]; + void *handle = NULL; + int i; + + /* + * Here we rely on the fact that calling dlopen multiple times on + * the same .so will simply increment a refcount (and not load + * a new copy of the library). + * We also assume that dlopen() is thread-safe. + */ + + LOGV("hal_module_info_get: Load module id=%s", id); + + /* Loop through the configuration variants looking for a module */ + status = -EINVAL; + for (i = 0; (status != 0) && (i < HAL_VARIANT_KEYS_COUNT); i++) { + + /* Get variant or default */ + if (strcmp(variant_keys[i], HAL_DEFAULT_VARIANT) == 0) { + strncpy(variant, HAL_DEFAULT_VARIANT, sizeof(variant)-1); + variant[sizeof(variant)-1] = 0; + } else { + if (property_get(variant_keys[i], variant, NULL) == 0) { + continue; + } + } + + /* Construct the path then try to load */ + snprintf(path, sizeof(path), "%s/%s.%s.so", + HAL_LIBRARY_PATH, id, variant); + status = load(id, path, &handle, &hmi); + } + if (status != 0) { + hmi = NULL; + if (handle != NULL) { + dlclose(handle); + } + } + + *module = hmi; + LOGV("hal_module_info_get: X id=%s hmi=%p status=%d", id, hmi, status); + + return status; +} diff --git a/include/hardware/copybit.h b/include/hardware/copybit.h new file mode 100644 index 00000000..7774cd26 --- /dev/null +++ b/include/hardware/copybit.h @@ -0,0 +1,216 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_COPYBIT_INTERFACE_H +#define ANDROID_COPYBIT_INTERFACE_H + +#include + +#include +#include +#include + +__BEGIN_DECLS + +/** + * The id of this module + */ +#define COPYBIT_HARDWARE_MODULE_ID "copybit" + +/** + * Name of the graphics device to open + */ +#define COPYBIT_HARDWARE_COPYBIT0 "copybit0" + +/* supported pixel-formats. these must be compatible with + * graphics/PixelFormat.java, ui/PixelFormat.h, pixelflinger/format.h + */ +enum { + COPYBIT_FORMAT_RGBA_8888 = HAL_PIXEL_FORMAT_RGBA_8888, + COPYBIT_FORMAT_RGB_565 = HAL_PIXEL_FORMAT_RGB_565, + COPYBIT_FORMAT_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888, + COPYBIT_FORMAT_RGBA_5551 = HAL_PIXEL_FORMAT_RGBA_5551, + COPYBIT_FORMAT_RGBA_4444 = HAL_PIXEL_FORMAT_RGBA_4444, + COPYBIT_FORMAT_YCbCr_422_SP = HAL_PIXEL_FORMAT_YCbCr_422_SP, + COPYBIT_FORMAT_YCbCr_420_SP = HAL_PIXEL_FORMAT_YCbCr_420_SP, +}; + +/* name for copybit_set_parameter */ +enum { + /* rotation of the source image in degrees (0 to 359) */ + COPYBIT_ROTATION_DEG = 1, + /* plane alpha value */ + COPYBIT_PLANE_ALPHA = 2, + /* enable or disable dithering */ + COPYBIT_DITHER = 3, + /* transformation applied (this is a superset of COPYBIT_ROTATION_DEG) */ + COPYBIT_TRANSFORM = 4, +}; + +/* values for copybit_set_parameter(COPYBIT_TRANSFORM) */ +enum { + /* flip source image horizontally */ + COPYBIT_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H, + /* flip source image vertically */ + COPYBIT_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V, + /* rotate source image 90 degres */ + COPYBIT_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90, + /* rotate source image 180 degres */ + COPYBIT_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180, + /* rotate source image 270 degres */ + COPYBIT_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270, +}; + +/* enable/disable value copybit_set_parameter */ +enum { + COPYBIT_DISABLE = 0, + COPYBIT_ENABLE = 1 +}; + +/* use get_static_info() to query static informations about the hardware */ +enum { + /* Maximum amount of minification supported by the hardware*/ + COPYBIT_MINIFICATION_LIMIT = 1, + /* Maximum amount of magnification supported by the hardware */ + COPYBIT_MAGNIFICATION_LIMIT = 2, + /* Number of fractional bits support by the scaling engine */ + COPYBIT_SCALING_FRAC_BITS = 3, + /* Supported rotation step in degres. */ + COPYBIT_ROTATION_STEP_DEG = 4, +}; + +/* Image structure */ +struct copybit_image_t { + /* width */ + uint32_t w; + /* height */ + uint32_t h; + /* format COPYBIT_FORMAT_xxx */ + int32_t format; + /* offset from base to first pixel */ + uint32_t offset; + /* base of buffer with image */ + void *base; + /* file descriptor for image */ + int fd; +}; + +/* Rectangle */ +struct copybit_rect_t { + /* left */ + int l; + /* top */ + int t; + /* right */ + int r; + /* bottom */ + int b; +}; + +/* Region */ +struct copybit_region_t { + int (*next)(struct copybit_region_t const *region, struct copybit_rect_t *rect); +}; + +/** + * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM + * and the fields of this data structure must begin with hw_module_t + * followed by module specific information. + */ +struct copybit_module_t { + struct hw_module_t common; +}; + +/** + * Every device data structure must begin with hw_device_t + * followed by module specific public methods and attributes. + */ +struct copybit_device_t { + struct hw_device_t common; + + /** + * Set a copybit parameter. + * + * @param dev from open + * @param name one for the COPYBIT_NAME_xxx + * @param value one of the COPYBIT_VALUE_xxx + * + * @return 0 if successful + */ + int (*set_parameter)(struct copybit_device_t *dev, int name, int value); + + /** + * Get a static copybit information. + * + * @param dev from open + * @param name one of the COPYBIT_STATIC_xxx + * + * @return value or -EINVAL if error + */ + int (*get)(struct copybit_device_t *dev, int name); + + /** + * Execute the bit blit copy operation + * + * @param dev from open + * @param dst is the destination image + * @param src is the source image + * @param region the clip region + * + * @return 0 if successful + */ + int (*blit)(struct copybit_device_t *dev, + struct copybit_image_t const *dst, + struct copybit_image_t const *src, + struct copybit_region_t const *region); + + /** + * Execute the stretch bit blit copy operation + * + * @param dev from open + * @param dst is the destination image + * @param src is the source image + * @param dst_rect is the destination rectangle + * @param src_rect is the source rectangle + * @param region the clip region + * + * @return 0 if successful + */ + int (*stretch)(struct copybit_device_t *dev, + struct copybit_image_t const *dst, + struct copybit_image_t const *src, + struct copybit_rect_t const *dst_rect, + struct copybit_rect_t const *src_rect, + struct copybit_region_t const *region); +}; + + +/** convenience API for opening and closing a device */ + +static inline int copybit_open(const struct hw_module_t* module, + struct copybit_device_t** device) { + return module->methods->open(module, + COPYBIT_HARDWARE_COPYBIT0, (struct hw_device_t**)device); +} + +static inline int copybit_close(struct copybit_device_t* device) { + return device->common.close(&device->common); +} + + +__END_DECLS + +#endif // ANDROID_COPYBIT_INTERFACE_H diff --git a/include/hardware/hardware.h b/include/hardware/hardware.h new file mode 100644 index 00000000..53257442 --- /dev/null +++ b/include/hardware/hardware.h @@ -0,0 +1,148 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_INCLUDE_HARDWARE_HARDWARE_H +#define ANDROID_INCLUDE_HARDWARE_HARDWARE_H + +#include +#include + +__BEGIN_DECLS + +/* + * Value for the hw_module_t.tag field + */ +#define HARDWARE_MODULE_TAG 'HWMT' +#define HARDWARE_DEVICE_TAG 'HWDT' + +struct hw_module_t; +struct hw_module_methods_t; +struct hw_device_t; + +/** + * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM + * and the fields of this data structure must begin with hw_module_t + * followed by module specific information. + */ +struct hw_module_t { + /** tag must be initialized to HARDWARE_MODULE_TAG */ + uint32_t tag; + + /** major version number for the module */ + uint16_t version_major; + + /** minor version number of the module */ + uint16_t version_minor; + + /** Identifier of module */ + const char *id; + + /** Name of this module */ + const char *name; + + /** Author/owner/implementor of the module */ + const char *author; + + /** Modules methods */ + struct hw_module_methods_t* methods; + + /** padding to 128 bytes, reserved for future use */ + uint32_t reserved[32-6]; +}; + +struct hw_module_methods_t { + /** Open a specific device */ + int (*open)(const struct hw_module_t* module, const char* id, + struct hw_device_t** device); +}; + +/** + * Every device data structure must begin with hw_device_t + * followed by module specific public methods and attributes. + */ +struct hw_device_t { + /** tag must be initialized to HARDWARE_DEVICE_TAG */ + uint32_t tag; + + /** version number for hw_device_t */ + uint32_t version; + + /** reference to the module this device belongs to */ + struct hw_module_t* module; + + /** padding reserved for future use */ + uint32_t reserved[12]; + + /** Close this device */ + int (*close)(struct hw_device_t* device); +}; + +/** + * Name of the hal_module_info + */ +#define HAL_MODULE_INFO_SYM HMI + +/** + * Name of the hal_module_info as a string + */ +#define HAL_MODULE_INFO_SYM_AS_STR "HMI" + +/** + * Get the module info associated with a module by id. + * @return: 0 == success, <0 == error and *pHmi == NULL + */ +int hw_get_module(const char *id, const struct hw_module_t **module); + + +/** + * pixel format definitions + */ + +enum { + HAL_PIXEL_FORMAT_RGBA_8888 = 1, + HAL_PIXEL_FORMAT_RGB_565 = 4, + HAL_PIXEL_FORMAT_BGRA_8888 = 5, + HAL_PIXEL_FORMAT_RGBA_5551 = 6, + HAL_PIXEL_FORMAT_RGBA_4444 = 7, + HAL_PIXEL_FORMAT_YCbCr_422_SP = 0x10, + HAL_PIXEL_FORMAT_YCbCr_420_SP = 0x11, + HAL_PIXEL_FORMAT_YCbCr_422_P = 0x12, + HAL_PIXEL_FORMAT_YCbCr_420_P = 0x13, + HAL_PIXEL_FORMAT_YCbCr_422_I = 0x14, + HAL_PIXEL_FORMAT_YCbCr_420_I = 0x15 +}; + + +/** + * Transformation definitions + */ + +enum { + /* flip source image horizontally */ + HAL_TRANSFORM_FLIP_H = 0x01, + /* flip source image vertically */ + HAL_TRANSFORM_FLIP_V = 0x02, + /* rotate source image 90 degres */ + HAL_TRANSFORM_ROT_90 = 0x04, + /* rotate source image 180 degres */ + HAL_TRANSFORM_ROT_180 = 0x03, + /* rotate source image 270 degres */ + HAL_TRANSFORM_ROT_270 = 0x07, +}; + +__END_DECLS + +#endif /* ANDROID_INCLUDE_HARDWARE_HARDWARE_H */ diff --git a/include/hardware/overlay.h b/include/hardware/overlay.h new file mode 100644 index 00000000..92992d18 --- /dev/null +++ b/include/hardware/overlay.h @@ -0,0 +1,225 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_OVERLAY_INTERFACE_H +#define ANDROID_OVERLAY_INTERFACE_H + +#include + +#include + +#include +#include +#include + +__BEGIN_DECLS + +/** + * The id of this module + */ +#define OVERLAY_HARDWARE_MODULE_ID "overlay" + +/** + * Name of the overlay device to open + */ +#define OVERLAY_HARDWARE_CONTROL "control" +#define OVERLAY_HARDWARE_DATA "data" + +/*****************************************************************************/ + +/* possible overlay formats */ +enum { + OVERLAY_FORMAT_RGBA_8888 = HAL_PIXEL_FORMAT_RGBA_8888, + OVERLAY_FORMAT_RGB_565 = HAL_PIXEL_FORMAT_RGB_565, + OVERLAY_FORMAT_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888, + OVERLAY_FORMAT_YCbCr_422_I = HAL_PIXEL_FORMAT_YCbCr_422_I, + OVERLAY_FORMAT_YCbCr_420_I = HAL_PIXEL_FORMAT_YCbCr_420_I +}; + +/* values for copybit_set_parameter(OVERLAY_TRANSFORM) */ +enum { + /* flip source image horizontally */ + OVERLAY_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_V, + /* flip source image vertically */ + OVERLAY_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_H, + /* rotate source image 90 degrees */ + OVERLAY_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90, + /* rotate source image 180 degrees */ + OVERLAY_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180, + /* rotate source image 270 degrees */ + OVERLAY_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270 +}; + +/* names for setParameter() */ +enum { + /* rotation of the source image in degrees (0 to 359) */ + OVERLAY_ROTATION_DEG = 1, + /* enable or disable dithering */ + OVERLAY_DITHER = 3, + /* transformation applied (this is a superset of COPYBIT_ROTATION_DEG) */ + OVERLAY_TRANSFORM = 4, +}; + +/* enable/disable value setParameter() */ +enum { + OVERLAY_DISABLE = 0, + OVERLAY_ENABLE = 1 +}; + +/* names for get() */ +enum { + /* Maximum amount of minification supported by the hardware*/ + OVERLAY_MINIFICATION_LIMIT = 1, + /* Maximum amount of magnification supported by the hardware */ + OVERLAY_MAGNIFICATION_LIMIT = 2, + /* Number of fractional bits support by the overlay scaling engine */ + OVERLAY_SCALING_FRAC_BITS = 3, + /* Supported rotation step in degrees. */ + OVERLAY_ROTATION_STEP_DEG = 4, + /* horizontal alignment in pixels */ + OVERLAY_HORIZONTAL_ALIGNMENT = 5, + /* vertical alignment in pixels */ + OVERLAY_VERTICAL_ALIGNMENT = 6, + /* width alignment restrictions. negative number for max. power-of-two */ + OVERLAY_WIDTH_ALIGNMENT = 7, + /* height alignment restrictions. negative number for max. power-of-two */ + OVERLAY_HEIGHT_ALIGNMENT = 8, +}; + +/*****************************************************************************/ + +/* opaque reference to an Overlay kernel object */ +typedef const native_handle* overlay_handle_t; + +typedef struct overlay_t { + uint32_t w; + uint32_t h; + int32_t format; + uint32_t w_stride; + uint32_t h_stride; + uint32_t reserved[3]; + /* returns a reference to this overlay's handle (the caller doesn't + * take ownership) */ + overlay_handle_t (*getHandleRef)(struct overlay_t* overlay); + uint32_t reserved_procs[7]; +} overlay_t; + +typedef void* overlay_buffer_t; + +/*****************************************************************************/ + +/** + * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM + * and the fields of this data structure must begin with hw_module_t + * followed by module specific information. + */ +struct overlay_module_t { + struct hw_module_t common; +}; + +/*****************************************************************************/ + +/** + * Every device data structure must begin with hw_device_t + * followed by module specific public methods and attributes. + */ + +struct overlay_control_device_t { + struct hw_device_t common; + + /* get static informations about the capabilities of the overlay engine */ + int (*get)(struct overlay_control_device_t *dev, int name); + + /* creates an overlay matching the given parameters as closely as possible. + * returns an error if no more overlays are available. The actual + * size and format is returned in overlay_t. */ + overlay_t* (*createOverlay)(struct overlay_control_device_t *dev, + uint32_t w, uint32_t h, int32_t format); + + /* destroys an overlay. This call releases all + * resources associated with overlay_t and make it invalid */ + void (*destroyOverlay)(struct overlay_control_device_t *dev, + overlay_t* overlay); + + /* set position and scaling of the given overlay as closely as possible. + * if scaling cannot be performed, overlay must be centered. */ + int (*setPosition)(struct overlay_control_device_t *dev, + overlay_t* overlay, + int x, int y, uint32_t w, uint32_t h); + + /* returns the actual position and size of the overlay */ + int (*getPosition)(struct overlay_control_device_t *dev, + overlay_t* overlay, + int* x, int* y, uint32_t* w, uint32_t* h); + + /* sets configurable parameters for this overlay. returns an error if not + * supported. */ + int (*setParameter)(struct overlay_control_device_t *dev, + overlay_t* overlay, int param, int value); +}; + + +struct overlay_data_device_t { + struct hw_device_t common; + + /* initialize the overlay from the given handle. this associates this + * overlay data module to its control module */ + int (*initialize)(struct overlay_data_device_t *dev, + overlay_handle_t handle); + + /* blocks until an overlay buffer is available and return that buffer. */ + int (*dequeueBuffer)(struct overlay_data_device_t *dev, + overlay_buffer_t *buf); + + /* release the overlay buffer and post it */ + int (*queueBuffer)(struct overlay_data_device_t *dev, + overlay_buffer_t buffer); + + /* returns the address of a given buffer if supported, NULL otherwise. */ + void* (*getBufferAddress)(struct overlay_data_device_t *dev, + overlay_buffer_t buffer); + + int (*getBufferCount)(struct overlay_data_device_t *dev); +}; + + +/*****************************************************************************/ + +/** convenience API for opening and closing a device */ + +static inline int overlay_control_open(const struct hw_module_t* module, + struct overlay_control_device_t** device) { + return module->methods->open(module, + OVERLAY_HARDWARE_CONTROL, (struct hw_device_t**)device); +} + +static inline int overlay_control_close(struct overlay_control_device_t* device) { + return device->common.close(&device->common); +} + +static inline int overlay_data_open(const struct hw_module_t* module, + struct overlay_data_device_t** device) { + return module->methods->open(module, + OVERLAY_HARDWARE_DATA, (struct hw_device_t**)device); +} + +static inline int overlay_data_close(struct overlay_data_device_t* device) { + return device->common.close(&device->common); +} + +__END_DECLS + +#endif // ANDROID_OVERLAY_INTERFACE_H diff --git a/include/hardware/sensors.h b/include/hardware/sensors.h new file mode 100644 index 00000000..094b3eee --- /dev/null +++ b/include/hardware/sensors.h @@ -0,0 +1,375 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_SENSORS_INTERFACE_H +#define ANDROID_SENSORS_INTERFACE_H + +#include +#include +#include + +#include + +__BEGIN_DECLS + +/** + * The id of this module + */ +#define SENSORS_HARDWARE_MODULE_ID "sensors" + +/** + * Name of the sensors device to open + */ +#define SENSORS_HARDWARE_CONTROL "control" +#define SENSORS_HARDWARE_DATA "data" + +/** + * Handles must be higher than SENSORS_HANDLE_BASE and must be unique. + * A Handle identifies a given sensors. The handle is used to activate + * and/or deactivate sensors. + * In this version of the API there can only be 256 handles. + */ +#define SENSORS_HANDLE_BASE 0 +#define SENSORS_HANDLE_BITS 8 +#define SENSORS_HANDLE_COUNT (1<0 + * ^ + * | + * +-----------+--> y>0 + * | | + * | | + * | | + * | | / z<0 + * | | / + * | | / + * O-----------+/ + * |[] [ ] []/ + * +----------/+ y<0 + * / + * / + * |/ z>0 (toward the sky) + * + * O: Origin (x=0,y=0,z=0) + * + * + * Orientation + * ----------- + * + * All values are angles in degrees. + * + * azimuth: angle between the magnetic north direction and the Y axis, around + * the Z axis (0<=azimuth<360). + * 0=North, 90=East, 180=South, 270=West + * + * pitch: Rotation around X axis (-180<=pitch<=180), with positive values when + * the z-axis moves toward the y-axis. + * + * roll: Rotation around Y axis (-90<=roll<=90), with positive values when + * the z-axis moves AWAY from the x-axis. + * + * Note: This definition is different from yaw, pitch and roll used in aviation + * where the X axis is along the long side of the plane (tail to nose). + * + * + * Acceleration + * ------------ + * + * All values are in SI units (m/s^2) and measure the acceleration of the + * device minus the force of gravity. + * + * x: Acceleration minus Gx on the x-axis + * y: Acceleration minus Gy on the y-axis + * z: Acceleration minus Gz on the z-axis + * + * Examples: + * When the device lies flat on a table and is pushed on its left side + * toward the right, the x acceleration value is positive. + * + * When the device lies flat on a table, the acceleration value is +9.81, + * which correspond to the acceleration of the device (0 m/s^2) minus the + * force of gravity (-9.81 m/s^2). + * + * When the device lies flat on a table and is pushed toward the sky, the + * acceleration value is greater than +9.81, which correspond to the + * acceleration of the device (+A m/s^2) minus the force of + * gravity (-9.81 m/s^2). + * + * + * Magnetic Field + * -------------- + * + * All values are in micro-Tesla (uT) and measure the ambient magnetic + * field in the X, Y and Z axis. + * + */ +typedef struct { + union { + float v[3]; + struct { + float x; + float y; + float z; + }; + struct { + float azimuth; + float pitch; + float roll; + }; + }; + int8_t status; + uint8_t reserved[3]; +} sensors_vec_t; + +/** + * Union of the various types of sensor data + * that can be returned. + */ +typedef struct { + /* sensor identifier */ + int sensor; + + union { + /* x,y,z values of the given sensor */ + sensors_vec_t vector; + + /* orientation values are in degrees */ + sensors_vec_t orientation; + + /* acceleration values are in meter per second per second (m/s^2) */ + sensors_vec_t acceleration; + + /* magnetic vector values are in micro-Tesla (uT) */ + sensors_vec_t magnetic; + + /* temperature is in degrees centigrade (Celsius) */ + float temperature; + }; + + /* time is in nanosecond */ + int64_t time; + + uint32_t reserved; +} sensors_data_t; + + +struct sensor_t; + +/** + * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM + * and the fields of this data structure must begin with hw_module_t + * followed by module specific information. + */ +struct sensors_module_t { + struct hw_module_t common; + + /** + * Enumerate all available sensors. The list is returned in "list". + * @return number of sensors in the list + */ + int (*get_sensors_list)(struct sensors_module_t* module, + struct sensor_t const** list); +}; + +struct sensor_t { + /* name of this sensors */ + const char* name; + /* vendor of the hardware part */ + const char* vendor; + /* version of the hardware part + driver. The value of this field is + * left to the implementation and doesn't have to be monotonicaly + * increasing. + */ + int version; + /* handle that identifies this sensors. This handle is used to activate + * and deactivate this sensor. The value of the handle must be 8 bits + * in this version of the API. + */ + int handle; + /* this sensor's type. */ + int type; + /* maximaum range of this sensor's value in SI units */ + float maxRange; + /* smallest difference between two values reported by this sensor */ + float resolution; + /* rough estimate of this sensor's power consumption in mA */ + float power; + /* reserved fields, must be zero */ + void* reserved[9]; +}; + + +/** + * Every device data structure must begin with hw_device_t + * followed by module specific public methods and attributes. + */ +struct sensors_control_device_t { + struct hw_device_t common; + + /** + * Returns the fd which will be the parameter to + * sensors_data_device_t::open_data(). + * The caller takes ownership of this fd. This is intended to be + * passed cross processes. + * + * @return a fd if successful, < 0 on error + */ + int (*open_data_source)(struct sensors_control_device_t *dev); + + /** Activate/deactivate one sensor. + * + * @param handle is the handle of the sensor to change. + * @param enabled set to 1 to enable, or 0 to disable the sensor. + * + * @return 0 on success, negative errno code otherwise + */ + int (*activate)(struct sensors_control_device_t *dev, + int handle, int enabled); + + /** + * Set the delay between sensor events in ms + * + * @return 0 if successful, < 0 on error + */ + int (*set_delay)(struct sensors_control_device_t *dev, int32_t ms); + + /** + * Causes sensors_data_device_t.poll() to return -EWOULDBLOCK immediately. + */ + int (*wake)(struct sensors_control_device_t *dev); +}; + +struct sensors_data_device_t { + struct hw_device_t common; + + /** + * Prepare to read sensor data. + * + * This routine does NOT take ownership of the fd + * and must not close it. Typically this routine would + * use a duplicate of the fd parameter. + * + * @param fd from sensors_control_open. + * + * @return 0 if successful, < 0 on error + */ + int (*data_open)(struct sensors_data_device_t *dev, int fd); + + /** + * Caller has completed using the sensor data. + * The caller will not be blocked in sensors_data_poll + * when this routine is called. + * + * @return 0 if successful, < 0 on error + */ + int (*data_close)(struct sensors_data_device_t *dev); + + /** + * Return sensor data for one of the enabled sensors. + * + * @return sensor handle for the returned data, 0x7FFFFFFF when + * sensors_control_device_t.wake() is called and -errno on error + * + */ + int (*poll)(struct sensors_data_device_t *dev, + sensors_data_t* data); +}; + + +/** convenience API for opening and closing a device */ + +static inline int sensors_control_open(const struct hw_module_t* module, + struct sensors_control_device_t** device) { + return module->methods->open(module, + SENSORS_HARDWARE_CONTROL, (struct hw_device_t**)device); +} + +static inline int sensors_control_close(struct sensors_control_device_t* device) { + return device->common.close(&device->common); +} + +static inline int sensors_data_open(const struct hw_module_t* module, + struct sensors_data_device_t** device) { + return module->methods->open(module, + SENSORS_HARDWARE_DATA, (struct hw_device_t**)device); +} + +static inline int sensors_data_close(struct sensors_data_device_t* device) { + return device->common.close(&device->common); +} + + +__END_DECLS + +#endif // ANDROID_SENSORS_INTERFACE_H diff --git a/modules/README.android b/modules/README.android new file mode 100644 index 00000000..57abb726 --- /dev/null +++ b/modules/README.android @@ -0,0 +1,23 @@ +Default (and possibly architecture dependents) HAL modules go here. + + +libhardware.so eventually should contain *just* the HAL hub +(hardware.c), everything in it should be rewritten as modules. + +Modules are .so in /system/libs/hw/ and have a well defined naming +convention: + + /system/libs/hw/<*_HARDWARE_MODULE_ID>..so + /system/libs/hw/<*_HARDWARE_MODULE_ID>..so + /system/libs/hw/<*_HARDWARE_MODULE_ID>..so + /system/libs/hw/<*_HARDWARE_MODULE_ID>.default.so + +They also have a well defined interface which lives in include/hardware/. + +A module can have several variants: "default", "arch" and "board", and they're +loaded in the "board", "arch" and "default" order. +The source code for the "board" variant, usually lives under partners/... + +The source code for "default" and "arch" would usually +live under hardware/modules/. + diff --git a/modules/overlay/Android.mk b/modules/overlay/Android.mk new file mode 100644 index 00000000..44b55af3 --- /dev/null +++ b/modules/overlay/Android.mk @@ -0,0 +1,26 @@ +# Copyright (C) 2008 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +LOCAL_PATH := $(call my-dir) + +# HAL module implemenation, not prelinked and stored in +# hw/..so +include $(CLEAR_VARS) +LOCAL_PRELINK_MODULE := false +LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw +LOCAL_SHARED_LIBRARIES := liblog +LOCAL_SRC_FILES := overlay.cpp +LOCAL_MODULE := overlay.trout +include $(BUILD_SHARED_LIBRARY) diff --git a/modules/overlay/README.android b/modules/overlay/README.android new file mode 100644 index 00000000..971d619d --- /dev/null +++ b/modules/overlay/README.android @@ -0,0 +1,3 @@ + +Skeleton for the "overlay" HAL module. + diff --git a/modules/overlay/overlay.cpp b/modules/overlay/overlay.cpp new file mode 100644 index 00000000..0246b5bb --- /dev/null +++ b/modules/overlay/overlay.cpp @@ -0,0 +1,321 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "Overlay" + +#include +#include + +#include +#include + +#include +#include + +/*****************************************************************************/ + +struct overlay_control_context_t { + struct overlay_control_device_t device; + /* our private state goes below here */ +}; + +struct overlay_data_context_t { + struct overlay_data_device_t device; + /* our private state goes below here */ +}; + +static int overlay_device_open(const struct hw_module_t* module, const char* name, + struct hw_device_t** device); + +static struct hw_module_methods_t overlay_module_methods = { + open: overlay_device_open +}; + +const struct overlay_module_t HAL_MODULE_INFO_SYM = { + common: { + tag: HARDWARE_MODULE_TAG, + version_major: 1, + version_minor: 0, + id: OVERLAY_HARDWARE_MODULE_ID, + name: "Sample Overlay module", + author: "The Android Open Source Project", + methods: &overlay_module_methods, + } +}; + +/*****************************************************************************/ + +/* + * This is the overlay_t object, it is returned to the user and represents + * an overlay. + * This handles will be passed across processes and possibly given to other + * HAL modules (for instance video decode modules). + */ + +class overlay_object : public overlay_t { + + struct handle_t : public native_handle { + /* add the data fields we need here, for instance: */ + int width; + int height; + }; + + handle_t mHandle; + + static overlay_handle_t getHandleRef(struct overlay_t* overlay) { + /* returns a reference to the handle, caller doesn't take ownership */ + return &(static_cast(overlay)->mHandle); + } + +public: + overlay_object() { + this->overlay_t::getHandleRef = getHandleRef; + mHandle.version = sizeof(native_handle); + mHandle.numFds = 0; + mHandle.numInts = 2; // extra ints we have in our handle + } +}; + +// **************************************************************************** +// Control module +// **************************************************************************** + +static int overlay_get(struct overlay_control_device_t *dev, int name) { + int result = -1; + switch (name) { + case OVERLAY_MINIFICATION_LIMIT: + result = 0; // 0 = no limit + break; + case OVERLAY_MAGNIFICATION_LIMIT: + result = 0; // 0 = no limit + break; + case OVERLAY_SCALING_FRAC_BITS: + result = 0; // 0 = infinite + break; + case OVERLAY_ROTATION_STEP_DEG: + result = 90; // 90 rotation steps (for instance) + break; + case OVERLAY_HORIZONTAL_ALIGNMENT: + result = 1; // 1-pixel alignment + break; + case OVERLAY_VERTICAL_ALIGNMENT: + result = 1; // 1-pixel alignment + break; + case OVERLAY_WIDTH_ALIGNMENT: + result = 1; // 1-pixel alignment + break; + case OVERLAY_HEIGHT_ALIGNMENT: + result = 1; // 1-pixel alignment + break; + } + return result; +} + +static overlay_t* overlay_createOverlay(struct overlay_control_device_t *dev, + uint32_t w, uint32_t h, int32_t format) +{ + /* check the input params, reject if not supported or invalid */ + switch (format) { + case OVERLAY_FORMAT_RGBA_8888: + case OVERLAY_FORMAT_RGB_565: + case OVERLAY_FORMAT_BGRA_8888: + case OVERLAY_FORMAT_YCbCr_422_SP: + case OVERLAY_FORMAT_YCbCr_420_SP: + case OVERLAY_FORMAT_YCbCr_422_I: + case OVERLAY_FORMAT_YCbCr_420_I: + break; + default: + return NULL; + } + + /* Create overlay object. Talk to the h/w here and adjust to what it can + * do. the overlay_t returned can be a C++ object, subclassing overlay_t + * if needed. + * + * we probably want to keep a list of the overlay_t created so they can + * all be cleaned up in overlay_close(). + */ + return new overlay_object( /* pass needed params here*/ ); +} + +static void overlay_destroyOverlay(struct overlay_control_device_t *dev, + overlay_t* overlay) +{ + /* free resources associated with this overlay_t */ + delete overlay; +} + +static int overlay_setPosition(struct overlay_control_device_t *dev, + overlay_t* overlay, + int x, int y, uint32_t w, uint32_t h) { + /* set this overlay's position (talk to the h/w) */ + return -EINVAL; +} + +static int overlay_getPosition(struct overlay_control_device_t *dev, + overlay_t* overlay, + int* x, int* y, uint32_t* w, uint32_t* h) { + /* get this overlay's position */ + return -EINVAL; +} + +static int overlay_setParameter(struct overlay_control_device_t *dev, + overlay_t* overlay, int param, int value) { + + int result = 0; + /* set this overlay's parameter (talk to the h/w) */ + switch (param) { + case OVERLAY_ROTATION_DEG: + /* if only 90 rotations are supported, the call fails + * for other values */ + break; + case OVERLAY_DITHER: + break; + case OVERLAY_TRANSFORM: + // see OVERLAY_TRANSFORM_* + break; + default: + result = -EINVAL; + break; + } + return result; +} + +static int overlay_control_close(struct hw_device_t *dev) +{ + struct overlay_control_context_t* ctx = (struct overlay_control_context_t*)dev; + if (ctx) { + /* free all resources associated with this device here + * in particular the overlay_handle_t, outstanding overlay_t, etc... + */ + free(ctx); + } + return 0; +} + +// **************************************************************************** +// Data module +// **************************************************************************** + +int overlay_initialize(struct overlay_data_device_t *dev, + overlay_handle_t handle) +{ + /* + * overlay_handle_t should contain all the information to "inflate" this + * overlay. Typically it'll have a file descriptor, informations about + * how many buffers are there, etc... + * It is also the place to mmap all buffers associated with this overlay + * (see getBufferAddress). + * + * NOTE: this function doesn't take ownership of overlay_handle_t + * + */ + + return -EINVAL; +} + +int overlay_dequeueBuffer(struct overlay_data_device_t *dev, + overlay_buffer_t* buf) +{ + /* blocks until a buffer is available and return an opaque structure + * representing this buffer. + */ + return -EINVAL; +} + +int overlay_queueBuffer(struct overlay_data_device_t *dev, + overlay_buffer_t buffer) +{ + /* Mark this buffer for posting and recycle or free overlay_buffer_t. */ + return -EINVAL; +} + +void *overlay_getBufferAddress(struct overlay_data_device_t *dev, + overlay_buffer_t buffer) +{ + /* this may fail (NULL) if this feature is not supported. In that case, + * presumably, there is some other HAL module that can fill the buffer, + * using a DSP for instance */ + return NULL; +} + +static int overlay_data_close(struct hw_device_t *dev) +{ + struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; + if (ctx) { + /* free all resources associated with this device here + * in particular all pending overlay_buffer_t if needed. + * + * NOTE: overlay_handle_t passed in initialize() is NOT freed and + * its file descriptors are not closed (this is the responsibility + * of the caller). + */ + free(ctx); + } + return 0; +} + +/*****************************************************************************/ + +static int overlay_device_open(const struct hw_module_t* module, const char* name, + struct hw_device_t** device) +{ + int status = -EINVAL; + if (!strcmp(name, OVERLAY_HARDWARE_CONTROL)) { + struct overlay_control_context_t *dev; + dev = (overlay_control_context_t*)malloc(sizeof(*dev)); + + /* initialize our state here */ + memset(dev, 0, sizeof(*dev)); + + /* initialize the procs */ + dev->device.common.tag = HARDWARE_DEVICE_TAG; + dev->device.common.version = 0; + dev->device.common.module = const_cast(module); + dev->device.common.close = overlay_control_close; + + dev->device.get = overlay_get; + dev->device.createOverlay = overlay_createOverlay; + dev->device.destroyOverlay = overlay_destroyOverlay; + dev->device.setPosition = overlay_setPosition; + dev->device.getPosition = overlay_getPosition; + dev->device.setParameter = overlay_setParameter; + + *device = &dev->device.common; + status = 0; + } else if (!strcmp(name, OVERLAY_HARDWARE_DATA)) { + struct overlay_data_context_t *dev; + dev = (overlay_data_context_t*)malloc(sizeof(*dev)); + + /* initialize our state here */ + memset(dev, 0, sizeof(*dev)); + + /* initialize the procs */ + dev->device.common.tag = HARDWARE_DEVICE_TAG; + dev->device.common.version = 0; + dev->device.common.module = const_cast(module); + dev->device.common.close = overlay_data_close; + + dev->device.initialize = overlay_initialize; + dev->device.dequeueBuffer = overlay_dequeueBuffer; + dev->device.queueBuffer = overlay_queueBuffer; + dev->device.getBufferAddress = overlay_getBufferAddress; + + *device = &dev->device.common; + status = 0; + } + return status; +}