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 <malloc.h>
19 #include <poll.h>
20 #include <pthread.h>
21 #include <sys/resource.h>
22 
23 #include <log/log.h>
24 #include <utils/Vector.h>
25 
26 #include <adf/adf.h>
27 #include <adfhwc/adfhwc.h>
28 
29 struct adf_hwc_helper {
30     adf_hwc_event_callbacks const *event_cb;
31     void *event_cb_data;
32 
33     pthread_t event_thread;
34 
35     android::Vector<int> intf_fds;
36     android::Vector<drm_mode_modeinfo> display_configs;
37 };
38 
min(T a,T b)39 template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
40 
adf_eventControl(struct adf_hwc_helper * dev,int disp,int event,int enabled)41 int adf_eventControl(struct adf_hwc_helper *dev, int disp, int event,
42         int enabled)
43 {
44     if (enabled != !!enabled)
45         return -EINVAL;
46 
47     if ((size_t)disp >= dev->intf_fds.size())
48         return -EINVAL;
49 
50     switch (event) {
51     case HWC_EVENT_VSYNC:
52         return adf_set_event(dev->intf_fds[disp], ADF_EVENT_VSYNC, enabled);
53     }
54 
55     return -EINVAL;
56 }
57 
dpi(uint16_t res,uint16_t size_mm)58 static inline int32_t dpi(uint16_t res, uint16_t size_mm)
59 {
60     if (size_mm)
61         return 1000 * (res * 25.4f) / size_mm;
62     return 0;
63 }
64 
adf_blank(struct adf_hwc_helper * dev,int disp,int blank)65 int adf_blank(struct adf_hwc_helper *dev, int disp, int blank)
66 {
67     if ((size_t)disp >= dev->intf_fds.size())
68         return -EINVAL;
69 
70     uint8_t dpms_mode = blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON;
71     return adf_interface_blank(dev->intf_fds[disp], dpms_mode);
72 }
73 
adf_query_display_types_supported(struct adf_hwc_helper * dev,int * value)74 int adf_query_display_types_supported(struct adf_hwc_helper *dev, int *value)
75 {
76     *value = 0;
77     if (dev->intf_fds.size() > 0)
78         *value |= HWC_DISPLAY_PRIMARY_BIT;
79     if (dev->intf_fds.size() > 1)
80         *value |= HWC_DISPLAY_EXTERNAL_BIT;
81 
82     return 0;
83 }
84 
adf_getDisplayConfigs(struct adf_hwc_helper * dev,int disp,uint32_t * configs,size_t * numConfigs)85 int adf_getDisplayConfigs(struct adf_hwc_helper *dev, int disp,
86         uint32_t *configs, size_t *numConfigs)
87 {
88     if ((size_t)disp >= dev->intf_fds.size())
89         return -EINVAL;
90 
91     adf_interface_data data;
92     int err = adf_get_interface_data(dev->intf_fds[disp], &data);
93     if (err < 0) {
94         ALOGE("failed to get ADF interface data: %s", strerror(err));
95         return err;
96     }
97 
98     if (!data.hotplug_detect)
99         return -ENODEV;
100 
101     android::Vector<drm_mode_modeinfo *> unique_configs;
102     unique_configs.push_back(&data.current_mode);
103     for (size_t i = 0; i < data.n_available_modes; i++)
104         if (memcmp(&data.available_modes[i], &data.current_mode,
105                 sizeof(data.current_mode)))
106             unique_configs.push_back(&data.available_modes[i]);
107 
108     for (size_t i = 0; i < min(*numConfigs, unique_configs.size()); i++) {
109         configs[i] = dev->display_configs.size();
110         dev->display_configs.push_back(*unique_configs[i]);
111     }
112     *numConfigs = unique_configs.size();
113 
114     adf_free_interface_data(&data);
115     return 0;
116 }
117 
adf_display_attribute(const adf_interface_data & data,const drm_mode_modeinfo & mode,const uint32_t attribute)118 static int32_t adf_display_attribute(const adf_interface_data &data,
119         const drm_mode_modeinfo &mode, const uint32_t attribute)
120 {
121     switch (attribute) {
122     case HWC_DISPLAY_VSYNC_PERIOD:
123         if (mode.vrefresh)
124             return 1000000000 / mode.vrefresh;
125         return 0;
126 
127     case HWC_DISPLAY_WIDTH:
128         return mode.hdisplay;
129 
130     case HWC_DISPLAY_HEIGHT:
131         return mode.vdisplay;
132 
133     case HWC_DISPLAY_DPI_X:
134         return dpi(mode.hdisplay, data.width_mm);
135 
136     case HWC_DISPLAY_DPI_Y:
137         return dpi(mode.vdisplay, data.height_mm);
138 
139     default:
140         ALOGE("unknown display attribute %u", attribute);
141         return -EINVAL;
142     }
143 }
144 
adf_getDisplayAttributes(struct adf_hwc_helper * dev,int disp,uint32_t config,const uint32_t * attributes,int32_t * values)145 int adf_getDisplayAttributes(struct adf_hwc_helper *dev, int disp,
146         uint32_t config, const uint32_t *attributes, int32_t *values)
147 {
148     if ((size_t)disp >= dev->intf_fds.size())
149         return -EINVAL;
150 
151     if (config >= dev->display_configs.size())
152         return -EINVAL;
153 
154     adf_interface_data data;
155     int err = adf_get_interface_data(dev->intf_fds[disp], &data);
156     if (err < 0) {
157         ALOGE("failed to get ADF interface data: %s", strerror(err));
158         return err;
159     }
160 
161     for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++)
162         values[i] = adf_display_attribute(data, dev->display_configs[config],
163                 attributes[i]);
164 
165     adf_free_interface_data(&data);
166     return 0;
167 }
168 
adf_display_attribute_hwc2(const adf_interface_data & data,const drm_mode_modeinfo & mode,const uint32_t attribute)169 static int32_t adf_display_attribute_hwc2(const adf_interface_data &data,
170         const drm_mode_modeinfo &mode, const uint32_t attribute)
171 {
172     switch (attribute) {
173     case HWC2_ATTRIBUTE_VSYNC_PERIOD:
174         if (mode.vrefresh)
175             return 1000000000 / mode.vrefresh;
176         return 0;
177 
178     case HWC2_ATTRIBUTE_WIDTH:
179         return mode.hdisplay;
180 
181     case HWC2_ATTRIBUTE_HEIGHT:
182         return mode.vdisplay;
183 
184     case HWC2_ATTRIBUTE_DPI_X:
185         return dpi(mode.hdisplay, data.width_mm);
186 
187     case HWC2_ATTRIBUTE_DPI_Y:
188         return dpi(mode.vdisplay, data.height_mm);
189 
190     default:
191         ALOGE("unknown display attribute %u", attribute);
192         return -EINVAL;
193     }
194 }
195 
adf_getDisplayAttributes_hwc2(struct adf_hwc_helper * dev,int disp,uint32_t config,const uint32_t * attributes,int32_t * values)196 int adf_getDisplayAttributes_hwc2(struct adf_hwc_helper *dev, int disp,
197         uint32_t config, const uint32_t *attributes, int32_t *values)
198 {
199     if ((size_t)disp >= dev->intf_fds.size())
200         return -EINVAL;
201 
202     if (config >= dev->display_configs.size())
203         return -EINVAL;
204 
205     adf_interface_data data;
206     int err = adf_get_interface_data(dev->intf_fds[disp], &data);
207     if (err < 0) {
208         ALOGE("failed to get ADF interface data: %s", strerror(err));
209         return err;
210     }
211 
212     for (int i = 0; attributes[i] != HWC2_ATTRIBUTE_INVALID; i++)
213         values[i] = adf_display_attribute_hwc2(data,
214                 dev->display_configs[config], attributes[i]);
215 
216     adf_free_interface_data(&data);
217     return 0;
218 }
219 
adf_set_active_config_hwc2(struct adf_hwc_helper * dev,int disp,uint32_t config)220 int adf_set_active_config_hwc2(struct adf_hwc_helper *dev, int disp,
221         uint32_t config)
222 {
223     if ((size_t)disp >= dev->intf_fds.size())
224         return -EINVAL;
225 
226     if (config >= dev->display_configs.size())
227         return -EINVAL;
228 
229     struct drm_mode_modeinfo mode = dev->display_configs[config];
230 
231     return adf_interface_set_mode(dev->intf_fds[disp], &mode);
232 }
233 
handle_adf_event(struct adf_hwc_helper * dev,int disp)234 static void handle_adf_event(struct adf_hwc_helper *dev, int disp)
235 {
236     adf_event *event;
237     int err = adf_read_event(dev->intf_fds[disp], &event);
238     if (err < 0) {
239         ALOGE("error reading event from display %d: %s", disp, strerror(err));
240         return;
241     }
242 
243     void *vsync_temp;
244     adf_vsync_event *vsync;
245     adf_hotplug_event *hotplug;
246 
247     switch (event->type) {
248     case ADF_EVENT_VSYNC:
249         vsync_temp = event;
250         vsync = static_cast<adf_vsync_event *>(vsync_temp);
251         // casting directly to adf_vsync_event * makes g++ warn about
252         // potential alignment issues that don't apply here
253         dev->event_cb->vsync(dev->event_cb_data, disp, vsync->timestamp);
254         break;
255     case ADF_EVENT_HOTPLUG:
256         hotplug = reinterpret_cast<adf_hotplug_event *>(event);
257         dev->event_cb->hotplug(dev->event_cb_data, disp, hotplug->connected);
258         break;
259     default:
260         if (event->type < ADF_EVENT_DEVICE_CUSTOM)
261             ALOGW("unrecognized event type %u", event->type);
262         else if (!dev->event_cb || !dev->event_cb->custom_event)
263             ALOGW("unhandled event type %u", event->type);
264         else
265             dev->event_cb->custom_event(dev->event_cb_data, disp, event);
266     }
267     free(event);
268 }
269 
adf_event_thread(void * data)270 static void *adf_event_thread(void *data)
271 {
272     adf_hwc_helper *dev = static_cast<adf_hwc_helper *>(data);
273 
274     setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
275 
276     struct sigaction action = { };
277     sigemptyset(&action.sa_mask);
278     action.sa_flags = 0;
279     action.sa_handler = [](int) { pthread_exit(0); };
280 
281     if (sigaction(SIGUSR2, &action, NULL) < 0) {
282         ALOGE("failed to set thread exit action %s", strerror(errno));
283         return NULL;
284     }
285 
286     sigset_t signal_set;
287     sigemptyset(&signal_set);
288     sigaddset(&signal_set, SIGUSR2);
289 
290     pthread_sigmask(SIG_UNBLOCK, &signal_set, NULL);
291 
292     pollfd fds[dev->intf_fds.size()];
293     for (size_t i = 0; i < dev->intf_fds.size(); i++) {
294         fds[i].fd = dev->intf_fds[i];
295         fds[i].events = POLLIN | POLLPRI;
296     }
297 
298     while (true) {
299         if (TEMP_FAILURE_RETRY(poll(fds, dev->intf_fds.size(), -1)) < 0) {
300             ALOGE("error in event thread: %s", strerror(errno));
301             break;
302         }
303 
304         for (size_t i = 0; i < dev->intf_fds.size(); i++)
305             if (fds[i].revents & (POLLIN | POLLPRI))
306                 handle_adf_event(dev, i);
307     }
308 
309     return NULL;
310 }
311 
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)312 int adf_hwc_open(int *intf_fds, size_t n_intfs,
313         const struct adf_hwc_event_callbacks *event_cb, void *event_cb_data,
314         struct adf_hwc_helper **dev)
315 {
316     if (!n_intfs)
317         return -EINVAL;
318 
319     adf_hwc_helper *dev_ret = new adf_hwc_helper;
320     dev_ret->event_cb = event_cb;
321     dev_ret->event_cb_data = event_cb_data;
322 
323     int ret;
324 
325     for (size_t i = 0; i < n_intfs; i++) {
326         int dup_intf_fd = dup(intf_fds[i]);
327         if (dup_intf_fd < 0) {
328             ALOGE("failed to dup interface fd: %s", strerror(errno));
329             ret = -errno;
330             goto err;
331         }
332 
333         dev_ret->intf_fds.push_back(dup_intf_fd);
334 
335         ret = adf_set_event(dup_intf_fd, ADF_EVENT_HOTPLUG, 1);
336         if (ret < 0 && ret != -EINVAL) {
337             ALOGE("failed to enable hotplug event on display %zu: %s",
338                     i, strerror(errno));
339             goto err;
340         }
341     }
342 
343     sigset_t signal_set;
344     sigemptyset(&signal_set);
345     sigaddset(&signal_set, SIGUSR2);
346 
347     pthread_sigmask(SIG_BLOCK, &signal_set, NULL);
348 
349     ret = pthread_create(&dev_ret->event_thread, NULL, adf_event_thread,
350             dev_ret);
351     if (ret) {
352         ALOGE("failed to create event thread: %s", strerror(ret));
353         goto err;
354     }
355 
356     *dev = dev_ret;
357     return 0;
358 
359 err:
360     for (size_t i = 0; i < dev_ret->intf_fds.size(); i++)
361         close(dev_ret->intf_fds[i]);
362 
363     delete dev_ret;
364     return ret;
365 }
366 
adf_hwc_close(struct adf_hwc_helper * dev)367 void adf_hwc_close(struct adf_hwc_helper *dev)
368 {
369     pthread_kill(dev->event_thread, SIGUSR2);
370     pthread_join(dev->event_thread, NULL);
371 
372     for (size_t i = 0; i < dev->intf_fds.size(); i++)
373         close(dev->intf_fds[i]);
374 
375     delete dev;
376 }
377