Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8f0e21b2 authored by Tao Bao's avatar Tao Bao
Browse files

minui: Clean up graphics_adf.cpp. 

Remove unneeded header includes. Switch a few memset() to '= {}' style.
Otherwise mostly cosmetic changes like reformatting.

Test: 'Run graphics test' on N9 (which is an ADF device).

Change-Id: If008af18ddae9521f53216b581d882d5eed76d41
parent 95bcbfdd

minui/graphics_adf.cpp

+156 −191
Original line number Diff line number Diff line
@@ -16,14 +16,10 @@ 


#include <errno.h>

#include <fcntl.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>



#include <sys/cdefs.h>

#include <sys/mman.h>

#include <unistd.h>



#include <adf/adf.h>

#include <sync/sync.h>
@@ -55,21 +51,20 @@ static GRSurface* adf_flip(minui_backend *backend); 
static void adf_blank(minui_backend* backend, bool blank);



static int adf_surface_init(adf_pdata* pdata, drm_mode_modeinfo* mode, adf_surface_pdata* surf) {

    memset(surf, 0, sizeof(*surf));



  *surf = {};

  surf->fence_fd = -1;

    surf->fd = adf_interface_simple_buffer_alloc(pdata->intf_fd, mode->hdisplay,

            mode->vdisplay, pdata->format, &surf->offset, &surf->pitch);

    if (surf->fd < 0)

  surf->fd = adf_interface_simple_buffer_alloc(pdata->intf_fd, mode->hdisplay, mode->vdisplay,

                                               pdata->format, &surf->offset, &surf->pitch);

  if (surf->fd < 0) {

    return surf->fd;

  }



  surf->base.width = mode->hdisplay;

  surf->base.height = mode->vdisplay;

  surf->base.row_bytes = surf->pitch;

  surf->base.pixel_bytes = (pdata->format == DRM_FORMAT_RGB565) ? 2 : 4;



    surf->base.data = static_cast<uint8_t*>(mmap(NULL,

                                                 surf->pitch * surf->base.height, PROT_WRITE,

  surf->base.data = static_cast<uint8_t*>(mmap(nullptr, surf->pitch * surf->base.height, PROT_WRITE,

                                               MAP_SHARED, surf->fd, surf->offset));

  if (surf->base.data == MAP_FAILED) {

    close(surf->fd);
@@ -79,16 +74,12 @@ static int adf_surface_init(adf_pdata *pdata, drm_mode_modeinfo *mode, adf_surfa 
  return 0;

}



static int adf_interface_init(adf_pdata *pdata)

{

static int adf_interface_init(adf_pdata* pdata) {

  adf_interface_data intf_data;

    int ret = 0;

    int err;



    err = adf_get_interface_data(pdata->intf_fd, &intf_data);

    if (err < 0)

        return err;

  int err = adf_get_interface_data(pdata->intf_fd, &intf_data);

  if (err < 0) return err;



  int ret = 0;

  err = adf_surface_init(pdata, &intf_data.current_mode, &pdata->surfaces[0]);

  if (err < 0) {

    fprintf(stderr, "allocating surface 0 failed: %s\n", strerror(-err));
@@ -96,11 +87,10 @@ static int adf_interface_init(adf_pdata *pdata) 
    goto done;

  }



    err = adf_surface_init(pdata, &intf_data.current_mode,

            &pdata->surfaces[1]);

  err = adf_surface_init(pdata, &intf_data.current_mode, &pdata->surfaces[1]);

  if (err < 0) {

    fprintf(stderr, "allocating surface 1 failed: %s\n", strerror(-err));

        memset(&pdata->surfaces[1], 0, sizeof(pdata->surfaces[1]));

    pdata->surfaces[1] = {};

    pdata->n_surfaces = 1;

  } else {

    pdata->n_surfaces = 2;
@@ -111,24 +101,16 @@ done: 
  return ret;

}



static int adf_device_init(adf_pdata *pdata, adf_device *dev)

{

static int adf_device_init(adf_pdata* pdata, adf_device* dev) {

  adf_id_t intf_id;

    int intf_fd;

    int err;



    err = adf_find_simple_post_configuration(dev, &pdata->format, 1, &intf_id,

            &pdata->eng_id);

    if (err < 0)

        return err;

  int err = adf_find_simple_post_configuration(dev, &pdata->format, 1, &intf_id, &pdata->eng_id);

  if (err < 0) return err;



  err = adf_device_attach(dev, pdata->eng_id, intf_id);

    if (err < 0 && err != -EALREADY)

        return err;

  if (err < 0 && err != -EALREADY) return err;



  pdata->intf_fd = adf_interface_open(dev, intf_id, O_RDWR);

    if (pdata->intf_fd < 0)

        return pdata->intf_fd;

  if (pdata->intf_fd < 0) return pdata->intf_fd;



  err = adf_interface_init(pdata);

  if (err < 0) {
@@ -139,12 +121,8 @@ static int adf_device_init(adf_pdata *pdata, adf_device *dev) 
  return err;

}



static GRSurface* adf_init(minui_backend *backend)

{

    adf_pdata *pdata = (adf_pdata *)backend;

    adf_id_t *dev_ids = NULL;

    ssize_t n_dev_ids, i;

    GRSurface* ret;

static GRSurface* adf_init(minui_backend* backend) {

  adf_pdata* pdata = reinterpret_cast<adf_pdata*>(backend);



#if defined(RECOVERY_ABGR)

  pdata->format = DRM_FORMAT_ABGR8888;
@@ -156,40 +134,36 @@ static GRSurface* adf_init(minui_backend *backend) 
  pdata->format = DRM_FORMAT_RGB565;

#endif



    n_dev_ids = adf_devices(&dev_ids);

  adf_id_t* dev_ids = nullptr;

  ssize_t n_dev_ids = adf_devices(&dev_ids);

  if (n_dev_ids == 0) {

        return NULL;

    return nullptr;

  } else if (n_dev_ids < 0) {

        fprintf(stderr, "enumerating adf devices failed: %s\n",

                strerror(-n_dev_ids));

        return NULL;

    fprintf(stderr, "enumerating adf devices failed: %s\n", strerror(-n_dev_ids));

    return nullptr;

  }



  pdata->intf_fd = -1;



    for (i = 0; i < n_dev_ids && pdata->intf_fd < 0; i++) {



  for (ssize_t i = 0; i < n_dev_ids && pdata->intf_fd < 0; i++) {

    int err = adf_device_open(dev_ids[i], O_RDWR, &pdata->dev);

    if (err < 0) {

            fprintf(stderr, "opening adf device %u failed: %s\n", dev_ids[i],

                    strerror(-err));

      fprintf(stderr, "opening adf device %u failed: %s\n", dev_ids[i], strerror(-err));

      continue;

    }



    err = adf_device_init(pdata, &pdata->dev);

    if (err < 0) {

            fprintf(stderr, "initializing adf device %u failed: %s\n",

                    dev_ids[i], strerror(-err));

      fprintf(stderr, "initializing adf device %u failed: %s\n", dev_ids[i], strerror(-err));

      adf_device_close(&pdata->dev);

    }

  }



  free(dev_ids);



    if (pdata->intf_fd < 0)

        return NULL;

  if (pdata->intf_fd < 0) return nullptr;



    ret = adf_flip(backend);

  GRSurface* ret = adf_flip(backend);



  adf_blank(backend, true);

  adf_blank(backend, false);
@@ -197,77 +171,68 @@ static GRSurface* adf_init(minui_backend *backend) 
  return ret;

}



static void adf_sync(adf_surface_pdata *surf)

{

    unsigned int warningTimeout = 3000;

static void adf_sync(adf_surface_pdata* surf) {

  static constexpr unsigned int warningTimeout = 3000;



    if (surf == NULL)

        return;

  if (surf == nullptr) return;



  if (surf->fence_fd >= 0) {

    int err = sync_wait(surf->fence_fd, warningTimeout);

        if (err < 0)

    if (err < 0) {

      perror("adf sync fence wait error\n");

    }



    close(surf->fence_fd);

    surf->fence_fd = -1;

  }

}



static GRSurface* adf_flip(minui_backend *backend)

{

    adf_pdata *pdata = (adf_pdata *)backend;

static GRSurface* adf_flip(minui_backend* backend) {

  adf_pdata* pdata = reinterpret_cast<adf_pdata*>(backend);

  adf_surface_pdata* surf = &pdata->surfaces[pdata->current_surface];



    int fence_fd = adf_interface_simple_post(pdata->intf_fd, pdata->eng_id,

            surf->base.width, surf->base.height, pdata->format, surf->fd,

            surf->offset, surf->pitch, -1);

    if (fence_fd >= 0)

        surf->fence_fd = fence_fd;

  int fence_fd =

      adf_interface_simple_post(pdata->intf_fd, pdata->eng_id, surf->base.width, surf->base.height,

                                pdata->format, surf->fd, surf->offset, surf->pitch, -1);

  if (fence_fd >= 0) surf->fence_fd = fence_fd;



  pdata->current_surface = (pdata->current_surface + 1) % pdata->n_surfaces;

  adf_sync(&pdata->surfaces[pdata->current_surface]);

  return &pdata->surfaces[pdata->current_surface].base;

}



static void adf_blank(minui_backend *backend, bool blank)

{

    adf_pdata *pdata = (adf_pdata *)backend;

    adf_interface_blank(pdata->intf_fd,

            blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON);

static void adf_blank(minui_backend* backend, bool blank) {

  adf_pdata* pdata = reinterpret_cast<adf_pdata*>(backend);

  adf_interface_blank(pdata->intf_fd, blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON);

}



static void adf_surface_destroy(adf_surface_pdata *surf)

{

static void adf_surface_destroy(adf_surface_pdata* surf) {

  munmap(surf->base.data, surf->pitch * surf->base.height);

  close(surf->fence_fd);

  close(surf->fd);

}



static void adf_exit(minui_backend *backend)

{

    adf_pdata *pdata = (adf_pdata *)backend;

    unsigned int i;



static void adf_exit(minui_backend* backend) {

  adf_pdata* pdata = reinterpret_cast<adf_pdata*>(backend);

  adf_device_close(&pdata->dev);

    for (i = 0; i < pdata->n_surfaces; i++)

  for (unsigned int i = 0; i < pdata->n_surfaces; i++) {

    adf_surface_destroy(&pdata->surfaces[i]);

    if (pdata->intf_fd >= 0)

        close(pdata->intf_fd);

  }

  if (pdata->intf_fd >= 0) close(pdata->intf_fd);

  free(pdata);

}



minui_backend *open_adf()

{

minui_backend* open_adf() {

  adf_pdata* pdata = static_cast<adf_pdata*>(calloc(1, sizeof(*pdata)));

  if (!pdata) {

    perror("allocating adf backend failed");

        return NULL;

    return nullptr;

  }



  pdata->base.init = adf_init;

  pdata->base.flip = adf_flip;

  pdata->base.blank = adf_blank;

  pdata->base.exit = adf_exit;



  return &pdata->base;

}