path: root/sde-drm/drm_panel_feature_mgr.cpp

/* Copyright (c) 2021, The Linux Foundataion. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*     * Redistributions of source code must retain the above copyright
*       notice, this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above
*       copyright notice, this list of conditions and the following
*       disclaimer in the documentation and/or other materials provided
*       with the distribution.
*     * Neither the name of The Linux Foundation nor the names of its
*       contributors may be used to endorse or promote products derived
*       from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

#include <sstream>
#include <errno.h>
#include <string>
#include <drm_logger.h>
#include <cstring>
#include <regex>
#include <inttypes.h>

#include "drm_panel_feature_mgr.h"

#define __CLASS__ "DRMPanelFeatureMgr"

namespace sde_drm {

using std::map;
using std::vector;
using std::mutex;
using std::lock_guard;

static DRMPanelFeatureMgr panel_feature_mgr;

DRMPanelFeatureMgrIntf *GetPanelFeatureManagerIntf() {
  return &panel_feature_mgr;
}

void DRMPanelFeatureMgr::Init(int fd, drmModeRes* res) {
  lock_guard<mutex> lock(lock_);

  if (!res || (fd < 0)) {
    DRM_LOGE("Invalid arguments for init - fd %d and DRM resources pointer 0x%p", fd, (void *)res);
    return;
  }

  drm_res_ = res;
  dev_fd_ = fd;

  for (int i = 0; i < res->count_crtcs; i++) {
    drmModeCrtc *crtc = drmModeGetCrtc(dev_fd_, res->crtcs[i]);
    if (crtc) {
      int err = InitObjectProps(crtc->crtc_id, DRM_MODE_OBJECT_CRTC);
      if (err) {
        DRM_LOGE("Failed to get crtc props %d", crtc->crtc_id);
      }
      drmModeFreeCrtc(crtc);
    }
  }

  for (int i = 0; i < res->count_connectors; i++) {
    drmModeConnector *conn = drmModeGetConnector(dev_fd_, res->connectors[i]);
    if (conn) {
      int err = InitObjectProps(conn->connector_id, DRM_MODE_OBJECT_CONNECTOR);
      if (err) {
        DRM_LOGE("Failed to get conn %d properties", conn->connector_id);
      }
      drmModeFreeConnector(conn);
    }
  }

  drm_property_map_[kDRMPanelFeatureDsppRCInfo] = DRMProperty::DSPP_CAPABILITIES;
  drm_property_map_[kDRMPanelFeatureRCInit] = DRMProperty::DSPP_RC_MASK_V1;
  drm_prop_type_map_[kDRMPanelFeatureRCInit] = DRMPropType::kPropBlob;
  drm_prop_type_map_[kDRMPanelFeatureDsppRCInfo] = DRMPropType::kPropRange;


  feature_info_tbl_[kDRMPanelFeatureRCInit] = DRMPanelFeatureInfo {
      kDRMPanelFeatureRCInit, DRM_MODE_OBJECT_CRTC, UINT32_MAX, 1, sizeof(msm_rc_mask_cfg), 0};

  feature_info_tbl_[kDRMPanelFeatureDsppRCInfo] = DRMPanelFeatureInfo {
    kDRMPanelFeatureDsppRCInfo, DRM_MODE_OBJECT_CRTC, UINT32_MAX, 1, 64, 0};
}

void DRMPanelFeatureMgr::DeInit() {
  int ret = 0;
  for (int i = 0; i < kDRMPanelFeatureMax; i++) {
    DRMPanelFeatureID prop_id = static_cast<DRMPanelFeatureID>(i);
    if (drm_prop_blob_ids_map_[prop_id]) {
      ret = drmModeDestroyPropertyBlob(dev_fd_, drm_prop_blob_ids_map_[prop_id]);
      if (ret) {
        DRM_LOGE("failed to destroy blob for feature %d, ret = %d", prop_id, ret);
        return;
      } else {
        drm_prop_blob_ids_map_[prop_id] = 0;
      }
    }
  }
}

int DRMPanelFeatureMgr::InitObjectProps(int obj_id, int obj_type) {
  if (dev_fd_ < 0 || obj_id < 0) {
    DRM_LOGE("Invalid dev_fd_ %d or crtc_id %d", dev_fd_, obj_id);
    return -EINVAL;
  }

  drmModeObjectProperties *props =
          drmModeObjectGetProperties(dev_fd_, obj_id, obj_type);
  if (!props || !props->props || !props->prop_values) {
    DRM_LOGE("Failed to get props for obj_id:%d obj_type:%d", obj_id, obj_type);
    drmModeFreeObjectProperties(props);
    return -EINVAL;
  }

  for (uint32_t j = 0; j < props->count_props; j++) {
    drmModePropertyRes *info = drmModeGetProperty(dev_fd_, props->props[j]);
    if (!info) {
      continue;
    }

    std::string property_name(info->name);
    DRMProperty prop_enum = prop_mgr_.GetPropertyEnum(property_name);
    if (prop_enum == DRMProperty::INVALID) {
      DRM_LOGD("DRMProperty %s missing from global property mapping", info->name);
      drmModeFreeProperty(info);
      continue;
    }

    prop_mgr_.SetPropertyId(prop_enum, info->prop_id);
    drmModeFreeProperty(info);
  }

  drmModeFreeObjectProperties(props);
  return 0;
}

void DRMPanelFeatureMgr::ParseDsppCapabilities(uint32_t blob_id, std::vector<int> *values,
                                            uint32_t *size, const std::string str) {
  drmModePropertyBlobRes *blob = drmModeGetPropertyBlob(dev_fd_, blob_id);
  if (!blob) {
    DRM_LOGW("Unable to find blob for id %d", blob_id);
    return;
  }

  if (!blob->data) {
    DRM_LOGW("Invalid blob - no data for for blob-id %d", blob_id);
    return;
  }

  char *fmt_str = new char[blob->length + 1];
  std::memcpy(fmt_str, blob->data, blob->length);
  fmt_str[blob->length] = '\0';
  std::stringstream stream(fmt_str);
  std::string line = {};
  // Search for panel feature property pattern. Which is defined as rc0=1, rc1=1
  const std::regex exp(str + "(\\d+)=1");
  std::smatch sm;
  while (std::getline(stream, line)) {
    std::regex_match(line, sm, exp);
    // smatch shall include full line as a match followed by the hw block # as a match
    if (sm.size() == 2) {
      std::string tmpstr(sm[1]);
      int temp = atoi(tmpstr.c_str());  // atoi safe to use due to regex success
      values->push_back(temp);
    }
  }

  *size = sizeof(int) * values->size();
  delete[] fmt_str;
}

void DRMPanelFeatureMgr::ParseCapabilities(uint32_t blob_id, char* value, uint32_t max_len,
                                           const std::string str) {
  drmModePropertyBlobRes *blob = drmModeGetPropertyBlob(dev_fd_, blob_id);
  if (!blob) {
    DRM_LOGW("Unable to find blob for id %d", blob_id);
    return;
  }

  if (!blob->data) {
    DRM_LOGW("Invalid blob - no data for for blob-id %d", blob_id);
    return;
  }

  char *fmt_str = new char[blob->length + 1];
  std::memcpy(fmt_str, blob->data, blob->length);
  fmt_str[blob->length] = '\0';
  std::stringstream stream(fmt_str);
  std::string line = {};
  std::string val = {};
  const std::string goal = str + "=";
  while (std::getline(stream, line)) {
    if (line.find(goal) != std::string::npos) {
      val = std::string(line, goal.length());
    }
  }

  if (max_len <= val.size()) {
    DRM_LOGW("Insufficient size max_len: %d actual size: %zu", max_len, val.size());
    return;
  }
  std::copy(val.begin(), val.end(), value);
  value[val.size()] = '\0';
  delete[] fmt_str;
}

void DRMPanelFeatureMgr::GetPanelFeatureInfo(DRMPanelFeatureInfo *info) {
  lock_guard<mutex> lock(lock_);

  if (!info) {
    DRM_LOGE("Invalid input, DRMPanelFeatureInfo is NULL");
    return;
  }

  if (info->prop_id > kDRMPanelFeatureMax) {
    DRM_LOGE("Invalid feature id %d", info->prop_id);
    return;
  }

  DRMProperty prop_enum = drm_property_map_[info->prop_id];
  if (!prop_mgr_.IsPropertyAvailable(prop_enum)) {
    DRM_LOGE("Property id is not available for DRMProperty: %d feature-id: %d",
             prop_enum, info->prop_id);
    return;
  }

  // memory is not allocated by client - populate default property info
  if (!info->prop_ptr) {
    *info = feature_info_tbl_[info->prop_id];
    return;
  }

  drmModeObjectProperties *props =
          drmModeObjectGetProperties(dev_fd_, info->obj_id, info->obj_type);
  if (!props || !props->props || !props->prop_values) {
    drmModeFreeObjectProperties(props);
    DRM_LOGE("Failed to Get properties for obj: %d type:%d", info->obj_id, info->obj_type);
    return;
  }

  for (uint32_t j = 0; j < props->count_props; j++) {
    drmModePropertyRes *property = drmModeGetProperty(dev_fd_, props->props[j]);
    if (!property) {
      continue;
    }

    std::string property_name(property->name);
    if (prop_enum != prop_mgr_.GetPropertyEnum(property_name)) {
      drmModeFreeProperty(property);
      continue;
    }
    else if (info->prop_id == kDRMPanelFeatureDsppRCInfo) {
      ParseDsppCapabilities(props->prop_values[j],
              reinterpret_cast<std::vector<int> *> (info->prop_ptr), &(info->prop_size), "rc");
    } else if (drm_prop_type_map_[info->prop_id] == DRMPropType::kPropBlob) {
      drmModePropertyBlobRes *blob = drmModeGetPropertyBlob(dev_fd_, props->prop_values[j]);
      if (!blob || !blob->data || !blob->length) {
        return;
      }
      uint8_t *src_begin = reinterpret_cast<uint8_t *> (blob->data);
      uint8_t *src_end = src_begin + blob->length;
      uint8_t *dst = reinterpret_cast<uint8_t *> (info->prop_ptr);
      std::copy(src_begin, src_end, dst);
    } else {
      uint8_t *src_begin = reinterpret_cast<uint8_t *> (props->prop_values[j]);
      uint8_t *src_end = src_begin + info->prop_size;
      uint8_t *dst = reinterpret_cast<uint8_t *> (info->prop_ptr);
      std::copy(src_begin, src_end, dst);
    }

    drmModeFreeProperty(property);
  }

  drmModeFreeObjectProperties(props);
}

void DRMPanelFeatureMgr::CachePanelFeature(const DRMPanelFeatureInfo &info) {
  lock_guard<mutex> lock(lock_);

  if (info.prop_id >= kDRMPanelFeatureMax || info.obj_id == UINT32_MAX) {
    DRM_LOGE("invalid property info to set id %d value ptr %" PRIu64 , info.prop_id, info.prop_ptr);
    return;
  }

  dirty_features_[info.prop_id].first = true;
  dirty_features_[info.prop_id].second = info;
}

void DRMPanelFeatureMgr::CommitPanelFeatures(drmModeAtomicReq *req, const DRMDisplayToken &tok) {
  int ret = 0;

  lock_guard<mutex> lock(lock_);
  for (auto it = dirty_features_.begin(); it != dirty_features_.end(); it++) {
    DRMPanelFeatureInfo &info = it->second;

    if (!it->first)
        continue;

    if (info.prop_id >= kDRMPanelFeatureMax) {
      DRM_LOGE("invalid property info to set id %d value ptr %" PRIu64 , info.prop_id, info.prop_ptr);
      continue;
    }

    // Commit only features meant for the given DisplayToken
    if (tok.crtc_id != info.obj_id && tok.conn_id != info.obj_id) {
      continue;
    }

    uint32_t prop_id = prop_mgr_.GetPropertyId(drm_property_map_[info.prop_id]);
    uint64_t value = 0;

    if (DRMPropType::kPropBlob == drm_prop_type_map_[info.prop_id]) {
      uint32_t blob_id = 0;
      if (!info.prop_ptr) {
        // Reset the feature.
        ret = drmModeAtomicAddProperty(req, info.obj_id, prop_id, 0);
        if (ret < 0) {
          DRM_LOGE("failed to add property ret:%d, obj_id:%d prop_id:%u value:%" PRIu64,
                    ret, info.obj_id, prop_id, value);
          return;
        }
        continue;
      }

      ret = drmModeCreatePropertyBlob(dev_fd_, reinterpret_cast<void *> (info.prop_ptr),
              info.prop_size, &blob_id);
      if (ret || blob_id == 0) {
        DRM_LOGE("failed to create blob ret %d, id = %d prop_ptr:%" PRIu64 " prop_sz:%d",
                ret, blob_id, info.prop_ptr, info.prop_size);
        return;
      }

      if (drm_prop_blob_ids_map_[info.prop_id]) {
        ret = drmModeDestroyPropertyBlob(dev_fd_, drm_prop_blob_ids_map_[info.prop_id]);
        if (ret) {
          DRM_LOGE("failed to destroy blob for feature %d, ret = %d", info.prop_id, ret);
          return;
        }
      }
      drm_prop_blob_ids_map_[info.prop_id] = blob_id;

      value = blob_id;
    } else if (info.prop_size == sizeof(uint64_t)) {
      value = (reinterpret_cast<uint64_t *> (info.prop_ptr))[0];
    } else {
      DRM_LOGE("Unsupported property type id = %d size:%d", info.prop_id, info.prop_size);
    }

    ret = drmModeAtomicAddProperty(req, info.obj_id, prop_id, value);
    if (ret < 0) {
      DRM_LOGE("failed to add property ret:%d, obj_id:%d prop_id:%x value:%" PRIu64,
                ret, info.obj_id, prop_id, value);
    }
    *it = {};
  }
}

}  // namespace sde_drm