tequilaOS/platform_hardware_libhardware
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

auto import from //depot/cupcake/@135843

Browse source
This commit is contained in:
The Android Open Source Project 2009-03-03 19:32:14 -08:00
parent d51f49a11d
commit f53ebec387
12 changed files with 1729 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
Android.mk Normal file
View file

@ -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)

0
MODULE_LICENSE_APACHE2 Normal file
View file

190
NOTICE Normal file
View file

@ -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

167
hardware.c Normal file
View file

@ -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 <hardware/hardware.h>
#include <cutils/properties.h>
#include <dlfcn.h>
#include <string.h>
#include <pthread.h>
#include <errno.h>
#include <limits.h>
#define LOG_TAG "HAL"
#include <utils/Log.h>
/** 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 "<MODULE_ID>.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;
}

216
include/hardware/copybit.h Normal file
View file

@ -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 <hardware/hardware.h>
#include <stdint.h>
#include <sys/cdefs.h>
#include <sys/types.h>
__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

148
include/hardware/hardware.h Normal file
View file

@ -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 <stdint.h>
#include <sys/cdefs.h>
__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 */

225
include/hardware/overlay.h Normal file
View file

@ -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 <cutils/native_handle.h>
#include <hardware/hardware.h>
#include <stdint.h>
#include <sys/cdefs.h>
#include <sys/types.h>
__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

375
include/hardware/sensors.h Normal file
View file

@ -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 <stdint.h>
#include <sys/cdefs.h>
#include <sys/types.h>
#include <hardware/hardware.h>
__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<<SENSORS_HANDLE_BITS)
/**
* Sensor types
*/
#define SENSOR_TYPE_ACCELEROMETER 1
#define SENSOR_TYPE_MAGNETIC_FIELD 2
#define SENSOR_TYPE_ORIENTATION 3
#define SENSOR_TYPE_GYROSCOPE 4
#define SENSOR_TYPE_LIGHT 5
#define SENSOR_TYPE_PRESSURE 6
#define SENSOR_TYPE_TEMPERATURE 7
#define SENSOR_TYPE_PROXIMITY 8
/**
* Values returned by the accelerometer in various locations in the universe.
* all values are in SI units (m/s^2)
*/
#define GRAVITY_SUN (275.0f)
#define GRAVITY_MERCURY (3.70f)
#define GRAVITY_VENUS (8.87f)
#define GRAVITY_EARTH (9.80665f)
#define GRAVITY_MOON (1.6f)
#define GRAVITY_MARS (3.71f)
#define GRAVITY_JUPITER (23.12f)
#define GRAVITY_SATURN (8.96f)
#define GRAVITY_URANUS (8.69f)
#define GRAVITY_NEPTUNE (11.0f)
#define GRAVITY_PLUTO (0.6f)
#define GRAVITY_DEATH_STAR_I (0.000000353036145f)
#define GRAVITY_THE_ISLAND (4.815162342f)
/** Maximum magnetic field on Earth's surface */
#define MAGNETIC_FIELD_EARTH_MAX (60.0f)
/** Minimum magnetic field on Earth's surface */
#define MAGNETIC_FIELD_EARTH_MIN (30.0f)
/**
* status of each sensor
*/
#define SENSOR_STATUS_UNRELIABLE 0
#define SENSOR_STATUS_ACCURACY_LOW 1
#define SENSOR_STATUS_ACCURACY_MEDIUM 2
#define SENSOR_STATUS_ACCURACY_HIGH 3
/**
* Definition of the axis
* ----------------------
*
* This API is relative to the screen of the device in its default orientation,
* that is, if the device can be used in portrait or landscape, this API
* is only relative to the NATURAL orientation of the screen. In other words,
* the axis are not swapped when the device's screen orientation changes.
* Higher level services /may/ perform this transformation.
*
* x<0 x>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

23
modules/README.android Normal file
View file

@ -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>.<ro.product.board>.so
/system/libs/hw/<*_HARDWARE_MODULE_ID>.<ro.board.platform>.so
/system/libs/hw/<*_HARDWARE_MODULE_ID>.<ro.arch>.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/.

26
modules/overlay/Android.mk Normal file
View file

@ -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/<OVERLAY_HARDWARE_MODULE_ID>.<ro.product.board>.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)

3
modules/overlay/README.android Normal file
View file

@ -0,0 +1,3 @@
Skeleton for the "overlay" HAL module.

321
modules/overlay/overlay.cpp Normal file
View file

@ -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 <hardware/hardware.h>
#include <hardware/overlay.h>
#include <fcntl.h>
#include <errno.h>
#include <cutils/log.h>
#include <cutils/atomic.h>
/*****************************************************************************/
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_object *>(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<hw_module_t*>(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<hw_module_t*>(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;
}