AetherDroid/android_device_samsung_universal7570-common
1
0
Fork 0
mirror of https://github.com/AetherDroid/android_device_samsung_universal7570-common.git synced 2025-09-06 00:17:47 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Initial common device tree

Browse source
This commit is contained in:
Astrako 2019-11-17 18:53:04 +01:00
commit 765503ce5e
71 changed files with 22665 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

157
include/hardware/audio_amplifier.h Normal file
View file

@ -0,0 +1,157 @@
/*
* Copyright (C) 2015, The CyanogenMod 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 CM_AUDIO_AMPLIFIER_INTERFACE_H
#define CM_AUDIO_AMPLIFIER_INTERFACE_H
#include <stdint.h>
#include <sys/cdefs.h>
#include <sys/types.h>
#include <hardware/audio.h>
#include <hardware/hardware.h>
#include <system/audio.h>
__BEGIN_DECLS
#define AMPLIFIER_HARDWARE_MODULE_ID "audio_amplifier"
#define AMPLIFIER_HARDWARE_INTERFACE "audio_amplifier_hw_if"
#define AMPLIFIER_MODULE_API_VERSION_0_1 HARDWARE_MODULE_API_VERSION(0, 1)
#define AMPLIFIER_DEVICE_API_VERSION_1_0 HARDWARE_DEVICE_API_VERSION(1, 0)
#define AMPLIFIER_DEVICE_API_VERSION_2_0 HARDWARE_DEVICE_API_VERSION(2, 0)
#define AMPLIFIER_DEVICE_API_VERSION_2_1 HARDWARE_DEVICE_API_VERSION(2, 1)
#define AMPLIFIER_DEVICE_API_VERSION_CURRENT AMPLIFIER_DEVICE_API_VERSION_2_1
struct str_parms;
typedef struct amplifier_device {
/**
* Common methods of the amplifier device. This *must* be the first member
* of amplifier_device as users of this structure will cast a hw_device_t
* to amplifier_device pointer in contexts where it's known
* the hw_device_t references a amplifier_device.
*/
struct hw_device_t common;
/**
* Notify amplifier device of current input devices
*
* This function should handle only input devices.
*/
int (*set_input_devices)(struct amplifier_device *device, uint32_t devices);
/**
* Notify amplifier device of current output devices
*
* This function should handle only output devices.
*/
int (*set_output_devices)(struct amplifier_device *device, uint32_t devices);
/**
* Notify amplifier device of output device enable/disable
*
* This function should handle only output devices.
*/
int (*enable_output_devices)(struct amplifier_device *device,
uint32_t devices, bool enable);
/**
* Notify amplifier device of input device enable/disable
*
* This function should handle only input devices.
*/
int (*enable_input_devices)(struct amplifier_device *device,
uint32_t devices, bool enable);
/**
* Notify amplifier device about current audio mode
*/
int (*set_mode)(struct amplifier_device *device, audio_mode_t mode);
/**
* Notify amplifier device that an output stream has started
*/
int (*output_stream_start)(struct amplifier_device *device,
struct audio_stream_out *stream, bool offload);
/**
* Notify amplifier device that an input stream has started
*/
int (*input_stream_start)(struct amplifier_device *device,
struct audio_stream_in *stream);
/**
* Notify amplifier device that an output stream has stopped
*/
int (*output_stream_standby)(struct amplifier_device *device,
struct audio_stream_out *stream);
/**
* Notify amplifier device that an input stream has stopped
*/
int (*input_stream_standby)(struct amplifier_device *device,
struct audio_stream_in *stream);
/**
* set/get audio device parameters.
*/
int (*set_parameters)(struct amplifier_device *device,
struct str_parms *parms);
/**
* set/get output stream parameters.
*/
int (*out_set_parameters)(struct amplifier_device *device,
struct str_parms *parms);
/**
* set/get input stream parameters.
*/
int (*in_set_parameters)(struct amplifier_device *device,
struct str_parms *parms);
} amplifier_device_t;
typedef struct amplifier_module {
/**
* Common methods of the amplifier module. This *must* be the first member
* of amplifier_module as users of this structure will cast a hw_module_t
* to amplifier_module pointer in contexts where it's known
* the hw_module_t references a amplifier_module.
*/
struct hw_module_t common;
} amplifier_module_t;
/** convenience API for opening and closing a supported device */
static inline int amplifier_device_open(const struct hw_module_t *module,
struct amplifier_device **device)
{
return module->methods->open(module, AMPLIFIER_HARDWARE_INTERFACE,
(struct hw_device_t **) device);
}
static inline int amplifier_device_close(struct amplifier_device *device)
{
return device->common.close(&device->common);
}
__END_DECLS
#endif // CM_AUDIO_AMPLIFIER_INTERFACE_H

275
include/hardware/gnss-base.h Normal file
View file

@ -0,0 +1,275 @@
// This file is autogenerated by hidl-gen. Do not edit manually.
// Source: android.hardware.gnss@1.0
// Root: android.hardware:hardware/interfaces
#ifndef HIDL_GENERATED_ANDROID_HARDWARE_GNSS_V1_0_EXPORTED_CONSTANTS_H_
#define HIDL_GENERATED_ANDROID_HARDWARE_GNSS_V1_0_EXPORTED_CONSTANTS_H_
#ifdef __cplusplus
extern "C" {
#endif
enum {
GNSS_MAX_SVS_COUNT = 64u, // 64
};
enum {
GNSS_CONSTELLATION_UNKNOWN = 0,
GNSS_CONSTELLATION_GPS = 1,
GNSS_CONSTELLATION_SBAS = 2,
GNSS_CONSTELLATION_GLONASS = 3,
GNSS_CONSTELLATION_QZSS = 4,
GNSS_CONSTELLATION_BEIDOU = 5,
GNSS_CONSTELLATION_GALILEO = 6,
};
enum {
GPS_LOCATION_HAS_LAT_LONG = 1, // 0x0001
GPS_LOCATION_HAS_ALTITUDE = 2, // 0x0002
GPS_LOCATION_HAS_SPEED = 4, // 0x0004
GPS_LOCATION_HAS_BEARING = 8, // 0x0008
GPS_LOCATION_HAS_HORIZONTAL_ACCURACY = 16, // 0x0010
GPS_LOCATION_HAS_VERTICAL_ACCURACY = 32, // 0x0020
GPS_LOCATION_HAS_SPEED_ACCURACY = 64, // 0x0040
GPS_LOCATION_HAS_BEARING_ACCURACY = 128, // 0x0080
};
enum {
APN_IP_INVALID = 0,
APN_IP_IPV4 = 1,
APN_IP_IPV6 = 2,
APN_IP_IPV4V6 = 3,
};
enum {
AGPS_TYPE_SUPL = 1,
AGPS_TYPE_C2K = 2,
};
enum {
GNSS_REQUEST_AGNSS_DATA_CONN = 1,
GNSS_RELEASE_AGNSS_DATA_CONN = 2,
GNSS_AGNSS_DATA_CONNECTED = 3,
GNSS_AGNSS_DATA_CONN_DONE = 4,
GNSS_AGNSS_DATA_CONN_FAILED = 5,
};
enum {
AGPS_SETID_TYPE_NONE = 0,
AGPS_SETID_TYPE_IMSI = 1,
AGPS_SETID_TYPE_MSISDM = 2,
};
enum {
AGPS_RIL_NETWORK_TYPE_MOBILE = 0,
AGPS_RIL_NETWORK_TYPE_WIFI = 1,
AGPS_RIL_NETWORK_TYPE_MMS = 2,
AGPS_RIL_NETWORK_TYPE_SUPL = 3,
AGPS_RIL_NETWORK_TYPE_DUN = 4,
AGPS_RIL_NETWORK_TYPE_HIPRI = 5,
AGPS_RIL_NETWORK_TYPE_WIMAX = 6,
};
enum {
AGPS_REF_LOCATION_TYPE_GSM_CELLID = 1,
AGPS_REF_LOCATION_TYPE_UMTS_CELLID = 2,
AGPS_REF_LOCATION_TYPE_LTE_CELLID = 4,
};
enum {
AGPS_RIL_REQUEST_SETID_IMSI = 1u, // (1 << 0L)
AGPS_RIL_REQUEST_SETID_MSISDN = 2u, // (1 << 1L)
};
enum {
GPS_POSITION_MODE_STANDALONE = 0,
GPS_POSITION_MODE_MS_BASED = 1,
GPS_POSITION_MODE_MS_ASSISTED = 2,
};
enum {
GPS_POSITION_RECURRENCE_PERIODIC = 0u, // 0
GPS_POSITION_RECURRENCE_SINGLE = 1u, // 1
};
enum {
GPS_DELETE_EPHEMERIS = 1, // 0x0001
GPS_DELETE_ALMANAC = 2, // 0x0002
GPS_DELETE_POSITION = 4, // 0x0004
GPS_DELETE_TIME = 8, // 0x0008
GPS_DELETE_IONO = 16, // 0x0010
GPS_DELETE_UTC = 32, // 0x0020
GPS_DELETE_HEALTH = 64, // 0x0040
GPS_DELETE_SVDIR = 128, // 0x0080
GPS_DELETE_SVSTEER = 256, // 0x0100
GPS_DELETE_SADATA = 512, // 0x0200
GPS_DELETE_RTI = 1024, // 0x0400
GPS_DELETE_CELLDB_INFO = 32768, // 0x8000
GPS_DELETE_ALL = 65535, // 0xFFFF
};
enum {
FLP_BATCH_WAKEUP_ON_FIFO_FULL = 1, // 0x01
};
enum {
GPS_CAPABILITY_SCHEDULING = 1u, // (1 << 0)
GPS_CAPABILITY_MSB = 2u, // (1 << 1)
GPS_CAPABILITY_MSA = 4u, // (1 << 2)
GPS_CAPABILITY_SINGLE_SHOT = 8u, // (1 << 3)
GPS_CAPABILITY_ON_DEMAND_TIME = 16u, // (1 << 4)
GPS_CAPABILITY_GEOFENCING = 32u, // (1 << 5)
GPS_CAPABILITY_MEASUREMENTS = 64u, // (1 << 6)
GPS_CAPABILITY_NAV_MESSAGES = 128u, // (1 << 7)
};
enum {
GPS_STATUS_NONE = 0,
GPS_STATUS_SESSION_BEGIN = 1,
GPS_STATUS_SESSION_END = 2,
GPS_STATUS_ENGINE_ON = 3,
GPS_STATUS_ENGINE_OFF = 4,
};
enum {
GNSS_SV_FLAGS_NONE = 0,
GNSS_SV_FLAGS_HAS_EPHEMERIS_DATA = 1, // (1 << 0)
GNSS_SV_FLAGS_HAS_ALMANAC_DATA = 2, // (1 << 1)
GNSS_SV_FLAGS_USED_IN_FIX = 4, // (1 << 2)
GNSS_SV_FLAGS_HAS_CARRIER_FREQUENCY = 8, // (1 << 3)
};
enum {
GPS_GEOFENCE_ENTERED = 1, // (1 << 0L)
GPS_GEOFENCE_EXITED = 2, // (1 << 1L)
GPS_GEOFENCE_UNCERTAIN = 4, // (1 << 2L)
};
enum {
GPS_GEOFENCE_UNAVAILABLE = 1, // (1 << 0L)
GPS_GEOFENCE_AVAILABLE = 2, // (1 << 1L)
};
enum {
GPS_GEOFENCE_OPERATION_SUCCESS = 0,
GPS_GEOFENCE_ERROR_TOO_MANY_GEOFENCES = -100, // (-100)
GPS_GEOFENCE_ERROR_ID_EXISTS = -101, // (-101)
GPS_GEOFENCE_ERROR_ID_UNKNOWN = -102, // (-102)
GPS_GEOFENCE_ERROR_INVALID_TRANSITION = -103, // (-103)
GPS_GEOFENCE_ERROR_GENERIC = -149, // (-149)
};
enum {
GPS_MEASUREMENT_SUCCESS = 0,
GPS_MEASUREMENT_ERROR_ALREADY_INIT = -100, // (-100)
GPS_MEASUREMENT_ERROR_GENERIC = -101, // (-101)
};
enum {
GNSS_CLOCK_HAS_LEAP_SECOND = 1, // (1 << 0)
GNSS_CLOCK_HAS_TIME_UNCERTAINTY = 2, // (1 << 1)
GNSS_CLOCK_HAS_FULL_BIAS = 4, // (1 << 2)
GNSS_CLOCK_HAS_BIAS = 8, // (1 << 3)
GNSS_CLOCK_HAS_BIAS_UNCERTAINTY = 16, // (1 << 4)
GNSS_CLOCK_HAS_DRIFT = 32, // (1 << 5)
GNSS_CLOCK_HAS_DRIFT_UNCERTAINTY = 64, // (1 << 6)
};
enum {
GNSS_MEASUREMENT_HAS_SNR = 1u, // (1 << 0)
GNSS_MEASUREMENT_HAS_CARRIER_FREQUENCY = 512u, // (1 << 9)
GNSS_MEASUREMENT_HAS_CARRIER_CYCLES = 1024u, // (1 << 10)
GNSS_MEASUREMENT_HAS_CARRIER_PHASE = 2048u, // (1 << 11)
GNSS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY = 4096u, // (1 << 12)
GNSS_MEASUREMENT_HAS_AUTOMATIC_GAIN_CONTROL = 8192u, // (1 << 13)
};
enum {
GNSS_MULTIPATH_INDICATOR_UNKNOWN = 0,
GNSS_MULTIPATH_INDICATOR_PRESENT = 1,
GNSS_MULTIPATH_INDICATIOR_NOT_PRESENT = 2,
};
enum {
GNSS_MEASUREMENT_STATE_UNKNOWN = 0u, // 0
GNSS_MEASUREMENT_STATE_CODE_LOCK = 1u, // (1 << 0)
GNSS_MEASUREMENT_STATE_BIT_SYNC = 2u, // (1 << 1)
GNSS_MEASUREMENT_STATE_SUBFRAME_SYNC = 4u, // (1 << 2)
GNSS_MEASUREMENT_STATE_TOW_DECODED = 8u, // (1 << 3)
GNSS_MEASUREMENT_STATE_MSEC_AMBIGUOUS = 16u, // (1 << 4)
GNSS_MEASUREMENT_STATE_SYMBOL_SYNC = 32u, // (1 << 5)
GNSS_MEASUREMENT_STATE_GLO_STRING_SYNC = 64u, // (1 << 6)
GNSS_MEASUREMENT_STATE_GLO_TOD_DECODED = 128u, // (1 << 7)
GNSS_MEASUREMENT_STATE_BDS_D2_BIT_SYNC = 256u, // (1 << 8)
GNSS_MEASUREMENT_STATE_BDS_D2_SUBFRAME_SYNC = 512u, // (1 << 9)
GNSS_MEASUREMENT_STATE_GAL_E1BC_CODE_LOCK = 1024u, // (1 << 10)
GNSS_MEASUREMENT_STATE_GAL_E1C_2ND_CODE_LOCK = 2048u, // (1 << 11)
GNSS_MEASUREMENT_STATE_GAL_E1B_PAGE_SYNC = 4096u, // (1 << 12)
GNSS_MEASUREMENT_STATE_SBAS_SYNC = 8192u, // (1 << 13)
GNSS_MEASUREMENT_STATE_TOW_KNOWN = 16384u, // (1 << 14)
GNSS_MEASUREMENT_STATE_GLO_TOD_KNOWN = 32768u, // (1 << 15)
};
enum {
GNSS_ADR_STATE_UNKNOWN = 0,
GNSS_ADR_STATE_VALID = 1, // (1 << 0)
GNSS_ADR_STATE_RESET = 2, // (1 << 1)
GNSS_ADR_STATE_CYCLE_SLIP = 4, // (1 << 2)
};
enum {
GPS_NAVIGATION_MESSAGE_SUCCESS = 0,
GPS_NAVIGATION_MESSAGE_ERROR_ALREADY_INIT = -100, // (-100)
GPS_NAVIGATION_MESSAGE_ERROR_GENERIC = -101, // (-101)
};
enum {
GNSS_NAVIGATION_MESSAGE_TYPE_UNKNOWN = 0,
GNSS_NAVIGATION_MESSAGE_TYPE_GNSS_L1CA = 257, // 0x0101
GNSS_NAVIGATION_MESSAGE_TYPE_GNSS_L2CNAV = 258, // 0x0102
GNSS_NAVIGATION_MESSAGE_TYPE_GNSS_L5CNAV = 259, // 0x0103
GNSS_NAVIGATION_MESSAGE_TYPE_GNSS_CNAV2 = 260, // 0x0104
GNSS_NAVIGATION_MESSAGE_TYPE_GLO_L1CA = 769, // 0x0301
GNSS_NAVIGATION_MESSAGE_TYPE_BDS_D1 = 1281, // 0x0501
GNSS_NAVIGATION_MESSAGE_TYPE_BDS_D2 = 1282, // 0x0502
GNSS_NAVIGATION_MESSAGE_TYPE_GAL_I = 1537, // 0x0601
GNSS_NAVIGATION_MESSAGE_TYPE_GAL_F = 1538, // 0x0602
};
typedef enum {
NAV_MESSAGE_STATUS_PARITY_PASSED = 1, // (1 << 0)
NAV_MESSAGE_STATUS_PARITY_REBUILT = 2, // (1 << 1)
NAV_MESSAGE_STATUS_UNKNOWN = 0,
} navigation_message_status;
enum {
GPS_NI_TYPE_VOICE = 1,
GPS_NI_TYPE_UMTS_SUPL = 2,
GPS_NI_TYPE_UMTS_CTRL_PLANE = 3,
};
enum {
GPS_NI_NEED_NOTIFY = 1u, // 0x0001
GPS_NI_NEED_VERIFY = 2u, // 0x0002
GPS_NI_PRIVACY_OVERRIDE = 4u, // 0x0004
};
enum {
GPS_NI_RESPONSE_ACCEPT = 1,
GPS_NI_RESPONSE_DENY = 2,
GPS_NI_RESPONSE_NORESP = 3,
};
enum {
GPS_ENC_NONE = 0,
GPS_ENC_SUPL_GSM_DEFAULT = 1,
GPS_ENC_SUPL_UTF8 = 2,
GPS_ENC_SUPL_UCS2 = 3,
GPS_ENC_UNKNOWN = -1, // (-1)
};
#ifdef __cplusplus
}
#endif
#endif // HIDL_GENERATED_ANDROID_HARDWARE_GNSS_V1_0_EXPORTED_CONSTANTS_H_

2006
include/hardware/gps.h Normal file
View file

File diff suppressed because it is too large Load diff

437
include/hardware/gralloc.h Normal file
View file

@ -0,0 +1,437 @@
/*
* 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_GRALLOC_INTERFACE_H
#define ANDROID_GRALLOC_INTERFACE_H
#include <system/graphics.h>
#include <hardware/hardware.h>
#include <stdint.h>
#include <sys/cdefs.h>
#include <sys/types.h>
#include <cutils/native_handle.h>
#include <hardware/hardware.h>
#include <hardware/fb.h>
__BEGIN_DECLS
/**
* Module versioning information for the Gralloc hardware module, based on
* gralloc_module_t.common.module_api_version.
*
* Version History:
*
* GRALLOC_MODULE_API_VERSION_0_1:
* Initial Gralloc hardware module API.
*
* GRALLOC_MODULE_API_VERSION_0_2:
* Add support for flexible YCbCr format with (*lock_ycbcr)() method.
*
* GRALLOC_MODULE_API_VERSION_0_3:
* Add support for fence passing to/from lock/unlock.
*/
#define GRALLOC_MODULE_API_VERSION_0_1 HARDWARE_MODULE_API_VERSION(0, 1)
#define GRALLOC_MODULE_API_VERSION_0_2 HARDWARE_MODULE_API_VERSION(0, 2)
#define GRALLOC_MODULE_API_VERSION_0_3 HARDWARE_MODULE_API_VERSION(0, 3)
#define GRALLOC_DEVICE_API_VERSION_0_1 HARDWARE_DEVICE_API_VERSION(0, 1)
/**
* The id of this module
*/
#define GRALLOC_HARDWARE_MODULE_ID "gralloc"
/**
* Name of the graphics device to open
*/
#define GRALLOC_HARDWARE_GPU0 "gpu0"
enum {
/* buffer is never read in software */
GRALLOC_USAGE_SW_READ_NEVER = 0x00000000U,
/* buffer is rarely read in software */
GRALLOC_USAGE_SW_READ_RARELY = 0x00000002U,
/* buffer is often read in software */
GRALLOC_USAGE_SW_READ_OFTEN = 0x00000003U,
/* added for VR single buffer only */
#ifdef USES_VR_FRONT_BUFFER
GRALLOC_USAGE_VR_SINGLE_BUFFER_USAGE= 0x00000004U,
#endif
/* mask for the software read values */
GRALLOC_USAGE_SW_READ_MASK = 0x0000000FU,
/* buffer is never written in software */
GRALLOC_USAGE_SW_WRITE_NEVER = 0x00000000U,
/* buffer is rarely written in software */
GRALLOC_USAGE_SW_WRITE_RARELY = 0x00000020U,
/* buffer is often written in software */
GRALLOC_USAGE_SW_WRITE_OFTEN = 0x00000030U,
/* mask for the software write values */
GRALLOC_USAGE_SW_WRITE_MASK = 0x000000F0U,
/* buffer will be used as an OpenGL ES texture */
GRALLOC_USAGE_HW_TEXTURE = 0x00000100U,
/* buffer will be used as an OpenGL ES render target */
GRALLOC_USAGE_HW_RENDER = 0x00000200U,
/* buffer will be used by the 2D hardware blitter */
GRALLOC_USAGE_HW_2D = 0x00000400U,
/* buffer will be used by the HWComposer HAL module */
GRALLOC_USAGE_HW_COMPOSER = 0x00000800U,
/* buffer will be used with the framebuffer device */
GRALLOC_USAGE_HW_FB = 0x00001000U,
/* buffer should be displayed full-screen on an external display when
* possible */
GRALLOC_USAGE_EXTERNAL_DISP = 0x00002000U,
/* Must have a hardware-protected path to external display sink for
* this buffer. If a hardware-protected path is not available, then
* either don't composite only this buffer (preferred) to the
* external sink, or (less desirable) do not route the entire
* composition to the external sink. */
GRALLOC_USAGE_PROTECTED = 0x00004000U,
/* buffer may be used as a cursor */
GRALLOC_USAGE_CURSOR = 0x00008000U,
/* buffer will be used with the HW video encoder */
GRALLOC_USAGE_HW_VIDEO_ENCODER = 0x00010000U,
/* buffer will be written by the HW camera pipeline */
GRALLOC_USAGE_HW_CAMERA_WRITE = 0x00020000U,
/* buffer will be read by the HW camera pipeline */
GRALLOC_USAGE_HW_CAMERA_READ = 0x00040000U,
/* buffer will be used as part of zero-shutter-lag queue */
GRALLOC_USAGE_HW_CAMERA_ZSL = 0x00060000U,
/* mask for the camera access values */
GRALLOC_USAGE_HW_CAMERA_MASK = 0x00060000U,
/* mask for the software usage bit-mask */
GRALLOC_USAGE_HW_MASK = 0x00071F00U,
/* buffer will be used as a RenderScript Allocation */
GRALLOC_USAGE_RENDERSCRIPT = 0x00100000U,
/* Set by the consumer to indicate to the producer that they may attach a
* buffer that they did not detach from the BufferQueue. Will be filtered
* out by GRALLOC_USAGE_ALLOC_MASK, so gralloc modules will not need to
* handle this flag. */
GRALLOC_USAGE_FOREIGN_BUFFERS = 0x00200000U,
/* Mask of all flags which could be passed to a gralloc module for buffer
* allocation. Any flags not in this mask do not need to be handled by
* gralloc modules. */
GRALLOC_USAGE_ALLOC_MASK = ~(GRALLOC_USAGE_FOREIGN_BUFFERS),
/* implementation-specific private usage flags */
GRALLOC_USAGE_PRIVATE_0 = 0x10000000U,
GRALLOC_USAGE_PRIVATE_1 = 0x20000000U,
GRALLOC_USAGE_PRIVATE_2 = 0x40000000U,
GRALLOC_USAGE_PRIVATE_3 = 0x80000000U,
GRALLOC_USAGE_PRIVATE_MASK = 0xF0000000U,
GRALLOC_USAGE_INTERNAL_ONLY = 0x10000000U,
GRALLOC_USAGE_EXTERNAL_FLEXIBLE = 0x20000000U,
GRALLOC_USAGE_EXTERNAL_BLOCK = 0x40000000U,
GRALLOC_USAGE_EXTERNAL_ONLY = 0x80000000U,
GRALLOC_USAGE_EXTERNAL_VIRTUALFB = 0x00400000U,
GRALLOC_USAGE_PROTECTED_DPB = 0x00800000U,
/* buffer will be used by the HW IPs when sysmmu is off */
GRALLOC_USAGE_PHYSICALLY_LINEAR = 0x01000000U,
GRALLOC_USAGE_PRIVATE_NONSECURE = 0x02000000U,
GRALLOC_USAGE_CAMERA_RESERVED = 0x04000000U,
GRALLOC_USAGE_NOZEROED = 0x08000000U,
GRALLOC_USAGE_VIDEO_EXT = 0x10000000U,
GRALLOC_USAGE_GPU_BUFFER = 0x00800000U,
};
/*****************************************************************************/
/**
* 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.
*/
typedef struct gralloc_module_t {
struct hw_module_t common;
/*
* (*registerBuffer)() must be called before a buffer_handle_t that has not
* been created with (*alloc_device_t::alloc)() can be used.
*
* This is intended to be used with buffer_handle_t's that have been
* received in this process through IPC.
*
* This function checks that the handle is indeed a valid one and prepares
* it for use with (*lock)() and (*unlock)().
*
* It is not necessary to call (*registerBuffer)() on a handle created
* with (*alloc_device_t::alloc)().
*
* returns an error if this buffer_handle_t is not valid.
*/
int (*registerBuffer)(struct gralloc_module_t const* module,
buffer_handle_t handle);
/*
* (*unregisterBuffer)() is called once this handle is no longer needed in
* this process. After this call, it is an error to call (*lock)(),
* (*unlock)(), or (*registerBuffer)().
*
* This function doesn't close or free the handle itself; this is done
* by other means, usually through libcutils's native_handle_close() and
* native_handle_free().
*
* It is an error to call (*unregisterBuffer)() on a buffer that wasn't
* explicitly registered first.
*/
int (*unregisterBuffer)(struct gralloc_module_t const* module,
buffer_handle_t handle);
/*
* The (*lock)() method is called before a buffer is accessed for the
* specified usage. This call may block, for instance if the h/w needs
* to finish rendering or if CPU caches need to be synchronized.
*
* The caller promises to modify only pixels in the area specified
* by (l,t,w,h).
*
* The content of the buffer outside of the specified area is NOT modified
* by this call.
*
* If usage specifies GRALLOC_USAGE_SW_*, vaddr is filled with the address
* of the buffer in virtual memory.
*
* Note calling (*lock)() on HAL_PIXEL_FORMAT_YCbCr_*_888 buffers will fail
* and return -EINVAL. These buffers must be locked with (*lock_ycbcr)()
* instead.
*
* THREADING CONSIDERATIONS:
*
* It is legal for several different threads to lock a buffer from
* read access, none of the threads are blocked.
*
* However, locking a buffer simultaneously for write or read/write is
* undefined, but:
* - shall not result in termination of the process
* - shall not block the caller
* It is acceptable to return an error or to leave the buffer's content
* into an indeterminate state.
*
* If the buffer was created with a usage mask incompatible with the
* requested usage flags here, -EINVAL is returned.
*
*/
int (*lock)(struct gralloc_module_t const* module,
buffer_handle_t handle, int usage,
int l, int t, int w, int h,
void** vaddr);
/*
* The (*unlock)() method must be called after all changes to the buffer
* are completed.
*/
int (*unlock)(struct gralloc_module_t const* module,
buffer_handle_t handle);
/* reserved for future use */
int (*perform)(struct gralloc_module_t const* module,
int operation, ... );
/*
* The (*lock_ycbcr)() method is like the (*lock)() method, with the
* difference that it fills a struct ycbcr with a description of the buffer
* layout, and zeroes out the reserved fields.
*
* If the buffer format is not compatible with a flexible YUV format (e.g.
* the buffer layout cannot be represented with the ycbcr struct), it
* will return -EINVAL.
*
* This method must work on buffers with HAL_PIXEL_FORMAT_YCbCr_*_888
* if supported by the device, as well as with any other format that is
* requested by the multimedia codecs when they are configured with a
* flexible-YUV-compatible color-format with android native buffers.
*
* Note that this method may also be called on buffers of other formats,
* including non-YUV formats.
*
* Added in GRALLOC_MODULE_API_VERSION_0_2.
*/
int (*lock_ycbcr)(struct gralloc_module_t const* module,
buffer_handle_t handle, int usage,
int l, int t, int w, int h,
struct android_ycbcr *ycbcr);
/*
* The (*lockAsync)() method is like the (*lock)() method except
* that the buffer's sync fence object is passed into the lock
* call instead of requiring the caller to wait for completion.
*
* The gralloc implementation takes ownership of the fenceFd and
* is responsible for closing it when no longer needed.
*
* Added in GRALLOC_MODULE_API_VERSION_0_3.
*/
int (*lockAsync)(struct gralloc_module_t const* module,
buffer_handle_t handle, int usage,
int l, int t, int w, int h,
void** vaddr, int fenceFd);
/*
* The (*unlockAsync)() method is like the (*unlock)() method
* except that a buffer sync fence object is returned from the
* lock call, representing the completion of any pending work
* performed by the gralloc implementation.
*
* The caller takes ownership of the fenceFd and is responsible
* for closing it when no longer needed.
*
* Added in GRALLOC_MODULE_API_VERSION_0_3.
*/
int (*unlockAsync)(struct gralloc_module_t const* module,
buffer_handle_t handle, int* fenceFd);
/*
* The (*lockAsync_ycbcr)() method is like the (*lock_ycbcr)()
* method except that the buffer's sync fence object is passed
* into the lock call instead of requiring the caller to wait for
* completion.
*
* The gralloc implementation takes ownership of the fenceFd and
* is responsible for closing it when no longer needed.
*
* Added in GRALLOC_MODULE_API_VERSION_0_3.
*/
int (*lockAsync_ycbcr)(struct gralloc_module_t const* module,
buffer_handle_t handle, int usage,
int l, int t, int w, int h,
struct android_ycbcr *ycbcr, int fenceFd);
/* reserved for future use */
void* reserved_proc[3];
} gralloc_module_t;
/*****************************************************************************/
/**
* Every device data structure must begin with hw_device_t
* followed by module specific public methods and attributes.
*/
typedef struct alloc_device_t {
struct hw_device_t common;
/*
* (*alloc)() Allocates a buffer in graphic memory with the requested
* parameters and returns a buffer_handle_t and the stride in pixels to
* allow the implementation to satisfy hardware constraints on the width
* of a pixmap (eg: it may have to be multiple of 8 pixels).
* The CALLER TAKES OWNERSHIP of the buffer_handle_t.
*
* If format is HAL_PIXEL_FORMAT_YCbCr_420_888, the returned stride must be
* 0, since the actual strides are available from the android_ycbcr
* structure.
*
* Returns 0 on success or -errno on error.
*/
int (*alloc)(struct alloc_device_t* dev,
int w, int h, int format, int usage,
buffer_handle_t* handle, int* stride);
/*
* (*free)() Frees a previously allocated buffer.
* Behavior is undefined if the buffer is still mapped in any process,
* but shall not result in termination of the program or security breaches
* (allowing a process to get access to another process' buffers).
* THIS FUNCTION TAKES OWNERSHIP of the buffer_handle_t which becomes
* invalid after the call.
*
* Returns 0 on success or -errno on error.
*/
int (*free)(struct alloc_device_t* dev,
buffer_handle_t handle);
/* This hook is OPTIONAL.
*
* If non NULL it will be caused by SurfaceFlinger on dumpsys
*/
void (*dump)(struct alloc_device_t *dev, char *buff, int buff_len);
void* reserved_proc[7];
} alloc_device_t;
/** convenience API for opening and closing a supported device */
static inline int gralloc_open(const struct hw_module_t* module,
struct alloc_device_t** device) {
return module->methods->open(module,
#ifdef __cplusplus
GRALLOC_HARDWARE_GPU0, reinterpret_cast<struct hw_device_t**>(device));
#else
GRALLOC_HARDWARE_GPU0, TO_HW_DEVICE_T_OPEN(device));
#endif
}
static inline int gralloc_close(struct alloc_device_t* device) {
return device->common.close(&device->common);
}
/**
* map_usage_to_memtrack should be called after allocating a gralloc buffer.
*
* @param usage - it is the flag used when alloc function is called.
*
* This function maps the gralloc usage flags to appropriate memtrack bucket.
* GrallocHAL implementers and users should make an additional ION_IOCTL_TAG
* call using the memtrack tag returned by this function. This will help the
* in-kernel memtack to categorize the memory allocated by different processes
* according to their usage.
*
*/
static inline const char* map_usage_to_memtrack(uint32_t usage) {
usage &= GRALLOC_USAGE_ALLOC_MASK;
if ((usage & GRALLOC_USAGE_HW_CAMERA_WRITE) != 0) {
return "camera";
} else if ((usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) != 0 ||
(usage & GRALLOC_USAGE_EXTERNAL_DISP) != 0) {
return "video";
} else if ((usage & GRALLOC_USAGE_HW_RENDER) != 0 ||
(usage & GRALLOC_USAGE_HW_TEXTURE) != 0) {
return "gl";
} else if ((usage & GRALLOC_USAGE_HW_CAMERA_READ) != 0) {
return "camera";
} else if ((usage & GRALLOC_USAGE_SW_READ_MASK) != 0 ||
(usage & GRALLOC_USAGE_SW_WRITE_MASK) != 0) {
return "cpu";
}
return "graphics";
}
__END_DECLS
#endif // ANDROID_GRALLOC_INTERFACE_H