Home | History | Annotate | Download | only in libadf
      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 <dirent.h>
     18 #include <errno.h>
     19 #include <fcntl.h>
     20 #include <malloc.h>
     21 #include <stdint.h>
     22 #include <stdio.h>
     23 #include <string.h>
     24 #include <unistd.h>
     25 
     26 #include <algorithm>
     27 #include <memory>
     28 #include <vector>
     29 
     30 #include <linux/limits.h>
     31 
     32 #include <sys/ioctl.h>
     33 
     34 #include <adf/adf.h>
     35 
     36 #define ADF_BASE_PATH "/dev/"
     37 
     38 static ssize_t adf_id_vector_to_array(const std::vector<adf_id_t> &in,
     39         adf_id_t **out)
     40 {
     41     auto size = sizeof(in[0]) * in.size();
     42     // We can't use new[] since the existing API says the caller should free()
     43     // the returned array
     44     auto ret = static_cast<adf_id_t *>(malloc(size));
     45     if (!ret)
     46         return -ENOMEM;
     47 
     48     std::copy(in.begin(), in.end(), ret);
     49     *out = ret;
     50     return in.size();
     51 }
     52 
     53 static ssize_t adf_find_nodes(const char *pattern, adf_id_t **ids_out)
     54 {
     55     struct dirent *dirent;
     56     std::unique_ptr<DIR, decltype(&closedir)>
     57         dir{opendir(ADF_BASE_PATH), closedir};
     58     if (!dir)
     59         return -errno;
     60 
     61     std::vector<adf_id_t> ids;
     62     errno = 0;
     63     while ((dirent = readdir(dir.get()))) {
     64         adf_id_t id;
     65         int matched = sscanf(dirent->d_name, pattern, &id);
     66 
     67         if (matched < 0)
     68             return -errno;
     69         else if (matched == 1)
     70             ids.push_back(id);
     71     }
     72     if (errno)
     73         return -errno;
     74 
     75     return adf_id_vector_to_array(ids, ids_out);
     76 }
     77 
     78 ssize_t adf_devices(adf_id_t **ids)
     79 {
     80     return adf_find_nodes("adf%u", ids);
     81 }
     82 
     83 int adf_device_open(adf_id_t id, int flags, struct adf_device *dev)
     84 {
     85     char filename[64];
     86 
     87     dev->id = id;
     88 
     89     snprintf(filename, sizeof(filename), ADF_BASE_PATH "adf%u", id);
     90     dev->fd = open(filename, flags);
     91     if (dev->fd < 0)
     92         return -errno;
     93 
     94     return 0;
     95 }
     96 
     97 void adf_device_close(struct adf_device *dev)
     98 {
     99     if (dev->fd >= 0)
    100         close(dev->fd);
    101 }
    102 
    103 int adf_get_device_data(struct adf_device *dev, struct adf_device_data *data)
    104 {
    105     int err;
    106     int ret = 0;
    107 
    108     memset(data, 0, sizeof(*data));
    109 
    110     err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data);
    111     if (err < 0)
    112         return -ENOMEM;
    113 
    114     if (data->n_attachments)
    115         data->attachments = new adf_attachment_config[data->n_attachments];
    116 
    117     if (data->n_allowed_attachments)
    118         data->allowed_attachments =
    119                 new adf_attachment_config[data->n_allowed_attachments];
    120 
    121     if (data->custom_data_size)
    122         data->custom_data = new char[data->custom_data_size];
    123 
    124     err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data);
    125     if (err < 0) {
    126         ret = -errno;
    127         adf_free_device_data(data);
    128     }
    129     return ret;
    130 }
    131 
    132 void adf_free_device_data(struct adf_device_data *data)
    133 {
    134     delete [] data->attachments;
    135     delete [] data->allowed_attachments;
    136     delete [] static_cast<char *>(data->custom_data);
    137 }
    138 
    139 int adf_device_post(struct adf_device *dev,
    140         adf_id_t *interfaces, size_t n_interfaces,
    141         struct adf_buffer_config *bufs, size_t n_bufs,
    142         void *custom_data, size_t custom_data_size)
    143 {
    144     int err;
    145     struct adf_post_config data;
    146 
    147     memset(&data, 0, sizeof(data));
    148     data.interfaces = interfaces;
    149     data.n_interfaces = n_interfaces;
    150     data.bufs = bufs;
    151     data.n_bufs = n_bufs;
    152     data.custom_data = custom_data;
    153     data.custom_data_size = custom_data_size;
    154 
    155     err = ioctl(dev->fd, ADF_POST_CONFIG, &data);
    156     if (err < 0)
    157         return -errno;
    158 
    159     return (int)data.complete_fence;
    160 }
    161 
    162 int adf_device_post_v2(struct adf_device *dev,
    163         adf_id_t *interfaces, __u32 n_interfaces,
    164         struct adf_buffer_config *bufs, __u32 n_bufs,
    165         void *custom_data, __u64 custom_data_size,
    166         enum adf_complete_fence_type complete_fence_type,
    167         int *complete_fence)
    168 {
    169     int err;
    170     struct adf_post_config_v2 data;
    171 
    172     memset(&data, 0, sizeof(data));
    173     data.interfaces = (uintptr_t)interfaces;
    174     data.n_interfaces = n_interfaces;
    175     data.bufs = (uintptr_t)bufs;
    176     data.n_bufs = n_bufs;
    177     data.custom_data = (uintptr_t)custom_data;
    178     data.custom_data_size = custom_data_size;
    179     data.complete_fence_type = complete_fence_type;
    180 
    181     err = ioctl(dev->fd, ADF_POST_CONFIG_V2, &data);
    182     if (err < 0)
    183         return -errno;
    184 
    185     if (complete_fence)
    186         *complete_fence = data.complete_fence;
    187     else if (data.complete_fence >= 0)
    188         close(data.complete_fence);
    189 
    190     return 0;
    191 }
    192 
    193 static int adf_device_attachment(struct adf_device *dev,
    194         adf_id_t overlay_engine, adf_id_t interface, bool attach)
    195 {
    196     int err;
    197     struct adf_attachment_config data;
    198 
    199     memset(&data, 0, sizeof(data));
    200     data.overlay_engine = overlay_engine;
    201     data.interface = interface;
    202 
    203     err = ioctl(dev->fd, attach ? ADF_ATTACH : ADF_DETACH, &data);
    204     if (err < 0)
    205         return -errno;
    206 
    207     return 0;
    208 }
    209 
    210 int adf_device_attach(struct adf_device *dev, adf_id_t overlay_engine,
    211                       adf_id_t interface)
    212 {
    213    return adf_device_attachment(dev, overlay_engine, interface, true);
    214 }
    215 
    216 int adf_device_detach(struct adf_device *dev, adf_id_t overlay_engine,
    217                       adf_id_t interface)
    218 {
    219    return adf_device_attachment(dev, overlay_engine, interface, false);
    220 }
    221 
    222 ssize_t adf_interfaces(struct adf_device *dev, adf_id_t **interfaces)
    223 {
    224     char pattern[64];
    225 
    226     snprintf(pattern, sizeof(pattern), "adf-interface%u.%%u", dev->id);
    227     return adf_find_nodes(pattern, interfaces);
    228 }
    229 
    230 ssize_t adf_interfaces_for_overlay_engine(struct adf_device *dev,
    231         adf_id_t overlay_engine, adf_id_t **interfaces)
    232 {
    233     struct adf_device_data data;
    234     auto err = adf_get_device_data(dev, &data);
    235     if (err < 0)
    236         return err;
    237 
    238     std::vector<adf_id_t> ids;
    239     for (size_t i = 0; i < data.n_allowed_attachments; i++)
    240         if (data.allowed_attachments[i].overlay_engine == overlay_engine)
    241             ids.push_back(data.allowed_attachments[i].interface);
    242 
    243     adf_free_device_data(&data);
    244     return adf_id_vector_to_array(ids, interfaces);
    245 }
    246 
    247 static ssize_t adf_interfaces_filter(struct adf_device *dev,
    248         adf_id_t *in, size_t n_in, adf_id_t **out,
    249         bool (*filter)(struct adf_interface_data *data, __u32 match),
    250         __u32 match)
    251 {
    252     std::vector<adf_id_t> ids;
    253     for (size_t i = 0; i < n_in; i++) {
    254         int fd = adf_interface_open(dev, in[i], O_RDONLY);
    255         if (fd < 0)
    256             return fd;
    257 
    258         struct adf_interface_data data;
    259         auto ret = adf_get_interface_data(fd, &data);
    260         close(fd);
    261         if (ret < 0)
    262             return ret;
    263 
    264         if (filter(&data, match))
    265             ids.push_back(in[i]);
    266     }
    267 
    268     return adf_id_vector_to_array(ids, out);
    269 }
    270 
    271 static bool adf_interface_type_filter(struct adf_interface_data *data,
    272         __u32 type)
    273 {
    274     return data->type == (enum adf_interface_type)type;
    275 }
    276 
    277 ssize_t adf_interfaces_filter_by_type(struct adf_device *dev,
    278         enum adf_interface_type type,
    279         adf_id_t *in, size_t n_in, adf_id_t **out)
    280 {
    281     return adf_interfaces_filter(dev, in, n_in, out, adf_interface_type_filter,
    282             type);
    283 }
    284 
    285 static bool adf_interface_flags_filter(struct adf_interface_data *data,
    286         __u32 flag)
    287 {
    288     return !!(data->flags & flag);
    289 }
    290 
    291 ssize_t adf_interfaces_filter_by_flag(struct adf_device *dev, __u32 flag,
    292         adf_id_t *in, size_t n_in, adf_id_t **out)
    293 {
    294     return adf_interfaces_filter(dev, in, n_in, out, adf_interface_flags_filter,
    295             flag);
    296 }
    297 
    298 int adf_interface_open(struct adf_device *dev, adf_id_t id, int flags)
    299 {
    300     char filename[64];
    301 
    302     snprintf(filename, sizeof(filename), ADF_BASE_PATH "adf-interface%u.%u",
    303             dev->id, id);
    304 
    305     int fd = open(filename, flags);
    306     if (fd < 0)
    307         return -errno;
    308     return fd;
    309 }
    310 
    311 int adf_get_interface_data(int fd, struct adf_interface_data *data)
    312 {
    313     int err;
    314     int ret = 0;
    315 
    316     memset(data, 0, sizeof(*data));
    317 
    318     err = ioctl(fd, ADF_GET_INTERFACE_DATA, data);
    319     if (err < 0)
    320         return -errno;
    321 
    322     if (data->n_available_modes)
    323         data->available_modes = new drm_mode_modeinfo[data->n_available_modes];
    324 
    325     if (data->custom_data_size)
    326         data->custom_data = new char[data->custom_data_size];
    327 
    328     err = ioctl(fd, ADF_GET_INTERFACE_DATA, data);
    329     if (err < 0) {
    330         ret = -errno;
    331         adf_free_interface_data(data);
    332     }
    333     return ret;
    334 }
    335 
    336 void adf_free_interface_data(struct adf_interface_data *data)
    337 {
    338     delete [] data->available_modes;
    339     delete [] static_cast<char *>(data->custom_data);
    340 }
    341 
    342 int adf_interface_blank(int fd, __u8 mode)
    343 {
    344     int err = ioctl(fd, ADF_BLANK, mode);
    345     if (err < 0)
    346         return -errno;
    347     return 0;
    348 }
    349 
    350 int adf_interface_set_mode(int fd, struct drm_mode_modeinfo *mode)
    351 {
    352     int err = ioctl(fd, ADF_SET_MODE, mode);
    353     if (err < 0)
    354         return -errno;
    355     return 0;
    356 }
    357 
    358 int adf_interface_simple_buffer_alloc(int fd, __u32 w, __u32 h,
    359         __u32 format, __u32 *offset, __u32 *pitch)
    360 {
    361     int err;
    362     struct adf_simple_buffer_alloc data;
    363 
    364     memset(&data, 0, sizeof(data));
    365     data.w = w;
    366     data.h = h;
    367     data.format = format;
    368 
    369     err = ioctl(fd, ADF_SIMPLE_BUFFER_ALLOC, &data);
    370     if (err < 0)
    371         return -errno;
    372 
    373     *offset = data.offset;
    374     *pitch = data.pitch;
    375     return (int)data.fd;
    376 }
    377 
    378 static void adf_interface_simple_post_config_buf(struct adf_buffer_config *buf,
    379         __u32 overlay_engine, __u32 w, __u32 h, __u32 format, int buf_fd,
    380         __u32 offset, __u32 pitch, int acquire_fence)
    381 {
    382     buf->overlay_engine = overlay_engine;
    383     buf->w = w;
    384     buf->h = h;
    385     buf->format = format;
    386     buf->fd[0] = buf_fd;
    387     buf->offset[0] = offset;
    388     buf->pitch[0] = pitch;
    389     buf->n_planes = 1;
    390     buf->acquire_fence = acquire_fence;
    391 }
    392 
    393 int adf_interface_simple_post(int fd, __u32 overlay_engine,
    394         __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset,
    395         __u32 pitch, int acquire_fence)
    396 {
    397     int ret;
    398     struct adf_simple_post_config data;
    399 
    400     memset(&data, 0, sizeof(data));
    401     adf_interface_simple_post_config_buf(&data.buf, overlay_engine, w, h, format,
    402             buf_fd, offset, pitch, acquire_fence);
    403     ret = ioctl(fd, ADF_SIMPLE_POST_CONFIG, &data);
    404     if (ret < 0)
    405         return -errno;
    406 
    407     return (int)data.complete_fence;
    408 }
    409 
    410 int adf_interface_simple_post_v2(int fd, adf_id_t overlay_engine,
    411         __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset,
    412         __u32 pitch, int acquire_fence,
    413         enum adf_complete_fence_type complete_fence_type,
    414         int *complete_fence)
    415 {
    416     int ret;
    417     struct adf_simple_post_config_v2 data;
    418 
    419     memset(&data, 0, sizeof(data));
    420     adf_interface_simple_post_config_buf(&data.buf, overlay_engine, w, h, format,
    421             buf_fd, offset, pitch, acquire_fence);
    422     data.complete_fence_type = complete_fence_type;
    423 
    424     ret = ioctl(fd, ADF_SIMPLE_POST_CONFIG_V2, &data);
    425     if (ret < 0)
    426         return -errno;
    427 
    428     if (complete_fence)
    429         *complete_fence = data.complete_fence;
    430     else if (data.complete_fence >= 0)
    431         close(data.complete_fence);
    432 
    433     return 0;
    434 }
    435 
    436 ssize_t adf_overlay_engines(struct adf_device *dev, adf_id_t **overlay_engines)
    437 {
    438     char pattern[64];
    439 
    440     snprintf(pattern, sizeof(pattern), "adf-overlay-engine%u.%%u", dev->id);
    441     return adf_find_nodes(pattern, overlay_engines);
    442 }
    443 
    444 ssize_t adf_overlay_engines_for_interface(struct adf_device *dev,
    445         adf_id_t interface, adf_id_t **overlay_engines)
    446 {
    447     struct adf_device_data data;
    448     auto err = adf_get_device_data(dev, &data);
    449     if (err < 0)
    450         return err;
    451 
    452     std::vector<adf_id_t> ids;
    453     for (size_t i = 0; i < data.n_allowed_attachments; i++)
    454         if (data.allowed_attachments[i].interface == interface)
    455             ids.push_back(data.allowed_attachments[i].overlay_engine);
    456 
    457     return adf_id_vector_to_array(ids, overlay_engines);
    458 }
    459 
    460 static ssize_t adf_overlay_engines_filter(struct adf_device *dev,
    461         adf_id_t *in, size_t n_in, adf_id_t **out,
    462         bool (*filter)(struct adf_overlay_engine_data *data, void *cookie),
    463         void *cookie)
    464 {
    465     std::vector<adf_id_t> ids;
    466     size_t i;
    467     for (i = 0; i < n_in; i++) {
    468         int fd = adf_overlay_engine_open(dev, in[i], O_RDONLY);
    469         if (fd < 0)
    470             return fd;
    471 
    472         struct adf_overlay_engine_data data;
    473         auto ret = adf_get_overlay_engine_data(fd, &data);
    474         close(fd);
    475         if (ret < 0)
    476             return ret;
    477 
    478         if (filter(&data, cookie))
    479             ids.push_back(in[i]);
    480     }
    481 
    482     return adf_id_vector_to_array(ids, out);
    483 }
    484 
    485 struct format_filter_cookie {
    486     const __u32 *formats;
    487     size_t n_formats;
    488 };
    489 
    490 static bool adf_overlay_engine_format_filter(
    491         struct adf_overlay_engine_data *data, void *cookie)
    492 {
    493     auto c = static_cast<format_filter_cookie *>(cookie);
    494     size_t i;
    495     for (i = 0; i < data->n_supported_formats; i++) {
    496         size_t j;
    497         for (j = 0; j < c->n_formats; j++)
    498             if (data->supported_formats[i] == c->formats[j])
    499                 return true;
    500     }
    501     return false;
    502 }
    503 
    504 ssize_t adf_overlay_engines_filter_by_format(struct adf_device *dev,
    505         const __u32 *formats, size_t n_formats, adf_id_t *in, size_t n_in,
    506         adf_id_t **out)
    507 {
    508     struct format_filter_cookie cookie = { formats, n_formats };
    509     return adf_overlay_engines_filter(dev, in, n_in, out,
    510             adf_overlay_engine_format_filter, &cookie);
    511 }
    512 
    513 int adf_overlay_engine_open(struct adf_device *dev, adf_id_t id, int flags)
    514 {
    515     char filename[64];
    516 
    517     snprintf(filename, sizeof(filename),
    518             ADF_BASE_PATH "adf-overlay-engine%u.%u", dev->id, id);
    519 
    520     int fd = open(filename, flags);
    521     if (fd < 0)
    522         return -errno;
    523     return fd;
    524 }
    525 
    526 int adf_get_overlay_engine_data(int fd, struct adf_overlay_engine_data *data)
    527 {
    528     int err;
    529     int ret = 0;
    530 
    531     memset(data, 0, sizeof(*data));
    532 
    533     err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data);
    534     if (err < 0)
    535         return -errno;
    536 
    537     if (data->n_supported_formats)
    538         data->supported_formats = new __u32[data->n_supported_formats];
    539 
    540     if (data->custom_data_size)
    541       data->custom_data = new char[data->custom_data_size];
    542 
    543     err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data);
    544     if (err < 0) {
    545         ret = -errno;
    546         adf_free_overlay_engine_data(data);
    547     }
    548     return ret;
    549 }
    550 
    551 void adf_free_overlay_engine_data(struct adf_overlay_engine_data *data)
    552 {
    553     delete [] data->supported_formats;
    554     delete [] static_cast<char *>(data->custom_data);
    555 }
    556 
    557 bool adf_overlay_engine_supports_format(int fd, __u32 format)
    558 {
    559     struct adf_overlay_engine_data data;
    560     bool ret = false;
    561     size_t i;
    562 
    563     int err = adf_get_overlay_engine_data(fd, &data);
    564     if (err < 0)
    565         return false;
    566 
    567     for (i = 0; i < data.n_supported_formats; i++) {
    568         if (data.supported_formats[i] == format) {
    569             ret = true;
    570             break;
    571         }
    572     }
    573 
    574     adf_free_overlay_engine_data(&data);
    575     return ret;
    576 }
    577 
    578 int adf_set_event(int fd, enum adf_event_type type, bool enabled)
    579 {
    580     struct adf_set_event data;
    581 
    582     data.type = type;
    583     data.enabled = enabled;
    584 
    585     int err = ioctl(fd, ADF_SET_EVENT, &data);
    586     if (err < 0)
    587         return -errno;
    588     return 0;
    589 }
    590 
    591 int adf_read_event(int fd, struct adf_event **event)
    592 {
    593     struct adf_event header;
    594     struct event_with_data {
    595         struct adf_event base;
    596         uint8_t data[0];
    597     };
    598     using unique_event = std::unique_ptr<event_with_data, decltype(&free)>;
    599     size_t data_size;
    600 
    601     int err = read(fd, &header, sizeof(header));
    602     if (err < 0)
    603         return -errno;
    604     if ((size_t)err < sizeof(header))
    605         return -EIO;
    606     if (header.length < sizeof(header))
    607         return -EIO;
    608 
    609     // Again, we can't use new[] since the existing API says the caller should
    610     // free() the returned event
    611     auto event_ptr = static_cast<event_with_data *>(malloc(header.length));
    612     unique_event event_ret{event_ptr, free};
    613     if (!event_ret)
    614         return -ENOMEM;
    615     data_size = header.length - sizeof(header);
    616 
    617     memcpy(event_ret.get(), &header, sizeof(header));
    618     ssize_t read_size = read(fd, &event_ret->data, data_size);
    619     if (read_size < 0)
    620         return -errno;
    621     if ((size_t)read_size < data_size)
    622         return -EIO;
    623 
    624     *event = &event_ret.release()->base;
    625     return 0;
    626 }
    627 
    628 void adf_format_str(__u32 format, char buf[ADF_FORMAT_STR_SIZE])
    629 {
    630     buf[0] = format & 0xFF;
    631     buf[1] = (format >> 8) & 0xFF;
    632     buf[2] = (format >> 16) & 0xFF;
    633     buf[3] = (format >> 24) & 0xFF;
    634     buf[4] = '\0';
    635 }
    636 
    637 static bool adf_find_simple_post_overlay_engine(struct adf_device *dev,
    638         const __u32 *formats, size_t n_formats,
    639         adf_id_t interface, adf_id_t *overlay_engine)
    640 {
    641     adf_id_t *engs;
    642     ssize_t n_engs = adf_overlay_engines_for_interface(dev, interface, &engs);
    643 
    644     if (n_engs <= 0)
    645         return false;
    646 
    647     adf_id_t *filtered_engs;
    648     ssize_t n_filtered_engs = adf_overlay_engines_filter_by_format(dev,
    649             formats, n_formats, engs, n_engs, &filtered_engs);
    650     free(engs);
    651 
    652     if (n_filtered_engs <= 0)
    653         return false;
    654 
    655     *overlay_engine = filtered_engs[0];
    656     free(filtered_engs);
    657     return true;
    658 }
    659 
    660 static const __u32 any_rgb_format[] = {
    661     DRM_FORMAT_C8,
    662     DRM_FORMAT_RGB332,
    663     DRM_FORMAT_BGR233,
    664     DRM_FORMAT_XRGB1555,
    665     DRM_FORMAT_XBGR1555,
    666     DRM_FORMAT_RGBX5551,
    667     DRM_FORMAT_BGRX5551,
    668     DRM_FORMAT_ARGB1555,
    669     DRM_FORMAT_ABGR1555,
    670     DRM_FORMAT_RGBA5551,
    671     DRM_FORMAT_BGRA5551,
    672     DRM_FORMAT_RGB565,
    673     DRM_FORMAT_BGR565,
    674     DRM_FORMAT_RGB888,
    675     DRM_FORMAT_BGR888,
    676     DRM_FORMAT_XRGB8888,
    677     DRM_FORMAT_XBGR8888,
    678     DRM_FORMAT_RGBX8888,
    679     DRM_FORMAT_BGRX8888,
    680     DRM_FORMAT_XRGB2101010,
    681     DRM_FORMAT_XBGR2101010,
    682     DRM_FORMAT_RGBX1010102,
    683     DRM_FORMAT_BGRX1010102,
    684     DRM_FORMAT_ARGB2101010,
    685     DRM_FORMAT_ABGR2101010,
    686     DRM_FORMAT_RGBA1010102,
    687     DRM_FORMAT_BGRA1010102,
    688     DRM_FORMAT_ARGB8888,
    689     DRM_FORMAT_ABGR8888,
    690     DRM_FORMAT_RGBA8888,
    691     DRM_FORMAT_BGRA8888,
    692 };
    693 
    694 int adf_find_simple_post_configuration(struct adf_device *dev,
    695         const __u32 *formats, size_t n_formats,
    696         adf_id_t *interface, adf_id_t *overlay_engine)
    697 {
    698     adf_id_t *intfs = NULL;
    699     ssize_t n_intfs = adf_interfaces(dev, &intfs);
    700 
    701     if (n_intfs < 0)
    702         return n_intfs;
    703     else if (!n_intfs)
    704         return -ENODEV;
    705 
    706     adf_id_t *primary_intfs;
    707     ssize_t n_primary_intfs = adf_interfaces_filter_by_flag(dev,
    708             ADF_INTF_FLAG_PRIMARY, intfs, n_intfs, &primary_intfs);
    709     free(intfs);
    710 
    711     if (n_primary_intfs < 0)
    712         return n_primary_intfs;
    713     else if (!n_primary_intfs)
    714         return -ENODEV;
    715 
    716     if (!formats) {
    717         formats = any_rgb_format;
    718         n_formats = sizeof(any_rgb_format) / sizeof(any_rgb_format[0]);
    719     }
    720 
    721     bool found = false;
    722     ssize_t i = 0;
    723     for (i = 0; i < n_primary_intfs; i++) {
    724         found = adf_find_simple_post_overlay_engine(dev, formats, n_formats,
    725                 primary_intfs[i], overlay_engine);
    726         if (found) {
    727             *interface = primary_intfs[i];
    728             break;
    729         }
    730     }
    731     free(primary_intfs);
    732 
    733     if (!found)
    734         return -ENODEV;
    735 
    736     return 0;
    737 }
    738