2 * Copyright (C) 2015 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
18 #define LOG_TAG "hwcomposer-drm"
20 #include "drm_hwcomposer.h"
21 #include "drmresources.h"
23 #include "virtualcompositorworker.h"
24 #include "vsyncworker.h"
35 #include <sys/param.h>
36 #include <sys/resource.h>
38 #include <xf86drmMode.h>
40 #include <cutils/log.h>
41 #include <cutils/properties.h>
42 #include <hardware/hardware.h>
43 #include <hardware/hwcomposer.h>
45 #include <sync/sync.h>
46 #include <utils/Trace.h>
48 #define UM_PER_INCH 25400
49 #define HWC_FB_BUFFERS 3
53 class DummySwSyncTimeline {
56 int ret = timeline_fd_.Set(sw_sync_timeline_create());
62 UniqueFd CreateDummyFence() {
63 int ret = sw_sync_fence_create(timeline_fd_.get(), "dummy fence",
66 ALOGE("Failed to create dummy fence %d", ret);
72 ret = sw_sync_timeline_inc(timeline_fd_.get(), 1);
74 ALOGE("Failed to increment dummy sync timeline %d", ret);
83 UniqueFd timeline_fd_;
87 struct CheckedOutputFd {
88 CheckedOutputFd(int *fd, const char *description,
89 DummySwSyncTimeline &timeline)
90 : fd_(fd), description_(description), timeline_(timeline) {
92 CheckedOutputFd(CheckedOutputFd &&rhs)
93 : description_(rhs.description_), timeline_(rhs.timeline_) {
94 std::swap(fd_, rhs.fd_);
97 CheckedOutputFd &operator=(const CheckedOutputFd &rhs) = delete;
106 *fd_ = timeline_.CreateDummyFence().Release();
109 ALOGE("Failed to fill %s (%p == %d) before destruction",
110 description_.c_str(), fd_, *fd_);
115 std::string description_;
116 DummySwSyncTimeline &timeline_;
119 typedef struct hwc_drm_display {
120 struct hwc_context_t *ctx;
123 std::vector<uint32_t> config_ids;
125 VSyncWorker vsync_worker;
128 struct hwc_context_t {
129 // map of display:hwc_drm_display_t
130 typedef std::map<int, hwc_drm_display_t> DisplayMap;
131 typedef DisplayMap::iterator DisplayMapIter;
133 hwc_context_t() : procs(NULL), importer(NULL), use_framebuffer_target(false) {
137 virtual_compositor_worker.Exit();
141 hwc_composer_device_1_t device;
142 hwc_procs_t const *procs;
147 const gralloc_module_t *gralloc;
148 DummySwSyncTimeline dummy_timeline;
149 bool use_framebuffer_target;
150 VirtualCompositorWorker virtual_compositor_worker;
153 static native_handle_t *dup_buffer_handle(buffer_handle_t handle) {
154 native_handle_t *new_handle =
155 native_handle_create(handle->numFds, handle->numInts);
156 if (new_handle == NULL)
159 const int *old_data = handle->data;
160 int *new_data = new_handle->data;
161 for (int i = 0; i < handle->numFds; i++) {
162 *new_data = dup(*old_data);
166 memcpy(new_data, old_data, sizeof(int) * handle->numInts);
171 static void free_buffer_handle(native_handle_t *handle) {
172 int ret = native_handle_close(handle);
174 ALOGE("Failed to close native handle %d", ret);
175 ret = native_handle_delete(handle);
177 ALOGE("Failed to delete native handle %d", ret);
180 OutputFd &OutputFd::operator=(OutputFd &&rhs) {
182 std::swap(fd_, rhs.fd_);
185 ALOGE("Failed to fill OutputFd %p before assignment", fd_);
194 const hwc_drm_bo *DrmHwcBuffer::operator->() const {
195 if (importer_ == NULL) {
196 ALOGE("Access of non-existent BO");
203 void DrmHwcBuffer::Clear() {
204 if (importer_ != NULL) {
205 importer_->ReleaseBuffer(&bo_);
210 int DrmHwcBuffer::ImportBuffer(buffer_handle_t handle, Importer *importer) {
213 int ret = importer->ImportBuffer(handle, &tmp_bo);
217 if (importer_ != NULL) {
218 importer_->ReleaseBuffer(&bo_);
221 importer_ = importer;
228 int DrmHwcNativeHandle::CopyBufferHandle(buffer_handle_t handle,
229 const gralloc_module_t *gralloc) {
230 native_handle_t *handle_copy = dup_buffer_handle(handle);
231 if (handle_copy == NULL) {
232 ALOGE("Failed to duplicate handle");
236 int ret = gralloc->registerBuffer(gralloc, handle_copy);
238 ALOGE("Failed to register buffer handle %d", ret);
239 free_buffer_handle(handle_copy);
246 handle_ = handle_copy;
251 DrmHwcNativeHandle::~DrmHwcNativeHandle() {
255 void DrmHwcNativeHandle::Clear() {
256 if (gralloc_ != NULL && handle_ != NULL) {
257 gralloc_->unregisterBuffer(gralloc_, handle_);
258 free_buffer_handle(handle_);
264 int DrmHwcLayer::InitFromHwcLayer(hwc_layer_1_t *sf_layer, Importer *importer,
265 const gralloc_module_t *gralloc) {
266 sf_handle = sf_layer->handle;
267 alpha = sf_layer->planeAlpha;
269 source_crop = DrmHwcRect<float>(
270 sf_layer->sourceCropf.left, sf_layer->sourceCropf.top,
271 sf_layer->sourceCropf.right, sf_layer->sourceCropf.bottom);
272 display_frame = DrmHwcRect<int>(
273 sf_layer->displayFrame.left, sf_layer->displayFrame.top,
274 sf_layer->displayFrame.right, sf_layer->displayFrame.bottom);
276 switch (sf_layer->transform) {
278 transform = DrmHwcTransform::kIdentity;
280 case HWC_TRANSFORM_FLIP_H:
281 transform = DrmHwcTransform::kFlipH;
283 case HWC_TRANSFORM_FLIP_V:
284 transform = DrmHwcTransform::kFlipV;
286 case HWC_TRANSFORM_ROT_90:
287 transform = DrmHwcTransform::kRotate90;
289 case HWC_TRANSFORM_ROT_180:
290 transform = DrmHwcTransform::kRotate180;
292 case HWC_TRANSFORM_ROT_270:
293 transform = DrmHwcTransform::kRotate270;
296 ALOGE("Invalid transform in hwc_layer_1_t %d", sf_layer->transform);
300 switch (sf_layer->blending) {
301 case HWC_BLENDING_NONE:
302 blending = DrmHwcBlending::kNone;
304 case HWC_BLENDING_PREMULT:
305 blending = DrmHwcBlending::kPreMult;
307 case HWC_BLENDING_COVERAGE:
308 blending = DrmHwcBlending::kCoverage;
311 ALOGE("Invalid blending in hwc_layer_1_t %d", sf_layer->blending);
315 int ret = buffer.ImportBuffer(sf_layer->handle, importer);
319 ret = handle.CopyBufferHandle(sf_layer->handle, gralloc);
326 static void hwc_dump(struct hwc_composer_device_1 *dev, char *buff,
328 struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
329 std::ostringstream out;
331 ctx->drm.compositor()->Dump(&out);
332 std::string out_str = out.str();
333 strncpy(buff, out_str.c_str(), std::min((size_t)buff_len, out_str.length()));
336 static int hwc_prepare(hwc_composer_device_1_t *dev, size_t num_displays,
337 hwc_display_contents_1_t **display_contents) {
338 struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
340 char use_framebuffer_target[PROPERTY_VALUE_MAX];
341 property_get("hwc.drm.use_framebuffer_target", use_framebuffer_target, "0");
342 bool new_use_framebuffer_target = atoi(use_framebuffer_target);
343 if (ctx->use_framebuffer_target != new_use_framebuffer_target)
344 ALOGW("Starting to %s HWC_FRAMEBUFFER_TARGET",
345 new_use_framebuffer_target ? "use" : "not use");
346 ctx->use_framebuffer_target = new_use_framebuffer_target;
348 for (int i = 0; i < (int)num_displays; ++i) {
349 if (!display_contents[i])
352 bool use_framebuffer_target = ctx->use_framebuffer_target;
353 if (i == HWC_DISPLAY_VIRTUAL) {
354 use_framebuffer_target = true;
356 DrmCrtc *crtc = ctx->drm.GetCrtcForDisplay(i);
358 ALOGE("No crtc for display %d", i);
363 int num_layers = display_contents[i]->numHwLayers;
364 for (int j = 0; j < num_layers; j++) {
365 hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
367 if (!use_framebuffer_target) {
368 if (layer->compositionType == HWC_FRAMEBUFFER)
369 layer->compositionType = HWC_OVERLAY;
371 switch (layer->compositionType) {
375 case HWC_CURSOR_OVERLAY:
376 layer->compositionType = HWC_FRAMEBUFFER;
386 static void hwc_add_layer_to_retire_fence(
387 hwc_layer_1_t *layer, hwc_display_contents_1_t *display_contents) {
388 if (layer->releaseFenceFd < 0)
391 if (display_contents->retireFenceFd >= 0) {
392 int old_retire_fence = display_contents->retireFenceFd;
393 display_contents->retireFenceFd =
394 sync_merge("dc_retire", old_retire_fence, layer->releaseFenceFd);
395 close(old_retire_fence);
397 display_contents->retireFenceFd = dup(layer->releaseFenceFd);
401 static int hwc_set(hwc_composer_device_1_t *dev, size_t num_displays,
402 hwc_display_contents_1_t **sf_display_contents) {
404 struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
407 std::vector<CheckedOutputFd> checked_output_fences;
408 std::vector<DrmHwcDisplayContents> displays_contents;
409 std::vector<DrmCompositionDisplayLayersMap> layers_map;
410 std::vector<std::vector<size_t>> layers_indices;
411 displays_contents.reserve(num_displays);
412 // layers_map.reserve(num_displays);
413 layers_indices.reserve(num_displays);
415 // Phase one does nothing that would cause errors. Only take ownership of FDs.
416 for (size_t i = 0; i < num_displays; ++i) {
417 hwc_display_contents_1_t *dc = sf_display_contents[i];
418 displays_contents.emplace_back();
419 DrmHwcDisplayContents &display_contents = displays_contents.back();
420 layers_indices.emplace_back();
421 std::vector<size_t> &indices_to_composite = layers_indices.back();
423 if (!sf_display_contents[i])
426 if (i == HWC_DISPLAY_VIRTUAL) {
427 ctx->virtual_compositor_worker.QueueComposite(dc);
431 std::ostringstream display_index_formatter;
432 display_index_formatter << "retire fence for display " << i;
433 std::string display_fence_description(display_index_formatter.str());
434 checked_output_fences.emplace_back(&dc->retireFenceFd,
435 display_fence_description.c_str(),
436 ctx->dummy_timeline);
437 display_contents.retire_fence = OutputFd(&dc->retireFenceFd);
439 size_t num_dc_layers = dc->numHwLayers;
440 int framebuffer_target_index = -1;
441 for (size_t j = 0; j < num_dc_layers; ++j) {
442 hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
444 display_contents.layers.emplace_back();
445 DrmHwcLayer &layer = display_contents.layers.back();
447 if (sf_layer->flags & HWC_SKIP_LAYER)
450 if (!ctx->use_framebuffer_target) {
451 if (sf_layer->compositionType == HWC_OVERLAY)
452 indices_to_composite.push_back(j);
453 if (sf_layer->compositionType == HWC_FRAMEBUFFER_TARGET)
454 framebuffer_target_index = j;
456 if (sf_layer->compositionType == HWC_FRAMEBUFFER_TARGET)
457 indices_to_composite.push_back(j);
460 layer.acquire_fence.Set(sf_layer->acquireFenceFd);
461 sf_layer->acquireFenceFd = -1;
463 std::ostringstream layer_fence_formatter;
464 layer_fence_formatter << "release fence for layer " << j << " of display "
466 std::string layer_fence_description(layer_fence_formatter.str());
467 checked_output_fences.emplace_back(&sf_layer->releaseFenceFd,
468 layer_fence_description.c_str(),
469 ctx->dummy_timeline);
470 layer.release_fence = OutputFd(&sf_layer->releaseFenceFd);
473 if (ctx->use_framebuffer_target) {
474 if (indices_to_composite.size() != 1) {
475 ALOGE("Expected 1 (got %d) layer with HWC_FRAMEBUFFER_TARGET",
476 indices_to_composite.size());
480 if (indices_to_composite.empty() && framebuffer_target_index >= 0) {
481 hwc_layer_1_t *sf_layer = &dc->hwLayers[framebuffer_target_index];
482 if (!sf_layer->handle || (sf_layer->flags & HWC_SKIP_LAYER)) {
484 "Expected valid layer with HWC_FRAMEBUFFER_TARGET when all "
485 "HWC_OVERLAY layers are skipped.");
488 indices_to_composite.push_back(framebuffer_target_index);
496 for (size_t i = 0; i < num_displays; ++i) {
497 hwc_display_contents_1_t *dc = sf_display_contents[i];
498 DrmHwcDisplayContents &display_contents = displays_contents[i];
499 if (!sf_display_contents[i])
502 layers_map.emplace_back();
503 DrmCompositionDisplayLayersMap &map = layers_map.back();
505 std::vector<size_t> &indices_to_composite = layers_indices[i];
506 for (size_t j : indices_to_composite) {
507 hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
509 DrmHwcLayer &layer = display_contents.layers[j];
511 ret = layer.InitFromHwcLayer(sf_layer, ctx->importer, ctx->gralloc);
513 ALOGE("Failed to init composition from layer %d", ret);
516 map.layers.emplace_back(std::move(layer));
520 std::unique_ptr<DrmComposition> composition(
521 ctx->drm.compositor()->CreateComposition(ctx->importer));
523 ALOGE("Drm composition init failed");
527 ret = composition->SetLayers(layers_map.size(), layers_map.data());
532 ret = ctx->drm.compositor()->QueueComposition(std::move(composition));
537 for (size_t i = 0; i < num_displays; ++i) {
538 hwc_display_contents_1_t *dc = sf_display_contents[i];
542 size_t num_dc_layers = dc->numHwLayers;
543 for (size_t j = 0; j < num_dc_layers; ++j) {
544 hwc_layer_1_t *layer = &dc->hwLayers[j];
545 if (layer->flags & HWC_SKIP_LAYER)
547 hwc_add_layer_to_retire_fence(layer, dc);
551 composition.reset(NULL);
556 static int hwc_event_control(struct hwc_composer_device_1 *dev, int display,
557 int event, int enabled) {
558 if (event != HWC_EVENT_VSYNC || (enabled != 0 && enabled != 1))
561 struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
562 hwc_drm_display_t *hd = &ctx->displays[display];
563 return hd->vsync_worker.VSyncControl(enabled);
566 static int hwc_set_power_mode(struct hwc_composer_device_1 *dev, int display,
568 struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
570 uint64_t dpmsValue = 0;
572 case HWC_POWER_MODE_OFF:
573 dpmsValue = DRM_MODE_DPMS_OFF;
576 /* We can't support dozing right now, so go full on */
577 case HWC_POWER_MODE_DOZE:
578 case HWC_POWER_MODE_DOZE_SUSPEND:
579 case HWC_POWER_MODE_NORMAL:
580 dpmsValue = DRM_MODE_DPMS_ON;
583 return ctx->drm.SetDpmsMode(display, dpmsValue);
586 static int hwc_query(struct hwc_composer_device_1 * /* dev */, int what,
589 case HWC_BACKGROUND_LAYER_SUPPORTED:
590 *value = 0; /* TODO: We should do this */
592 case HWC_VSYNC_PERIOD:
593 ALOGW("Query for deprecated vsync value, returning 60Hz");
594 *value = 1000 * 1000 * 1000 / 60;
596 case HWC_DISPLAY_TYPES_SUPPORTED:
597 *value = HWC_DISPLAY_PRIMARY | HWC_DISPLAY_EXTERNAL | HWC_DISPLAY_VIRTUAL;
603 static void hwc_register_procs(struct hwc_composer_device_1 *dev,
604 hwc_procs_t const *procs) {
605 struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
609 for (hwc_context_t::DisplayMapIter iter = ctx->displays.begin();
610 iter != ctx->displays.end(); ++iter) {
611 iter->second.vsync_worker.SetProcs(procs);
615 static int hwc_get_display_configs(struct hwc_composer_device_1 *dev,
616 int display, uint32_t *configs,
617 size_t *num_configs) {
621 struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
622 hwc_drm_display_t *hd = &ctx->displays[display];
623 hd->config_ids.clear();
625 DrmConnector *connector = ctx->drm.GetConnectorForDisplay(display);
627 ALOGE("Failed to get connector for display %d", display);
631 int ret = connector->UpdateModes();
633 ALOGE("Failed to update display modes %d", ret);
637 for (DrmConnector::ModeIter iter = connector->begin_modes();
638 iter != connector->end_modes(); ++iter) {
639 size_t idx = hd->config_ids.size();
640 if (idx == *num_configs)
642 hd->config_ids.push_back(iter->id());
643 configs[idx] = iter->id();
645 *num_configs = hd->config_ids.size();
646 return *num_configs == 0 ? -1 : 0;
649 static int hwc_get_display_attributes(struct hwc_composer_device_1 *dev,
650 int display, uint32_t config,
651 const uint32_t *attributes,
653 struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
654 DrmConnector *c = ctx->drm.GetConnectorForDisplay(display);
656 ALOGE("Failed to get DrmConnector for display %d", display);
660 for (DrmConnector::ModeIter iter = c->begin_modes(); iter != c->end_modes();
662 if (iter->id() == config) {
667 if (mode.id() == 0) {
668 ALOGE("Failed to find active mode for display %d", display);
672 uint32_t mm_width = c->mm_width();
673 uint32_t mm_height = c->mm_height();
674 for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; ++i) {
675 switch (attributes[i]) {
676 case HWC_DISPLAY_VSYNC_PERIOD:
677 values[i] = 1000 * 1000 * 1000 / mode.v_refresh();
679 case HWC_DISPLAY_WIDTH:
680 values[i] = mode.h_display();
682 case HWC_DISPLAY_HEIGHT:
683 values[i] = mode.v_display();
685 case HWC_DISPLAY_DPI_X:
686 /* Dots per 1000 inches */
687 values[i] = mm_width ? (mode.h_display() * UM_PER_INCH) / mm_width : 0;
689 case HWC_DISPLAY_DPI_Y:
690 /* Dots per 1000 inches */
692 mm_height ? (mode.v_display() * UM_PER_INCH) / mm_height : 0;
699 static int hwc_get_active_config(struct hwc_composer_device_1 *dev,
701 struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
702 DrmConnector *c = ctx->drm.GetConnectorForDisplay(display);
704 ALOGE("Failed to get DrmConnector for display %d", display);
708 DrmMode mode = c->active_mode();
709 hwc_drm_display_t *hd = &ctx->displays[display];
710 for (size_t i = 0; i < hd->config_ids.size(); ++i) {
711 if (hd->config_ids[i] == mode.id())
717 static int hwc_set_active_config(struct hwc_composer_device_1 *dev, int display,
719 struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
720 hwc_drm_display_t *hd = &ctx->displays[display];
721 if (index >= (int)hd->config_ids.size()) {
722 ALOGE("Invalid config index %d passed in", index);
726 DrmConnector *c = ctx->drm.GetConnectorForDisplay(display);
728 ALOGE("Failed to get connector for display %d", display);
732 for (DrmConnector::ModeIter iter = c->begin_modes(); iter != c->end_modes();
734 if (iter->id() == hd->config_ids[index]) {
739 if (mode.id() != hd->config_ids[index]) {
740 ALOGE("Could not find active mode for %d/%d", index, hd->config_ids[index]);
743 int ret = ctx->drm.SetDisplayActiveMode(display, mode);
745 ALOGE("Failed to set active config %d", ret);
751 static int hwc_device_close(struct hw_device_t *dev) {
752 struct hwc_context_t *ctx = (struct hwc_context_t *)dev;
758 * TODO: This function sets the active config to the first one in the list. This
759 * should be fixed such that it selects the preferred mode for the display, or
760 * some other, saner, method of choosing the config.
762 static int hwc_set_initial_config(hwc_drm_display_t *hd) {
764 size_t num_configs = 1;
765 int ret = hwc_get_display_configs(&hd->ctx->device, hd->display, &config,
767 if (ret || !num_configs)
770 ret = hwc_set_active_config(&hd->ctx->device, hd->display, 0);
772 ALOGE("Failed to set active config d=%d ret=%d", hd->display, ret);
779 static int hwc_initialize_display(struct hwc_context_t *ctx, int display) {
780 hwc_drm_display_t *hd = &ctx->displays[display];
782 hd->display = display;
784 int ret = hwc_set_initial_config(hd);
786 ALOGE("Failed to set initial config for d=%d ret=%d", display, ret);
790 ret = hd->vsync_worker.Init(&ctx->drm, display);
792 ALOGE("Failed to create event worker for display %d %d\n", display, ret);
799 static int hwc_enumerate_displays(struct hwc_context_t *ctx) {
801 for (DrmResources::ConnectorIter c = ctx->drm.begin_connectors();
802 c != ctx->drm.end_connectors(); ++c) {
803 ret = hwc_initialize_display(ctx, (*c)->display());
805 ALOGE("Failed to initialize display %d", (*c)->display());
810 ret = ctx->virtual_compositor_worker.Init();
812 ALOGE("Failed to initialize virtual compositor worker");
818 static int hwc_device_open(const struct hw_module_t *module, const char *name,
819 struct hw_device_t **dev) {
820 if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
821 ALOGE("Invalid module name- %s", name);
825 struct hwc_context_t *ctx = new hwc_context_t();
827 ALOGE("Failed to allocate hwc context");
831 int ret = ctx->drm.Init();
833 ALOGE("Can't initialize Drm object %d", ret);
838 ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
839 (const hw_module_t **)&ctx->gralloc);
841 ALOGE("Failed to open gralloc module %d", ret);
846 ret = ctx->dummy_timeline.Init();
848 ALOGE("Failed to create dummy sw sync timeline %d", ret);
852 ctx->importer = Importer::CreateInstance(&ctx->drm);
853 if (!ctx->importer) {
854 ALOGE("Failed to create importer instance");
859 ret = hwc_enumerate_displays(ctx);
861 ALOGE("Failed to enumerate displays: %s", strerror(ret));
866 ctx->device.common.tag = HARDWARE_DEVICE_TAG;
867 ctx->device.common.version = HWC_DEVICE_API_VERSION_1_4;
868 ctx->device.common.module = const_cast<hw_module_t *>(module);
869 ctx->device.common.close = hwc_device_close;
871 ctx->device.dump = hwc_dump;
872 ctx->device.prepare = hwc_prepare;
873 ctx->device.set = hwc_set;
874 ctx->device.eventControl = hwc_event_control;
875 ctx->device.setPowerMode = hwc_set_power_mode;
876 ctx->device.query = hwc_query;
877 ctx->device.registerProcs = hwc_register_procs;
878 ctx->device.getDisplayConfigs = hwc_get_display_configs;
879 ctx->device.getDisplayAttributes = hwc_get_display_attributes;
880 ctx->device.getActiveConfig = hwc_get_active_config;
881 ctx->device.setActiveConfig = hwc_set_active_config;
882 ctx->device.setCursorPositionAsync = NULL; /* TODO: Add cursor */
884 *dev = &ctx->device.common;
890 static struct hw_module_methods_t hwc_module_methods = {
891 open : android::hwc_device_open
894 hwc_module_t HAL_MODULE_INFO_SYM = {
896 tag : HARDWARE_MODULE_TAG,
899 id : HWC_HARDWARE_MODULE_ID,
900 name : "DRM hwcomposer module",
901 author : "The Android Open Source Project",
902 methods : &hwc_module_methods,