1/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <fcntl.h>
18#include <poll.h>
19#include <pthread.h>
20#include <sys/resource.h>
21
22#include <adf/adf.h>
23#include <adfhwc/adfhwc.h>
24
25#include <cutils/log.h>
26#include <utils/Vector.h>
27
28struct adf_hwc_helper {
29    adf_hwc_event_callbacks const *event_cb;
30    void *event_cb_data;
31
32    pthread_t event_thread;
33
34    android::Vector<int> intf_fds;
35    android::Vector<drm_mode_modeinfo> display_configs;
36};
37
38template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
39
40int adf_eventControl(struct adf_hwc_helper *dev, int disp, int event,
41        int enabled)
42{
43    if (enabled != !!enabled)
44        return -EINVAL;
45
46    if ((size_t)disp >= dev->intf_fds.size())
47        return -EINVAL;
48
49    switch (event) {
50    case HWC_EVENT_VSYNC:
51        return adf_set_event(dev->intf_fds[disp], ADF_EVENT_VSYNC, enabled);
52    }
53
54    return -EINVAL;
55}
56
57static inline int32_t dpi(uint16_t res, uint16_t size_mm)
58{
59    if (size_mm)
60        return 1000 * (res * 25.4f) / size_mm;
61    return 0;
62}
63
64int adf_blank(struct adf_hwc_helper *dev, int disp, int blank)
65{
66    if ((size_t)disp >= dev->intf_fds.size())
67        return -EINVAL;
68
69    uint8_t dpms_mode = blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON;
70    return adf_interface_blank(dev->intf_fds[disp], dpms_mode);
71}
72
73int adf_query_display_types_supported(struct adf_hwc_helper *dev, int *value)
74{
75    *value = 0;
76    if (dev->intf_fds.size() > 0)
77        *value |= HWC_DISPLAY_PRIMARY_BIT;
78    if (dev->intf_fds.size() > 1)
79        *value |= HWC_DISPLAY_EXTERNAL_BIT;
80
81    return 0;
82}
83
84int adf_getDisplayConfigs(struct adf_hwc_helper *dev, int disp,
85        uint32_t *configs, size_t *numConfigs)
86{
87    if ((size_t)disp >= dev->intf_fds.size())
88        return -EINVAL;
89
90    adf_interface_data data;
91    int err = adf_get_interface_data(dev->intf_fds[disp], &data);
92    if (err < 0) {
93        ALOGE("failed to get ADF interface data: %s", strerror(err));
94        return err;
95    }
96
97    if (!data.hotplug_detect)
98        return -ENODEV;
99
100    android::Vector<drm_mode_modeinfo *> unique_configs;
101    unique_configs.push_back(&data.current_mode);
102    for (size_t i = 0; i < data.n_available_modes; i++)
103        if (memcmp(&data.available_modes[i], &data.current_mode,
104                sizeof(data.current_mode)))
105            unique_configs.push_back(&data.available_modes[i]);
106
107    for (size_t i = 0; i < min(*numConfigs, unique_configs.size()); i++) {
108        configs[i] = dev->display_configs.size();
109        dev->display_configs.push_back(*unique_configs[i]);
110    }
111    *numConfigs = unique_configs.size();
112
113    adf_free_interface_data(&data);
114    return 0;
115}
116
117static int32_t adf_display_attribute(const adf_interface_data &data,
118        const drm_mode_modeinfo &mode, const uint32_t attribute)
119{
120    switch (attribute) {
121    case HWC_DISPLAY_VSYNC_PERIOD:
122        if (mode.vrefresh)
123            return 1000000000 / mode.vrefresh;
124        return 0;
125
126    case HWC_DISPLAY_WIDTH:
127        return mode.hdisplay;
128
129    case HWC_DISPLAY_HEIGHT:
130        return mode.vdisplay;
131
132    case HWC_DISPLAY_DPI_X:
133        return dpi(mode.hdisplay, data.width_mm);
134
135    case HWC_DISPLAY_DPI_Y:
136        return dpi(mode.vdisplay, data.height_mm);
137
138    default:
139        ALOGE("unknown display attribute %u", attribute);
140        return -EINVAL;
141    }
142}
143
144int adf_getDisplayAttributes(struct adf_hwc_helper *dev, int disp,
145        uint32_t config, const uint32_t *attributes, int32_t *values)
146{
147    if ((size_t)disp >= dev->intf_fds.size())
148        return -EINVAL;
149
150    if (config >= dev->display_configs.size())
151        return -EINVAL;
152
153    adf_interface_data data;
154    int err = adf_get_interface_data(dev->intf_fds[disp], &data);
155    if (err < 0) {
156        ALOGE("failed to get ADF interface data: %s", strerror(err));
157        return err;
158    }
159
160    for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++)
161        values[i] = adf_display_attribute(data, dev->display_configs[config],
162                attributes[i]);
163
164    adf_free_interface_data(&data);
165    return 0;
166}
167
168static void handle_adf_event(struct adf_hwc_helper *dev, int disp)
169{
170    adf_event *event;
171    int err = adf_read_event(dev->intf_fds[disp], &event);
172    if (err < 0) {
173        ALOGE("error reading event from display %d: %s", disp, strerror(err));
174        return;
175    }
176
177    void *vsync_temp;
178    adf_vsync_event *vsync;
179    adf_hotplug_event *hotplug;
180
181    switch (event->type) {
182    case ADF_EVENT_VSYNC:
183        vsync_temp = event;
184        vsync = static_cast<adf_vsync_event *>(vsync_temp);
185        // casting directly to adf_vsync_event * makes g++ warn about
186        // potential alignment issues that don't apply here
187        dev->event_cb->vsync(dev->event_cb_data, disp, vsync->timestamp);
188        break;
189    case ADF_EVENT_HOTPLUG:
190        hotplug = reinterpret_cast<adf_hotplug_event *>(event);
191        dev->event_cb->hotplug(dev->event_cb_data, disp, hotplug->connected);
192        break;
193    default:
194        if (event->type < ADF_EVENT_DEVICE_CUSTOM)
195            ALOGW("unrecognized event type %u", event->type);
196        else if (!dev->event_cb || !dev->event_cb->custom_event)
197            ALOGW("unhandled event type %u", event->type);
198        else
199            dev->event_cb->custom_event(dev->event_cb_data, disp, event);
200    }
201    free(event);
202}
203
204static void *adf_event_thread(void *data)
205{
206    adf_hwc_helper *dev = static_cast<adf_hwc_helper *>(data);
207
208    setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
209
210    pollfd *fds = new pollfd[dev->intf_fds.size()];
211    for (size_t i = 0; i < dev->intf_fds.size(); i++) {
212        fds[i].fd = dev->intf_fds[i];
213        fds[i].events = POLLIN | POLLPRI;
214    }
215
216    while (true) {
217        int err = poll(fds, dev->intf_fds.size(), -1);
218
219        if (err > 0) {
220            for (size_t i = 0; i < dev->intf_fds.size(); i++)
221                if (fds[i].revents & (POLLIN | POLLPRI))
222                    handle_adf_event(dev, i);
223        }
224        else if (err == -1) {
225            if (errno == EINTR)
226                break;
227            ALOGE("error in event thread: %s", strerror(errno));
228        }
229    }
230
231    delete [] fds;
232    return NULL;
233}
234
235int adf_hwc_open(int *intf_fds, size_t n_intfs,
236        const struct adf_hwc_event_callbacks *event_cb, void *event_cb_data,
237        struct adf_hwc_helper **dev)
238{
239    if (!n_intfs)
240        return -EINVAL;
241
242    adf_hwc_helper *dev_ret = new adf_hwc_helper;
243    dev_ret->event_cb = event_cb;
244    dev_ret->event_cb_data = event_cb_data;
245
246    int ret;
247
248    for (size_t i = 0; i < n_intfs; i++) {
249        int dup_intf_fd = dup(intf_fds[i]);
250        if (dup_intf_fd < 0) {
251            ALOGE("failed to dup interface fd: %s", strerror(errno));
252            ret = -errno;
253            goto err;
254        }
255
256        dev_ret->intf_fds.push_back(dup_intf_fd);
257
258        ret = adf_set_event(dup_intf_fd, ADF_EVENT_HOTPLUG, 1);
259        if (ret < 0 && ret != -EINVAL) {
260            ALOGE("failed to enable hotplug event on display %zu: %s",
261                    i, strerror(errno));
262            goto err;
263        }
264    }
265
266    ret = pthread_create(&dev_ret->event_thread, NULL, adf_event_thread,
267            dev_ret);
268    if (ret) {
269        ALOGE("failed to create event thread: %s", strerror(ret));
270        goto err;
271    }
272
273    *dev = dev_ret;
274    return 0;
275
276err:
277    for (size_t i = 0; i < dev_ret->intf_fds.size(); i++)
278        close(dev_ret->intf_fds[i]);
279
280    delete dev_ret;
281    return ret;
282}
283
284void adf_hwc_close(struct adf_hwc_helper *dev)
285{
286    pthread_kill(dev->event_thread, SIGTERM);
287    pthread_join(dev->event_thread, NULL);
288
289    for (size_t i = 0; i < dev->intf_fds.size(); i++)
290        close(dev->intf_fds[i]);
291
292    delete dev;
293}
294