LineageOS/android_hardware_libhardware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

remove deprecated/unused HAL headers

Browse Source 
copybit, overlay, sensors_deprecated are no longer supported.

Change-Id: Ie5da20bd4ff95f7565a162d628bf572a76327b7b
This commit is contained in:
Mathias Agopian
2011-04-28 20:00:54 -07:00
parent 53b8af5e9c
commit 03dd9c671d
5 changed files with 0 additions and 541 deletions
Download Patch File Download Diff File Expand all files Collapse all files

219
include/hardware/copybit.h
View File

@@ -1,219 +0,0 @@
/*
* 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_RGBX_8888 = HAL_PIXEL_FORMAT_RGBX_8888,
COPYBIT_FORMAT_RGB_888 = HAL_PIXEL_FORMAT_RGB_888,
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 = 0x10,
COPYBIT_FORMAT_YCrCb_420_SP = 0x11,
};
/* 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,
/* blurs the copied bitmap. The amount of blurring cannot be changed
* at this time. */
COPYBIT_BLUR = 5
};
/* 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;
/* base of buffer with image */
void *base;
/* handle to the image */
native_handle_t* handle;
};
/* 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

243
include/hardware/overlay.h
View File

@@ -1,243 +0,0 @@
/*
* 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_YCbYCr_422_I = 0x14,
OVERLAY_FORMAT_CbYCrY_422_I = 0x16,
OVERLAY_FORMAT_DEFAULT = 99 // The actual color format is determined
// by the overlay
};
/* values for copybit_set_parameter(OVERLAY_TRANSFORM) */
enum {
/* flip source image horizontally */
OVERLAY_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H,
/* flip source image vertically */
OVERLAY_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V,
/* 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);
int (*stage)(struct overlay_control_device_t *dev, overlay_t* overlay);
int (*commit)(struct overlay_control_device_t *dev, overlay_t* overlay);
};
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);
/* can be called to change the width and height of the overlay. */
int (*resizeInput)(struct overlay_data_device_t *dev,
uint32_t w, uint32_t h);
int (*setCrop)(struct overlay_data_device_t *dev,
uint32_t x, uint32_t y, uint32_t w, uint32_t h) ;
int (*getCrop)(struct overlay_data_device_t *dev,
uint32_t* x, uint32_t* y, uint32_t* w, uint32_t* h) ;
int (*setParameter)(struct overlay_data_device_t *dev,
int param, int value);
/* 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

2
include/hardware/sensors.h
View File

@@ -459,6 +459,4 @@ static inline int sensors_close(struct sensors_poll_device_t* device) {
__END_DECLS __END_DECLS
#include <hardware/sensors_deprecated.h>
#endif // ANDROID_SENSORS_INTERFACE_H #endif // ANDROID_SENSORS_INTERFACE_H

76
include/hardware/sensors_deprecated.h
View File

@@ -1,76 +0,0 @@
/*
* 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 SENSORS_HARDWARE_CONTROL "control"
#define SENSORS_HARDWARE_DATA "data"
__BEGIN_DECLS
typedef struct {
int sensor;
union {
sensors_vec_t vector;
sensors_vec_t orientation;
sensors_vec_t acceleration;
sensors_vec_t magnetic;
float temperature;
float distance;
float light;
float pressure;
};
int64_t time;
uint32_t reserved;
} sensors_data_t;
struct sensors_control_device_t {
struct hw_device_t common;
native_handle_t* (*open_data_source)(struct sensors_control_device_t *dev);
int (*close_data_source)(struct sensors_control_device_t *dev);
int (*activate)(struct sensors_control_device_t *dev,
int handle, int enabled);
int (*set_delay)(struct sensors_control_device_t *dev, int32_t ms);
int (*wake)(struct sensors_control_device_t *dev);
};
struct sensors_data_device_t {
struct hw_device_t common;
int (*data_open)(struct sensors_data_device_t *dev, native_handle_t* nh);
int (*data_close)(struct sensors_data_device_t *dev);
int (*poll)(struct sensors_data_device_t *dev,
sensors_data_t* data);
};
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

1
modules/hwcomposer/hwcomposer.cpp
View File

@@ -15,7 +15,6 @@
*/ */
#include <hardware/hardware.h> #include <hardware/hardware.h>
#include <hardware/overlay.h>
#include <fcntl.h> #include <fcntl.h>
#include <errno.h> #include <errno.h>