| /* | |
| * Copyright (C) 2013 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 _LIBADF_ADF_H_ | |
| #define _LIBADF_ADF_H_ | |
| #include <stdint.h> | |
| #include <stdbool.h> | |
| #include <sys/cdefs.h> | |
| #include <sys/types.h> | |
| #include <video/adf.h> | |
| typedef __u32 adf_id_t; | |
| struct adf_device { | |
| adf_id_t id; | |
| int fd; | |
| }; | |
| __BEGIN_DECLS | |
| /** | |
| * Enumerates all ADF devices. | |
| * | |
| * Returns the number of ADF devices, and sets ids to a list of device IDs. | |
| * The caller must free() the returned list of device IDs. | |
| * | |
| * On error, returns -errno. | |
| */ | |
| ssize_t adf_devices(adf_id_t **ids); | |
| /** | |
| * Opens an ADF device. | |
| * | |
| * On error, returns -errno. | |
| */ | |
| int adf_device_open(adf_id_t id, int flags, struct adf_device *dev); | |
| /** | |
| * Closes an ADF device. | |
| */ | |
| void adf_device_close(struct adf_device *dev); | |
| /** | |
| * Reads the ADF device data. | |
| * | |
| * adf_get_device_data() allocates buffers inside data, which the caller | |
| * must free by calling adf_free_device_data(). On error, returns -errno. | |
| */ | |
| int adf_get_device_data(struct adf_device *dev, struct adf_device_data *data); | |
| /** | |
| * Frees the device data returned by adf_get_device_data(). | |
| */ | |
| void adf_free_device_data(struct adf_device_data *data); | |
| /** | |
| * Atomically posts a new display configuration to the specified interfaces. | |
| * | |
| * Returns a sync fence fd that will fire when the configuration is removed | |
| * from the screen. On error, returns -errno. | |
| */ | |
| int adf_device_post(struct adf_device *dev, | |
| adf_id_t *interfaces, size_t n_interfaces, | |
| struct adf_buffer_config *bufs, size_t n_bufs, | |
| void *custom_data, size_t custom_data_size); | |
| /** | |
| * Atomically posts a new display configuration to the specified interfaces. | |
| * | |
| * Compared to adf_device_post(), adf_device_post_v2(): | |
| * | |
| * (*) allows the client to choose the kind of sync fence returned | |
| * (through complete_fence_type) | |
| * | |
| * (*) stores the returned sync fence fd in a provided buffer, so the client | |
| * can distinguish between a permission error (ret = -1) and a successful | |
| * call that returns no fence (*complete_fence = -1) | |
| * | |
| * On error, returns -errno. | |
| * | |
| * On devices without the corresponding kernel support, returns -ENOTTY. | |
| */ | |
| int adf_device_post_v2(struct adf_device *dev, | |
| adf_id_t *interfaces, __u32 n_interfaces, | |
| struct adf_buffer_config *bufs, __u32 n_bufs, | |
| void *custom_data, __u64 custom_data_size, | |
| enum adf_complete_fence_type complete_fence_type, | |
| int *complete_fence); | |
| /** | |
| * Attaches the specified interface and overlay engine. | |
| */ | |
| int adf_device_attach(struct adf_device *dev, adf_id_t overlay_engine, | |
| adf_id_t interface); | |
| /** | |
| * Detaches the specified interface and overlay engine. | |
| */ | |
| int adf_device_detach(struct adf_device *dev, adf_id_t overlay_engine, | |
| adf_id_t interface); | |
| /** | |
| * Enumerates all interfaces belonging to an ADF device. | |
| * | |
| * The caller must free() the returned list of interface IDs. | |
| */ | |
| ssize_t adf_interfaces(struct adf_device *dev, adf_id_t **interfaces); | |
| /** | |
| * Enumerates all interfaces which can be attached to the specified overlay | |
| * engine. | |
| * | |
| * The caller must free() the returned list of interface IDs. | |
| */ | |
| ssize_t adf_interfaces_for_overlay_engine(struct adf_device *dev, | |
| adf_id_t overlay_engine, adf_id_t **interfaces); | |
| /** | |
| * Filters a list of interfaces by type. | |
| * | |
| * Returns the number of matching interfaces, and sets out to a list of matching | |
| * interface IDs. The caller must free() the returned list of interface IDs. | |
| * | |
| * On error, returns -errno. | |
| */ | |
| ssize_t adf_interfaces_filter_by_type(struct adf_device *dev, | |
| enum adf_interface_type type, | |
| adf_id_t *in, size_t n_in, adf_id_t **out); | |
| /** | |
| * Filters a list of interfaces by flag. | |
| * | |
| * The caller must free() the returned list of interface IDs. | |
| */ | |
| ssize_t adf_interfaces_filter_by_flag(struct adf_device *dev, __u32 flag, | |
| adf_id_t *in, size_t n_in, adf_id_t **out); | |
| /** | |
| * Opens an ADF interface. | |
| * | |
| * Returns a file descriptor. The caller must close() the fd when done. | |
| * On error, returns -errno. | |
| */ | |
| int adf_interface_open(struct adf_device *dev, adf_id_t id, int flags); | |
| /** | |
| * Reads the interface data. | |
| * | |
| * adf_get_interface_data() allocates buffers inside data, which the caller | |
| * must free by calling adf_free_interface_data(). On error, returns -errno. | |
| */ | |
| int adf_get_interface_data(int fd, struct adf_interface_data *data); | |
| /** | |
| * Frees the interface data returned by adf_get_interface_data(). | |
| */ | |
| void adf_free_interface_data(struct adf_interface_data *data); | |
| /** | |
| * Sets the interface's DPMS mode. | |
| */ | |
| int adf_interface_blank(int fd, __u8 mode); | |
| /** | |
| * Sets the interface's display mode. | |
| */ | |
| int adf_interface_set_mode(int fd, struct drm_mode_modeinfo *mode); | |
| /** | |
| * Allocates a single-plane RGB buffer of the specified size and format. | |
| * | |
| * Returns a dma-buf fd. On error, returns -errno. | |
| */ | |
| int adf_interface_simple_buffer_alloc(int fd, __u32 w, __u32 h, | |
| __u32 format, __u32 *offset, __u32 *pitch); | |
| /** | |
| * Posts a single-plane RGB buffer to the display using the specified | |
| * overlay engine. | |
| * | |
| * Returns a sync fence fd that will fire when the buffer is removed | |
| * from the screen. On error, returns -errno. | |
| */ | |
| int adf_interface_simple_post(int fd, adf_id_t overlay_engine, | |
| __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset, | |
| __u32 pitch, int acquire_fence); | |
| /** | |
| * Posts a single-plane RGB buffer to the display using the specified | |
| * overlay engine. | |
| * | |
| * Compared to adf_interface_simple_post(), adf_interface_simple_post_v2(): | |
| * | |
| * (*) allows the client to choose the kind of sync fence returned | |
| * (through complete_fence_type) | |
| * | |
| * (*) stores the returned sync fence fd in a provided buffer, so the client | |
| * can distinguish between a permission error (ret = -1) and a successful | |
| * call that returns no fence (*complete_fence = -1) | |
| * | |
| * On error, returns -errno. | |
| * | |
| * On devices without the corresponding kernel support, returns -ENOTTY. | |
| */ | |
| int adf_interface_simple_post_v2(int fd, adf_id_t overlay_engine, | |
| __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset, | |
| __u32 pitch, int acquire_fence, | |
| enum adf_complete_fence_type complete_fence_type, | |
| int *complete_fence); | |
| /** | |
| * Enumerates all overlay engines belonging to an ADF device. | |
| * | |
| * The caller must free() the returned list of overlay engine IDs. | |
| */ | |
| ssize_t adf_overlay_engines(struct adf_device *dev, adf_id_t **overlay_engines); | |
| /** | |
| * Enumerates all overlay engines which can be attached to the specified | |
| * interface. | |
| * | |
| * The caller must free() the returned list of overlay engine IDs. | |
| */ | |
| ssize_t adf_overlay_engines_for_interface(struct adf_device *dev, | |
| adf_id_t interface, adf_id_t **overlay_engines); | |
| /** | |
| * Filters a list of overlay engines by supported buffer format. | |
| * | |
| * Returns the overlay engines which support at least one of the specified | |
| * formats. The caller must free() the returned list of overlay engine IDs. | |
| */ | |
| ssize_t adf_overlay_engines_filter_by_format(struct adf_device *dev, | |
| const __u32 *formats, size_t n_formats, adf_id_t *in, size_t n_in, | |
| adf_id_t **out); | |
| /** | |
| * Opens an ADF overlay engine. | |
| * | |
| * Returns a file descriptor. The caller must close() the fd when done. | |
| * On error, returns -errno. | |
| */ | |
| int adf_overlay_engine_open(struct adf_device *dev, adf_id_t id, int flags); | |
| /** | |
| * Reads the overlay engine data. | |
| * | |
| * adf_get_overlay_engine_data() allocates buffers inside data, which the caller | |
| * must free by calling adf_free_overlay_engine_data(). On error, returns | |
| * -errno. | |
| */ | |
| int adf_get_overlay_engine_data(int fd, struct adf_overlay_engine_data *data); | |
| /** | |
| * Frees the overlay engine data returned by adf_get_overlay_engine_data(). | |
| */ | |
| void adf_free_overlay_engine_data(struct adf_overlay_engine_data *data); | |
| /** | |
| * Returns whether the overlay engine supports the specified format. | |
| */ | |
| bool adf_overlay_engine_supports_format(int fd, __u32 format); | |
| /** | |
| * Subscribes or unsubscribes from the specified hardware event. | |
| */ | |
| int adf_set_event(int fd, enum adf_event_type type, bool enabled); | |
| /** | |
| * Reads one event from the fd, blocking if needed. | |
| * | |
| * The caller must free() the returned buffer. On error, returns -errno. | |
| */ | |
| int adf_read_event(int fd, struct adf_event **event); | |
| #define ADF_FORMAT_STR_SIZE 5 | |
| /** | |
| * Converts an ADF/DRM fourcc format to its string representation. | |
| */ | |
| void adf_format_str(__u32 format, char buf[ADF_FORMAT_STR_SIZE]); | |
| /** | |
| * Finds an appropriate interface and overlay engine for a simple post. | |
| * | |
| * Specifically, finds the primary interface, and an overlay engine | |
| * that can be attached to the primary interface and supports one of the | |
| * specified formats. The caller may pass a NULL formats list, to indicate that | |
| * any RGB format is acceptable. | |
| * | |
| * On error, returns -errno. | |
| */ | |
| int adf_find_simple_post_configuration(struct adf_device *dev, | |
| const __u32 *formats, size_t n_formats, | |
| adf_id_t *interface, adf_id_t *overlay_engine); | |
| __END_DECLS | |
| #endif /* _LIBADF_ADF_H_ */ |