static int hwc_query(struct hwc_composer_device_1 * /* dev */,
int what, int* /* value */)
{
(void) what;
ALOGTRACE("what = %d", what);
return -EINVAL;
}
bool TngGrallocBufferMapper::gttMap(void *vaddr,
uint32_t size,
uint32_t gttAlign,
int *offset)
{
struct psb_gtt_mapping_arg arg;
bool ret;
ALOGTRACE("vaddr = %p, size = %d", vaddr, size);
if (!vaddr || !size || !offset) {
VLOGTRACE("invalid parameters");
return false;
}
arg.type = PSB_GTT_MAP_TYPE_VIRTUAL;
arg.page_align = gttAlign;
arg.vaddr = (uint32_t)vaddr;
arg.size = size;
Drm *drm = Hwcomposer::getInstance().getDrm();
ret = drm->writeReadIoctl(DRM_PSB_GTT_MAP, &arg, sizeof(arg));
if (ret == false) {
ELOGTRACE("gtt mapping failed");
return false;
}
VLOGTRACE("offset = %#x", arg.offset_pages);
*offset = arg.offset_pages;
return true;
}
bool DisplayPlane::assignToDevice(int disp)
{
RETURN_FALSE_IF_NOT_INIT();
ALOGTRACE("disp = %d", disp);
mDevice = disp;
Drm *drm = Hwcomposer::getInstance().getDrm();
if (!drm->getModeInfo(mDevice, mModeInfo)) {
ELOGTRACE("failed to get mode info");
}
mPanelOrientation = drm->getPanelOrientation(mDevice);
mForceScaling = DisplayQuery::forceFbScaling(disp);
drm->getDisplayResolution(disp, mDisplayWidth, mDisplayHeight);
if (mForceScaling) {
mModeInfo.hdisplay = mDisplayWidth;
mModeInfo.vdisplay = mDisplayHeight;
mPosition.x = 0;
mPosition.y = 0;
mPosition.w = mDisplayWidth;
mPosition.h = mDisplayHeight;
}
mDisplayCrop.x = 0;
mDisplayCrop.y = 0;
mDisplayCrop.w = mDisplayWidth;
mDisplayCrop.h = mDisplayHeight;
return true;
}
static int hwc_device_open(const struct hw_module_t* module,
const char* name,
struct hw_device_t** device)
{
if (!name) {
ELOGTRACE("invalid name.");
return -EINVAL;
}
ALOGTRACE("open device %s", name);
if (strcmp(name, HWC_HARDWARE_COMPOSER) != 0) {
ELOGTRACE("try to open unknown HWComposer %s", name);
return -EINVAL;
}
Hwcomposer& hwc = Hwcomposer::getInstance();
// initialize our state here
if (hwc.initialize() == false) {
ELOGTRACE("failed to intialize HWComposer");
Hwcomposer::releaseInstance();
return -EINVAL;
}
// initialize the procs
hwc.hwc_composer_device_1_t::common.tag = HARDWARE_DEVICE_TAG;
hwc.hwc_composer_device_1_t::common.module =
const_cast<hw_module_t*>(module);
hwc.hwc_composer_device_1_t::common.close = hwc_device_close;
hwc.hwc_composer_device_1_t::prepare = hwc_prepare;
hwc.hwc_composer_device_1_t::set = hwc_set;
hwc.hwc_composer_device_1_t::dump = hwc_dump;
hwc.hwc_composer_device_1_t::registerProcs = hwc_registerProcs;
hwc.hwc_composer_device_1_t::query = hwc_query;
hwc.hwc_composer_device_1_t::eventControl = hwc_eventControl;
hwc.hwc_composer_device_1_t::getDisplayConfigs = hwc_getDisplayConfigs;
hwc.hwc_composer_device_1_t::getDisplayAttributes = hwc_getDisplayAttributes;
// This is used to hack FBO switch flush issue in SurfaceFlinger.
hwc.hwc_composer_device_1_t::reserved_proc[0] = (void*)hwc_compositionComplete;
hwc.hwc_composer_device_1_t::common.version = HWC_DEVICE_API_VERSION_1_4;
hwc.hwc_composer_device_1_t::setPowerMode = hwc_setPowerMode;
hwc.hwc_composer_device_1_t::getActiveConfig = hwc_getActiveConfig;
hwc.hwc_composer_device_1_t::setActiveConfig = hwc_setActiveConfig;
// Todo: add hwc_setCursorPositionAsync after supporting patches
hwc.hwc_composer_device_1_t::setCursorPositionAsync = NULL;
*device = &hwc.hwc_composer_device_1_t::common;
return 0;
}
void DisplayPlane::setTransform(int trans)
{
ALOGTRACE("transform = %d", trans);
if (mTransform == trans) {
return;
}
mTransform = trans;
mUpdateMasks |= PLANE_TRANSFORM_CHANGED;
}
bool Hwcomposer::vsyncControl(int disp, int enabled)
{
RETURN_FALSE_IF_NOT_INIT();
ALOGTRACE("disp = %d, enabled = %d", disp, enabled);
if (disp != 0) {
ELOGTRACE("invalid disp %d", disp);
// return false;
}
// return device->vsyncControl(enabled ? true : false);
return true;
}
void DisplayPlane::setSourceCrop(int x, int y, int w, int h)
{
ALOGTRACE("Source crop = %d, %d - %dx%d", x, y, w, h);
if (mSrcCrop.x != x || mSrcCrop.y != y ||
mSrcCrop.w != w || mSrcCrop.h != h) {
mUpdateMasks |= PLANE_SOURCE_CROP_CHANGED;
mSrcCrop.x = x;
mSrcCrop.y = y;
mSrcCrop.w = w;
mSrcCrop.h = h;
}
}
void DisplayPlane::setPlaneAlpha(uint8_t alpha, uint32_t blending)
{
ALOGTRACE("plane alpha = 0x%x", alpha);
if (mPlaneAlpha != alpha) {
mPlaneAlpha = alpha;
mUpdateMasks |= PLANE_BUFFER_CHANGED;
}
if (mBlending != blending) {
mBlending = blending;
mUpdateMasks |= PLANE_BUFFER_CHANGED;
}
}
void DisplayPlane::setPosition(int x, int y, int w, int h)
{
ALOGTRACE("Position = %d, %d - %dx%d", x, y, w, h);
if (mForceScaling) {
// set in assignToDevice
return;
}
if (mPosition.x != x || mPosition.y != y ||
mPosition.w != w || mPosition.h != h) {
mUpdateMasks |= PLANE_POSITION_CHANGED;
mPosition.x = x;
mPosition.y = y;
mPosition.w = w;
mPosition.h = h;
}
}
bool Hwcomposer::blank(int disp, int blank)
{
RETURN_FALSE_IF_NOT_INIT();
ALOGTRACE("disp = %d, blank = %d", disp, blank);
// handle one display, lol...
if (disp != 0) {
ELOGTRACE("invalid disp %d", disp);
// return false;
}
// if the device isn't created yet, create it
if(!mInitialized) {
initialize();
}
// blank the device...
//return device->blank(blank ? true : false);
return true;
}
bool Hwcomposer::blank(int disp, int blank)
{
RETURN_FALSE_IF_NOT_INIT();
ALOGTRACE("disp = %d, blank = %d", disp, blank);
if (disp < 0 || disp >= IDisplayDevice::DEVICE_COUNT) {
ELOGTRACE("invalid disp %d", disp);
return false;
}
if (disp >= (int) mDisplayDevices.size()) {
return false;
}
IDisplayDevice *device = mDisplayDevices.itemAt(disp);
if (!device) {
ELOGTRACE("no device found");
return false;
}
return device->blank(blank ? true : false);
}
bool Hwcomposer::vsyncControl(int disp, int enabled)
{
RETURN_FALSE_IF_NOT_INIT();
ALOGTRACE("disp = %d, enabled = %d", disp, enabled);
if (disp < 0 || disp >= IDisplayDevice::DEVICE_COUNT) {
ELOGTRACE("invalid disp %d", disp);
return false;
}
if (disp >= (int) mDisplayDevices.size()) {
return false;
}
IDisplayDevice *device = mDisplayDevices.itemAt(disp);
if (!device) {
ELOGTRACE("no device found");
return false;
}
return device->vsyncControl(enabled ? true : false);
}
bool TngGrallocBufferMapper::gttUnmap(void *vaddr)
{
struct psb_gtt_mapping_arg arg;
bool ret;
ALOGTRACE("vaddr = %p", vaddr);
if (!vaddr) {
ELOGTRACE("invalid parameter");
return false;
}
arg.type = PSB_GTT_MAP_TYPE_VIRTUAL;
arg.vaddr = (uint32_t)vaddr;
Drm *drm = Hwcomposer::getInstance().getDrm();
ret = drm->writeIoctl(DRM_PSB_GTT_UNMAP, &arg, sizeof(arg));
if (ret == false) {
ELOGTRACE("gtt unmapping failed");
return false;
}
return true;
}
bool DisplayPlane::setDataBuffer(uint32_t handle)
{
DataBuffer *buffer;
BufferMapper *mapper;
ssize_t index;
bool ret;
bool isCompression;
BufferManager *bm = Hwcomposer::getInstance().getBufferManager();
RETURN_FALSE_IF_NOT_INIT();
ALOGTRACE("handle = %#x", handle);
if (!handle) {
WLOGTRACE("invalid buffer handle");
return false;
}
// do not need to update the buffer handle
if (mCurrentDataBuffer != handle)
mUpdateMasks |= PLANE_BUFFER_CHANGED;
// if no update then do Not need set data buffer
if (!mUpdateMasks)
return true;
buffer = bm->lockDataBuffer(handle);
if (!buffer) {
ELOGTRACE("failed to get buffer");
return false;
}
mIsProtectedBuffer = GraphicBuffer::isProtectedBuffer((GraphicBuffer*)buffer);
isCompression = GraphicBuffer::isCompressionBuffer((GraphicBuffer*)buffer);
// map buffer if it's not in cache
index = mDataBuffers.indexOfKey(buffer->getKey());
if (index < 0) {
VLOGTRACE("unmapped buffer, mapping...");
mapper = mapBuffer(buffer);
if (!mapper) {
ELOGTRACE("failed to map buffer %#x", handle);
bm->unlockDataBuffer(buffer);
return false;
}
} else {
VLOGTRACE("got mapper in saved data buffers and update source Crop");
mapper = mDataBuffers.valueAt(index);
}
// always update source crop to mapper
mapper->setCrop(mSrcCrop.x, mSrcCrop.y, mSrcCrop.w, mSrcCrop.h);
mapper->setIsCompression(isCompression);
// unlock buffer after getting mapper
bm->unlockDataBuffer(buffer);
buffer = NULL;
ret = setDataBuffer(*mapper);
if (ret) {
mCurrentDataBuffer = handle;
// update active buffers
updateActiveBuffers(mapper);
}
return ret;
}
