diff options
Diffstat (limited to 'deprecated-adf/libadfhwc/adfhwc.cpp')
| -rw-r--r-- | deprecated-adf/libadfhwc/adfhwc.cpp | 376 |
1 files changed, 376 insertions, 0 deletions
diff --git a/deprecated-adf/libadfhwc/adfhwc.cpp b/deprecated-adf/libadfhwc/adfhwc.cpp new file mode 100644 index 000000000..63c0f7521 --- /dev/null +++ b/deprecated-adf/libadfhwc/adfhwc.cpp @@ -0,0 +1,376 @@ +/* + * 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. + */ + +#include <fcntl.h> +#include <malloc.h> +#include <poll.h> +#include <pthread.h> +#include <sys/resource.h> + +#include <log/log.h> +#include <utils/Vector.h> + +#include <adf/adf.h> +#include <adfhwc/adfhwc.h> + +struct adf_hwc_helper { + adf_hwc_event_callbacks const *event_cb; + void *event_cb_data; + + pthread_t event_thread; + + android::Vector<int> intf_fds; + android::Vector<drm_mode_modeinfo> display_configs; +}; + +template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; } + +int adf_eventControl(struct adf_hwc_helper *dev, int disp, int event, + int enabled) +{ + if (enabled != !!enabled) + return -EINVAL; + + if ((size_t)disp >= dev->intf_fds.size()) + return -EINVAL; + + switch (event) { + case HWC_EVENT_VSYNC: + return adf_set_event(dev->intf_fds[disp], ADF_EVENT_VSYNC, enabled); + } + + return -EINVAL; +} + +static inline int32_t dpi(uint16_t res, uint16_t size_mm) +{ + if (size_mm) + return 1000 * (res * 25.4f) / size_mm; + return 0; +} + +int adf_blank(struct adf_hwc_helper *dev, int disp, int blank) +{ + if ((size_t)disp >= dev->intf_fds.size()) + return -EINVAL; + + uint8_t dpms_mode = blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON; + return adf_interface_blank(dev->intf_fds[disp], dpms_mode); +} + +int adf_query_display_types_supported(struct adf_hwc_helper *dev, int *value) +{ + *value = 0; + if (dev->intf_fds.size() > 0) + *value |= HWC_DISPLAY_PRIMARY_BIT; + if (dev->intf_fds.size() > 1) + *value |= HWC_DISPLAY_EXTERNAL_BIT; + + return 0; +} + +int adf_getDisplayConfigs(struct adf_hwc_helper *dev, int disp, + uint32_t *configs, size_t *numConfigs) +{ + if ((size_t)disp >= dev->intf_fds.size()) + return -EINVAL; + + adf_interface_data data; + int err = adf_get_interface_data(dev->intf_fds[disp], &data); + if (err < 0) { + ALOGE("failed to get ADF interface data: %s", strerror(err)); + return err; + } + + if (!data.hotplug_detect) + return -ENODEV; + + android::Vector<drm_mode_modeinfo *> unique_configs; + unique_configs.push_back(&data.current_mode); + for (size_t i = 0; i < data.n_available_modes; i++) + if (memcmp(&data.available_modes[i], &data.current_mode, + sizeof(data.current_mode))) + unique_configs.push_back(&data.available_modes[i]); + + for (size_t i = 0; i < min(*numConfigs, unique_configs.size()); i++) { + configs[i] = dev->display_configs.size(); + dev->display_configs.push_back(*unique_configs[i]); + } + *numConfigs = unique_configs.size(); + + adf_free_interface_data(&data); + return 0; +} + +static int32_t adf_display_attribute(const adf_interface_data &data, + const drm_mode_modeinfo &mode, const uint32_t attribute) +{ + switch (attribute) { + case HWC_DISPLAY_VSYNC_PERIOD: + if (mode.vrefresh) + return 1000000000 / mode.vrefresh; + return 0; + + case HWC_DISPLAY_WIDTH: + return mode.hdisplay; + + case HWC_DISPLAY_HEIGHT: + return mode.vdisplay; + + case HWC_DISPLAY_DPI_X: + return dpi(mode.hdisplay, data.width_mm); + + case HWC_DISPLAY_DPI_Y: + return dpi(mode.vdisplay, data.height_mm); + + default: + ALOGE("unknown display attribute %u", attribute); + return -EINVAL; + } +} + +int adf_getDisplayAttributes(struct adf_hwc_helper *dev, int disp, + uint32_t config, const uint32_t *attributes, int32_t *values) +{ + if ((size_t)disp >= dev->intf_fds.size()) + return -EINVAL; + + if (config >= dev->display_configs.size()) + return -EINVAL; + + adf_interface_data data; + int err = adf_get_interface_data(dev->intf_fds[disp], &data); + if (err < 0) { + ALOGE("failed to get ADF interface data: %s", strerror(err)); + return err; + } + + for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++) + values[i] = adf_display_attribute(data, dev->display_configs[config], + attributes[i]); + + adf_free_interface_data(&data); + return 0; +} + +static int32_t adf_display_attribute_hwc2(const adf_interface_data &data, + const drm_mode_modeinfo &mode, const uint32_t attribute) +{ + switch (attribute) { + case HWC2_ATTRIBUTE_VSYNC_PERIOD: + if (mode.vrefresh) + return 1000000000 / mode.vrefresh; + return 0; + + case HWC2_ATTRIBUTE_WIDTH: + return mode.hdisplay; + + case HWC2_ATTRIBUTE_HEIGHT: + return mode.vdisplay; + + case HWC2_ATTRIBUTE_DPI_X: + return dpi(mode.hdisplay, data.width_mm); + + case HWC2_ATTRIBUTE_DPI_Y: + return dpi(mode.vdisplay, data.height_mm); + + default: + ALOGE("unknown display attribute %u", attribute); + return -EINVAL; + } +} + +int adf_getDisplayAttributes_hwc2(struct adf_hwc_helper *dev, int disp, + uint32_t config, const uint32_t *attributes, int32_t *values) +{ + if ((size_t)disp >= dev->intf_fds.size()) + return -EINVAL; + + if (config >= dev->display_configs.size()) + return -EINVAL; + + adf_interface_data data; + int err = adf_get_interface_data(dev->intf_fds[disp], &data); + if (err < 0) { + ALOGE("failed to get ADF interface data: %s", strerror(err)); + return err; + } + + for (int i = 0; attributes[i] != HWC2_ATTRIBUTE_INVALID; i++) + values[i] = adf_display_attribute_hwc2(data, + dev->display_configs[config], attributes[i]); + + adf_free_interface_data(&data); + return 0; +} + +int adf_set_active_config_hwc2(struct adf_hwc_helper *dev, int disp, + uint32_t config) +{ + if ((size_t)disp >= dev->intf_fds.size()) + return -EINVAL; + + if (config >= dev->display_configs.size()) + return -EINVAL; + + struct drm_mode_modeinfo mode = dev->display_configs[config]; + + return adf_interface_set_mode(dev->intf_fds[disp], &mode); +} + +static void handle_adf_event(struct adf_hwc_helper *dev, int disp) +{ + adf_event *event; + int err = adf_read_event(dev->intf_fds[disp], &event); + if (err < 0) { + ALOGE("error reading event from display %d: %s", disp, strerror(err)); + return; + } + + void *vsync_temp; + adf_vsync_event *vsync; + adf_hotplug_event *hotplug; + + switch (event->type) { + case ADF_EVENT_VSYNC: + vsync_temp = event; + vsync = static_cast<adf_vsync_event *>(vsync_temp); + // casting directly to adf_vsync_event * makes g++ warn about + // potential alignment issues that don't apply here + dev->event_cb->vsync(dev->event_cb_data, disp, vsync->timestamp); + break; + case ADF_EVENT_HOTPLUG: + hotplug = reinterpret_cast<adf_hotplug_event *>(event); + dev->event_cb->hotplug(dev->event_cb_data, disp, hotplug->connected); + break; + default: + if (event->type < ADF_EVENT_DEVICE_CUSTOM) + ALOGW("unrecognized event type %u", event->type); + else if (!dev->event_cb || !dev->event_cb->custom_event) + ALOGW("unhandled event type %u", event->type); + else + dev->event_cb->custom_event(dev->event_cb_data, disp, event); + } + free(event); +} + +static void *adf_event_thread(void *data) +{ + adf_hwc_helper *dev = static_cast<adf_hwc_helper *>(data); + + setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY); + + struct sigaction action = { }; + sigemptyset(&action.sa_mask); + action.sa_flags = 0; + action.sa_handler = [](int) { pthread_exit(0); }; + + if (sigaction(SIGUSR2, &action, NULL) < 0) { + ALOGE("failed to set thread exit action %s", strerror(errno)); + return NULL; + } + + sigset_t signal_set; + sigemptyset(&signal_set); + sigaddset(&signal_set, SIGUSR2); + + pthread_sigmask(SIG_UNBLOCK, &signal_set, NULL); + + pollfd fds[dev->intf_fds.size()]; + for (size_t i = 0; i < dev->intf_fds.size(); i++) { + fds[i].fd = dev->intf_fds[i]; + fds[i].events = POLLIN | POLLPRI; + } + + while (true) { + if (TEMP_FAILURE_RETRY(poll(fds, dev->intf_fds.size(), -1)) < 0) { + ALOGE("error in event thread: %s", strerror(errno)); + break; + } + + for (size_t i = 0; i < dev->intf_fds.size(); i++) + if (fds[i].revents & (POLLIN | POLLPRI)) + handle_adf_event(dev, i); + } + + return NULL; +} + +int adf_hwc_open(int *intf_fds, size_t n_intfs, + const struct adf_hwc_event_callbacks *event_cb, void *event_cb_data, + struct adf_hwc_helper **dev) +{ + if (!n_intfs) + return -EINVAL; + + adf_hwc_helper *dev_ret = new adf_hwc_helper; + dev_ret->event_cb = event_cb; + dev_ret->event_cb_data = event_cb_data; + + int ret; + + for (size_t i = 0; i < n_intfs; i++) { + int dup_intf_fd = dup(intf_fds[i]); + if (dup_intf_fd < 0) { + ALOGE("failed to dup interface fd: %s", strerror(errno)); + ret = -errno; + goto err; + } + + dev_ret->intf_fds.push_back(dup_intf_fd); + + ret = adf_set_event(dup_intf_fd, ADF_EVENT_HOTPLUG, 1); + if (ret < 0 && ret != -EINVAL) { + ALOGE("failed to enable hotplug event on display %zu: %s", + i, strerror(errno)); + goto err; + } + } + + sigset_t signal_set; + sigemptyset(&signal_set); + sigaddset(&signal_set, SIGUSR2); + + pthread_sigmask(SIG_BLOCK, &signal_set, NULL); + + ret = pthread_create(&dev_ret->event_thread, NULL, adf_event_thread, + dev_ret); + if (ret) { + ALOGE("failed to create event thread: %s", strerror(ret)); + goto err; + } + + *dev = dev_ret; + return 0; + +err: + for (size_t i = 0; i < dev_ret->intf_fds.size(); i++) + close(dev_ret->intf_fds[i]); + + delete dev_ret; + return ret; +} + +void adf_hwc_close(struct adf_hwc_helper *dev) +{ + pthread_kill(dev->event_thread, SIGUSR2); + pthread_join(dev->event_thread, NULL); + + for (size_t i = 0; i < dev->intf_fds.size(); i++) + close(dev->intf_fds[i]); + + delete dev; +} |