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

Commit d096d7e5 authored by Tao Bao's avatar Tao Bao
Browse files

minui: Cleanup GRSurfaceDrm and MinuiBackendDrm. 

This CL adds a dtor to GRSurfaceDrm that handles the resource
deallocation. It also manages MinuiBackendDrm::GRSurfaceDrms with smart
pointers.

Test: Build and boot into recovery on blueline. `Run graphics test`.
Change-Id: Iff7bbdddbc0b5ab16483d00870794fca9f832bd5
parent 47b650b5

minui/graphics_drm.cpp

+85 −114
Original line number Diff line number Diff line
@@ -24,74 +24,37 @@ 
#include <sys/types.h>

#include <unistd.h>



#include <memory>



#include <android-base/macros.h>

#include <android-base/stringprintf.h>

#include <android-base/unique_fd.h>

#include <drm_fourcc.h>

#include <xf86drm.h>

#include <xf86drmMode.h>



#include "minui/minui.h"



#define ARRAY_SIZE(A) (sizeof(A)/sizeof(*(A)))



MinuiBackendDrm::MinuiBackendDrm()

    : GRSurfaceDrms(), main_monitor_crtc(nullptr), main_monitor_connector(nullptr), drm_fd(-1) {}



void MinuiBackendDrm::DrmDisableCrtc(int drm_fd, drmModeCrtc* crtc) {

  if (crtc) {

    drmModeSetCrtc(drm_fd, crtc->crtc_id,

                   0,         // fb_id

                   0, 0,      // x,y

                   nullptr,   // connectors

                   0,         // connector_count

                   nullptr);  // mode

  }

}



int MinuiBackendDrm::DrmEnableCrtc(int drm_fd, drmModeCrtc* crtc, GRSurfaceDrm* surface) {

  int ret = drmModeSetCrtc(drm_fd, crtc->crtc_id, surface->fb_id, 0, 0,  // x,y

                           &main_monitor_connector->connector_id,

                           1,  // connector_count

                           &main_monitor_crtc->mode);



  if (ret) {

    printf("drmModeSetCrtc failed ret=%d\n", ret);

GRSurfaceDrm::~GRSurfaceDrm() {

  if (mmapped_buffer_) {

    munmap(mmapped_buffer_, row_bytes * height);

  }



  return ret;

}



void MinuiBackendDrm::Blank(bool blank) {

  if (blank) {

    DrmDisableCrtc(drm_fd, main_monitor_crtc);

  } else {

    DrmEnableCrtc(drm_fd, main_monitor_crtc, GRSurfaceDrms[current_buffer]);

  if (fb_id) {

    if (drmModeRmFB(drm_fd_, fb_id) != 0) {

      perror("Failed to drmModeRmFB");

      // Falling through to free other resources.

    }

  }



void MinuiBackendDrm::DrmDestroySurface(GRSurfaceDrm* surface) {

  if (!surface) return;



  if (surface->mmapped_buffer_) {

    munmap(surface->mmapped_buffer_, surface->row_bytes * surface->height);

  }



  if (surface->fb_id) {

    int ret = drmModeRmFB(drm_fd, surface->fb_id);

    if (ret) {

      printf("drmModeRmFB failed ret=%d\n", ret);

    }

  }



  if (surface->handle) {

  if (handle) {

    drm_gem_close gem_close = {};

    gem_close.handle = surface->handle;

    gem_close.handle = handle;



    int ret = drmIoctl(drm_fd, DRM_IOCTL_GEM_CLOSE, &gem_close);

    if (ret) {

      printf("DRM_IOCTL_GEM_CLOSE failed ret=%d\n", ret);

    if (drmIoctl(drm_fd_, DRM_IOCTL_GEM_CLOSE, &gem_close) != 0) {

      perror("Failed to DRM_IOCTL_GEM_CLOSE");

    }

  }



  delete surface;

}



static int drm_format_to_bpp(uint32_t format) {
@@ -111,10 +74,7 @@ static int drm_format_to_bpp(uint32_t format) { 
  }

}



GRSurfaceDrm* MinuiBackendDrm::DrmCreateSurface(int width, int height) {

  GRSurfaceDrm* surface = new GRSurfaceDrm;

  *surface = {};



std::unique_ptr<GRSurfaceDrm> GRSurfaceDrm::Create(int drm_fd, int width, int height) {

  uint32_t format;

  PixelFormat pixel_format = gr_pixel_format();

  // PixelFormat comes in byte order, whereas DRM_FORMAT_* uses little-endian
@@ -137,12 +97,12 @@ GRSurfaceDrm* MinuiBackendDrm::DrmCreateSurface(int width, int height) { 
  create_dumb.bpp = drm_format_to_bpp(format);

  create_dumb.flags = 0;



  int ret = drmIoctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);

  if (ret) {

    printf("DRM_IOCTL_MODE_CREATE_DUMB failed ret=%d\n", ret);

    DrmDestroySurface(surface);

  if (drmIoctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb) != 0) {

    perror("Failed to DRM_IOCTL_MODE_CREATE_DUMB");

    return nullptr;

  }



  std::unique_ptr<GRSurfaceDrm> surface = std::make_unique<GRSurfaceDrm>(drm_fd);

  surface->handle = create_dumb.handle;



  uint32_t handles[4], pitches[4], offsets[4];
@@ -151,20 +111,16 @@ GRSurfaceDrm* MinuiBackendDrm::DrmCreateSurface(int width, int height) { 
  pitches[0] = create_dumb.pitch;

  offsets[0] = 0;



  ret =

      drmModeAddFB2(drm_fd, width, height, format, handles, pitches, offsets, &(surface->fb_id), 0);

  if (ret) {

    printf("drmModeAddFB2 failed ret=%d\n", ret);

    DrmDestroySurface(surface);

  if (drmModeAddFB2(drm_fd, width, height, format, handles, pitches, offsets, &surface->fb_id, 0) !=

      0) {

    perror("Failed to drmModeAddFB2");

    return nullptr;

  }



  drm_mode_map_dumb map_dumb = {};

  map_dumb.handle = create_dumb.handle;

  ret = drmIoctl(drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb);

  if (ret) {

    printf("DRM_IOCTL_MODE_MAP_DUMB failed ret=%d\n", ret);

    DrmDestroySurface(surface);

  if (drmIoctl(drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb) != 0) {

    perror("Failed to DRM_IOCTL_MODE_MAP_DUMB");

    return nullptr;

  }
@@ -175,14 +131,44 @@ GRSurfaceDrm* MinuiBackendDrm::DrmCreateSurface(int width, int height) { 
  auto mmapped = mmap(nullptr, surface->height * surface->row_bytes, PROT_READ | PROT_WRITE,

                      MAP_SHARED, drm_fd, map_dumb.offset);

  if (mmapped == MAP_FAILED) {

    perror("mmap() failed");

    DrmDestroySurface(surface);

    perror("Failed to mmap()");

    return nullptr;

  }

  surface->mmapped_buffer_ = static_cast<uint8_t*>(mmapped);

  return surface;

}



void MinuiBackendDrm::DrmDisableCrtc(int drm_fd, drmModeCrtc* crtc) {

  if (crtc) {

    drmModeSetCrtc(drm_fd, crtc->crtc_id,

                   0,         // fb_id

                   0, 0,      // x,y

                   nullptr,   // connectors

                   0,         // connector_count

                   nullptr);  // mode

  }

}



bool MinuiBackendDrm::DrmEnableCrtc(int drm_fd, drmModeCrtc* crtc,

                                    const std::unique_ptr<GRSurfaceDrm>& surface) {

  if (drmModeSetCrtc(drm_fd, crtc->crtc_id, surface->fb_id, 0, 0,  // x,y

                     &main_monitor_connector->connector_id,

                     1,  // connector_count

                     &main_monitor_crtc->mode) != 0) {

    perror("Failed to drmModeSetCrtc");

    return false;

  }

  return true;

}



void MinuiBackendDrm::Blank(bool blank) {

  if (blank) {

    DrmDisableCrtc(drm_fd, main_monitor_crtc);

  } else {

    DrmEnableCrtc(drm_fd, main_monitor_crtc, GRSurfaceDrms[current_buffer]);

  }

}



static drmModeCrtc* find_crtc_for_connector(int fd, drmModeRes* resources,

                                            drmModeConnector* connector) {

  // Find the encoder. If we already have one, just use it.
@@ -264,7 +250,7 @@ drmModeConnector* MinuiBackendDrm::FindMainMonitor(int fd, drmModeRes* resources 
  do {

    main_monitor_connector = find_used_connector_by_type(fd, resources, kConnectorPriority[i]);

    i++;

  } while (!main_monitor_connector && i < ARRAY_SIZE(kConnectorPriority));

  } while (!main_monitor_connector && i < arraysize(kConnectorPriority));



  /* If we didn't find a connector, grab the first one that is connected. */

  if (!main_monitor_connector) {
@@ -298,60 +284,53 @@ void MinuiBackendDrm::DisableNonMainCrtcs(int fd, drmModeRes* resources, drmMode 


GRSurface* MinuiBackendDrm::Init() {

  drmModeRes* res = nullptr;

  drm_fd = -1;



  /* Consider DRM devices in order. */

  for (int i = 0; i < DRM_MAX_MINOR; i++) {

    char* dev_name;

    int ret = asprintf(&dev_name, DRM_DEV_NAME, DRM_DIR_NAME, i);

    if (ret < 0) continue;



    drm_fd = open(dev_name, O_RDWR, 0);

    free(dev_name);

    if (drm_fd < 0) continue;

    auto dev_name = android::base::StringPrintf(DRM_DEV_NAME, DRM_DIR_NAME, i);

    android::base::unique_fd fd(open(dev_name.c_str(), O_RDWR));

    if (fd == -1) continue;



    uint64_t cap = 0;

    /* We need dumb buffers. */

    ret = drmGetCap(drm_fd, DRM_CAP_DUMB_BUFFER, &cap);

    if (ret || cap == 0) {

      close(drm_fd);

    if (uint64_t cap = 0; drmGetCap(fd.get(), DRM_CAP_DUMB_BUFFER, &cap) != 0 || cap == 0) {

      continue;

    }



    res = drmModeGetResources(drm_fd);

    res = drmModeGetResources(fd.get());

    if (!res) {

      close(drm_fd);

      continue;

    }



    /* Use this device if it has at least one connected monitor. */

    if (res->count_crtcs > 0 && res->count_connectors > 0) {

      if (find_first_connected_connector(drm_fd, res)) break;

      if (find_first_connected_connector(fd.get(), res)) {

        drm_fd = fd.release();

        break;

      }

    }



    drmModeFreeResources(res);

    close(drm_fd);

    res = nullptr;

  }



  if (drm_fd < 0 || res == nullptr) {

    perror("cannot find/open a drm device");

  if (drm_fd == -1 || res == nullptr) {

    perror("Failed to find/open a drm device");

    return nullptr;

  }



  uint32_t selected_mode;

  main_monitor_connector = FindMainMonitor(drm_fd, res, &selected_mode);



  if (!main_monitor_connector) {

    printf("main_monitor_connector not found\n");

    fprintf(stderr, "Failed to find main_monitor_connector\n");

    drmModeFreeResources(res);

    close(drm_fd);

    return nullptr;

  }



  main_monitor_crtc = find_crtc_for_connector(drm_fd, res, main_monitor_connector);



  if (!main_monitor_crtc) {

    printf("main_monitor_crtc not found\n");

    fprintf(stderr, "Failed to find main_monitor_crtc\n");

    drmModeFreeResources(res);

    close(drm_fd);

    return nullptr;
@@ -366,21 +345,20 @@ GRSurface* MinuiBackendDrm::Init() { 


  drmModeFreeResources(res);



  GRSurfaceDrms[0] = DrmCreateSurface(width, height);

  GRSurfaceDrms[1] = DrmCreateSurface(width, height);

  GRSurfaceDrms[0] = GRSurfaceDrm::Create(drm_fd, width, height);

  GRSurfaceDrms[1] = GRSurfaceDrm::Create(drm_fd, width, height);

  if (!GRSurfaceDrms[0] || !GRSurfaceDrms[1]) {

    // GRSurfaceDrms and drm_fd should be freed in d'tor.

    return nullptr;

  }



  current_buffer = 0;



  // We will likely encounter errors in the backend functions (i.e. Flip) if EnableCrtc fails.

  if (DrmEnableCrtc(drm_fd, main_monitor_crtc, GRSurfaceDrms[1]) != 0) {

  if (!DrmEnableCrtc(drm_fd, main_monitor_crtc, GRSurfaceDrms[1])) {

    return nullptr;

  }



  return GRSurfaceDrms[0];

  return GRSurfaceDrms[0].get();

}



static void page_flip_complete(__unused int fd,
@@ -393,12 +371,9 @@ static void page_flip_complete(__unused int fd, 


GRSurface* MinuiBackendDrm::Flip() {

  bool ongoing_flip = true;



  int ret = drmModePageFlip(drm_fd, main_monitor_crtc->crtc_id,

                            GRSurfaceDrms[current_buffer]->fb_id,

                            DRM_MODE_PAGE_FLIP_EVENT, &ongoing_flip);

  if (ret < 0) {

    printf("drmModePageFlip failed ret=%d\n", ret);

  if (drmModePageFlip(drm_fd, main_monitor_crtc->crtc_id, GRSurfaceDrms[current_buffer]->fb_id,

                      DRM_MODE_PAGE_FLIP_EVENT, &ongoing_flip) != 0) {

    perror("Failed to drmModePageFlip");

    return nullptr;

  }
@@ -408,9 +383,8 @@ GRSurface* MinuiBackendDrm::Flip() { 
      .events = POLLIN

    };



    ret = poll(&fds, 1, -1);

    if (ret == -1 || !(fds.revents & POLLIN)) {

      printf("poll() failed on drm fd\n");

    if (poll(&fds, 1, -1) == -1 || !(fds.revents & POLLIN)) {

      perror("Failed to poll() on drm fd");

      break;

    }
@@ -419,21 +393,18 @@ GRSurface* MinuiBackendDrm::Flip() { 
      .page_flip_handler = page_flip_complete

    };



    ret = drmHandleEvent(drm_fd, &evctx);

    if (ret != 0) {

      printf("drmHandleEvent failed ret=%d\n", ret);

    if (drmHandleEvent(drm_fd, &evctx) != 0) {

      perror("Failed to drmHandleEvent");

      break;

    }

  }



  current_buffer = 1 - current_buffer;

  return GRSurfaceDrms[current_buffer];

  return GRSurfaceDrms[current_buffer].get();

}



MinuiBackendDrm::~MinuiBackendDrm() {

  DrmDisableCrtc(drm_fd, main_monitor_crtc);

  DrmDestroySurface(GRSurfaceDrms[0]);

  DrmDestroySurface(GRSurfaceDrms[1]);

  drmModeFreeCrtc(main_monitor_crtc);

  drmModeFreeConnector(main_monitor_connector);

  close(drm_fd);

minui/graphics_drm.h

+24 −12
Original line number Diff line number Diff line
@@ -18,6 +18,9 @@ 


#include <stdint.h>



#include <memory>



#include <android-base/macros.h>

#include <xf86drmMode.h>



#include "graphics.h"
@@ -25,6 +28,12 @@ 


class GRSurfaceDrm : public GRSurface {

 public:

  explicit GRSurfaceDrm(int drm_fd) : drm_fd_(drm_fd) {}

  ~GRSurfaceDrm() override;



  // Creates a GRSurfaceDrm instance.

  static std::unique_ptr<GRSurfaceDrm> Create(int drm_fd, int width, int height);



  uint8_t* data() override {

    return mmapped_buffer_;

  }
@@ -32,30 +41,33 @@ class GRSurfaceDrm : public GRSurface { 
 private:

  friend class MinuiBackendDrm;



  uint32_t fb_id;

  uint32_t handle;

  const int drm_fd_;



  uint32_t fb_id{ 0 };

  uint32_t handle{ 0 };

  uint8_t* mmapped_buffer_{ nullptr };



  DISALLOW_COPY_AND_ASSIGN(GRSurfaceDrm);

};



class MinuiBackendDrm : public MinuiBackend {

 public:

  MinuiBackendDrm() = default;

  ~MinuiBackendDrm() override;



  GRSurface* Init() override;

  GRSurface* Flip() override;

  void Blank(bool) override;

  ~MinuiBackendDrm() override;

  MinuiBackendDrm();



 private:

  void DrmDisableCrtc(int drm_fd, drmModeCrtc* crtc);

  int DrmEnableCrtc(int drm_fd, drmModeCrtc* crtc, GRSurfaceDrm* surface);

  GRSurfaceDrm* DrmCreateSurface(int width, int height);

  void DrmDestroySurface(GRSurfaceDrm* surface);

  bool DrmEnableCrtc(int drm_fd, drmModeCrtc* crtc, const std::unique_ptr<GRSurfaceDrm>& surface);

  void DisableNonMainCrtcs(int fd, drmModeRes* resources, drmModeCrtc* main_crtc);

  drmModeConnector* FindMainMonitor(int fd, drmModeRes* resources, uint32_t* mode_index);



  GRSurfaceDrm* GRSurfaceDrms[2];

  int current_buffer;

  drmModeCrtc* main_monitor_crtc;

  drmModeConnector* main_monitor_connector;

  int drm_fd;

  std::unique_ptr<GRSurfaceDrm> GRSurfaceDrms[2];

  int current_buffer{ 0 };

  drmModeCrtc* main_monitor_crtc{ nullptr };

  drmModeConnector* main_monitor_connector{ nullptr };

  int drm_fd{ -1 };

};