API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 9th, 2015
204
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 28.81 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. * Copyright (C) 2010 The Android Open Source Project
  3. * Copyright (C) 2012-2013, The Linux Foundation. All rights reserved.
  4. *
  5. * Not a Contribution, Apache license notifications and license are retained
  6. * for attribution purposes only.
  7. *
  8. * Licensed under the Apache License, Version 2.0 (the "License");
  9. * you may not use this file except in compliance with the License.
  10. * You may obtain a copy of the License at
  11. *
  12. * http://www.apache.org/licenses/LICENSE-2.0
  13. *
  14. * Unless required by applicable law or agreed to in writing, software
  15. * distributed under the License is distributed on an "AS IS" BASIS,
  16. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17. * See the License for the specific language governing permissions and
  18. * limitations under the License.
  19. */
  20. #define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL)
  21. #include <fcntl.h>
  22. #include <errno.h>
  23.  
  24. #include <cutils/log.h>
  25. #include <cutils/atomic.h>
  26. #include <EGL/egl.h>
  27. #include <utils/Trace.h>
  28. #include <sys/ioctl.h>
  29. #include <overlay.h>
  30. #include <overlayRotator.h>
  31. #include <mdp_version.h>
  32. #include "hwc_utils.h"
  33. #include "hwc_fbupdate.h"
  34. #include "hwc_mdpcomp.h"
  35. #include "hwc_dump_layers.h"
  36. #include "external.h"
  37. #include "hwc_copybit.h"
  38. #include "profiler.h"
  39.  
  40. using namespace qhwc;
  41. using namespace overlay;
  42.  
  43. #define VSYNC_DEBUG 0
  44. #define BLANK_DEBUG 1
  45.  
  46. static int hwc_device_open(const struct hw_module_t* module,
  47. const char* name,
  48. struct hw_device_t** device);
  49.  
  50. static struct hw_module_methods_t hwc_module_methods = {
  51. open: hwc_device_open
  52. };
  53.  
  54. static void reset_panel(struct hwc_composer_device_1* dev);
  55.  
  56. hwc_module_t HAL_MODULE_INFO_SYM = {
  57. common: {
  58. tag: HARDWARE_MODULE_TAG,
  59. version_major: 2,
  60. version_minor: 0,
  61. id: HWC_HARDWARE_MODULE_ID,
  62. name: "Qualcomm Hardware Composer Module",
  63. author: "CodeAurora Forum",
  64. methods: &hwc_module_methods,
  65. dso: 0,
  66. reserved: {0},
  67. }
  68. };
  69.  
  70. /* In case of non-hybrid WFD session, we are fooling SF by piggybacking on
  71. * HDMI display ID for virtual. This helper is needed to differentiate their
  72. * paths in HAL.
  73. * TODO: Not needed once we have WFD client working on top of Google API's */
  74.  
  75. static int getDpyforExternalDisplay(hwc_context_t *ctx, int dpy) {
  76. if(dpy == HWC_DISPLAY_EXTERNAL && ctx->mVirtualonExtActive)
  77. return HWC_DISPLAY_VIRTUAL;
  78. return dpy;
  79. }
  80.  
  81. /*
  82. * Save callback functions registered to HWC
  83. */
  84. static void hwc_registerProcs(struct hwc_composer_device_1* dev,
  85. hwc_procs_t const* procs)
  86. {
  87. ALOGI("%s", __FUNCTION__);
  88. hwc_context_t* ctx = (hwc_context_t*)(dev);
  89. if(!ctx) {
  90. ALOGE("%s: Invalid context", __FUNCTION__);
  91. return;
  92. }
  93. ctx->proc = procs;
  94.  
  95. // Now that we have the functions needed, kick off
  96. // the uevent & vsync threads
  97. init_uevent_thread(ctx);
  98. init_vsync_thread(ctx);
  99. }
  100.  
  101. //Helper
  102. static void reset(hwc_context_t *ctx, int numDisplays,
  103. hwc_display_contents_1_t** displays) {
  104. ctx->isPaddingRound = false;
  105. memset(ctx->listStats, 0, sizeof(ctx->listStats));
  106. for(int i = 0; i < HWC_NUM_DISPLAY_TYPES; i++) {
  107. hwc_display_contents_1_t *list = displays[i];
  108. // XXX:SurfaceFlinger no longer guarantees that this
  109. // value is reset on every prepare. However, for the layer
  110. // cache we need to reset it.
  111. // We can probably rethink that later on
  112. if (LIKELY(list && list->numHwLayers > 0)) {
  113. for(uint32_t j = 0; j < list->numHwLayers; j++) {
  114. if(list->hwLayers[j].compositionType != HWC_FRAMEBUFFER_TARGET)
  115. list->hwLayers[j].compositionType = HWC_FRAMEBUFFER;
  116. }
  117.  
  118. if((ctx->mPrevHwLayerCount[i] == 1) and (list->numHwLayers > 1)) {
  119. /* If the previous cycle for dpy 'i' has 0 AppLayers and the
  120. * current cycle has atleast 1 AppLayer, padding round needs
  121. * to be invoked on current cycle to free up the resources.
  122. */
  123. ctx->isPaddingRound = true;
  124. }
  125. ctx->mPrevHwLayerCount[i] = list->numHwLayers;
  126. } else {
  127. ctx->mPrevHwLayerCount[i] = 0;
  128. }
  129.  
  130. if(ctx->mFBUpdate[i])
  131. ctx->mFBUpdate[i]->reset();
  132. if(ctx->mCopyBit[i])
  133. ctx->mCopyBit[i]->reset();
  134. if(ctx->mLayerRotMap[i])
  135. ctx->mLayerRotMap[i]->reset();
  136. }
  137.  
  138. }
  139.  
  140. //clear prev layer prop flags and realloc for current frame
  141. static void reset_layer_prop(hwc_context_t* ctx, int dpy, int numAppLayers) {
  142. if(ctx->layerProp[dpy]) {
  143. delete[] ctx->layerProp[dpy];
  144. ctx->layerProp[dpy] = NULL;
  145. }
  146. ctx->layerProp[dpy] = new LayerProp[numAppLayers];
  147. }
  148.  
  149.  
  150. static int hwc_prepare_primary(hwc_composer_device_1 *dev,
  151. hwc_display_contents_1_t *list) {
  152. hwc_context_t* ctx = (hwc_context_t*)(dev);
  153. const int dpy = HWC_DISPLAY_PRIMARY;
  154. int ret = -1;
  155. if(UNLIKELY(!ctx->mBasePipeSetup) &&
  156. qdutils::MDPVersion::getInstance().getMDPVersion() >= qdutils::MDP_V4_2)
  157. setupBasePipe(ctx);
  158. if (LIKELY(list && list->numHwLayers > 1) &&
  159. ctx->dpyAttr[dpy].isActive) {
  160. reset_layer_prop(ctx, dpy, list->numHwLayers - 1);
  161. setListStats(ctx, list, dpy);
  162. if((ret = ctx->mMDPComp[dpy]->prepare(ctx, list)) < 0) {
  163. const int fbZ = 0;
  164. ctx->mFBUpdate[dpy]->prepare(ctx, list, fbZ);
  165. }
  166. #ifdef USE_COPYBIT_COMPOSITION_FALLBACK
  167. // Use Copybit, when MDP comp fails
  168. // (only for 8960 which has dedicated 2D core)
  169. if((ret < 1) && ctx->mCopyBit[dpy])
  170. ctx->mCopyBit[dpy]->prepare(ctx, list, dpy);
  171. #endif
  172. }
  173. return 0;
  174. }
  175.  
  176. static int hwc_prepare_external(hwc_composer_device_1 *dev,
  177. hwc_display_contents_1_t *list) {
  178. hwc_context_t* ctx = (hwc_context_t*)(dev);
  179. const int dpy = HWC_DISPLAY_EXTERNAL;
  180. int ret = -1;
  181.  
  182. if (LIKELY(list && list->numHwLayers > 1) &&
  183. ctx->dpyAttr[dpy].isActive &&
  184. ctx->dpyAttr[dpy].connected) {
  185. reset_layer_prop(ctx, dpy, list->numHwLayers - 1);
  186. if(!ctx->dpyAttr[dpy].isPause) {
  187. ctx->dpyAttr[dpy].isConfiguring = false;
  188. setListStats(ctx, list, dpy);
  189. if((ret = ctx->mMDPComp[dpy]->prepare(ctx, list)) < 0) {
  190. const int fbZ = 0;
  191. ctx->mFBUpdate[dpy]->prepare(ctx, list, fbZ);
  192. }
  193. #ifdef USE_COPYBIT_COMPOSITION_FALLBACK
  194. // Use Copybit, when MDP comp fails
  195. // (only for 8960 which has dedicated 2D core)
  196. if((ret < 1) && ctx->mCopyBit[dpy] &&
  197. !ctx->listStats[dpy].isDisplayAnimating)
  198. ctx->mCopyBit[dpy]->prepare(ctx, list, dpy);
  199. #endif
  200. if(ctx->listStats[dpy].isDisplayAnimating) {
  201. // Mark all app layers as HWC_OVERLAY for external during
  202. // animation, so that SF doesnt draw it on FB
  203. for(int i = 0 ;i < ctx->listStats[dpy].numAppLayers; i++) {
  204. hwc_layer_1_t *layer = &list->hwLayers[i];
  205. layer->compositionType = HWC_OVERLAY;
  206. }
  207. }
  208. } else {
  209. /* External Display is in Pause state.
  210. * Mark all application layers as OVERLAY so that
  211. * GPU will not compose.
  212. */
  213. for(size_t i = 0 ;i < (size_t)(list->numHwLayers - 1); i++) {
  214. hwc_layer_1_t *layer = &list->hwLayers[i];
  215. layer->compositionType = HWC_OVERLAY;
  216. }
  217. }
  218. }
  219. return 0;
  220. }
  221.  
  222. static int hwc_prepare_virtual(hwc_composer_device_1 *dev,
  223. hwc_display_contents_1_t *list) {
  224.  
  225. hwc_context_t* ctx = (hwc_context_t*)(dev);
  226. const int dpy = HWC_DISPLAY_VIRTUAL;
  227.  
  228. if (LIKELY(list && list->numHwLayers > 1) &&
  229. ctx->dpyAttr[dpy].isActive &&
  230. ctx->dpyAttr[dpy].connected) {
  231. reset_layer_prop(ctx, dpy, list->numHwLayers - 1);
  232. if(!ctx->dpyAttr[dpy].isPause) {
  233. ctx->dpyAttr[dpy].isConfiguring = false;
  234. setListStats(ctx, list, dpy);
  235. if(ctx->mMDPComp[dpy]->prepare(ctx, list) < 0) {
  236. const int fbZ = 0;
  237. ctx->mFBUpdate[dpy]->prepare(ctx, list, fbZ);
  238. }
  239.  
  240. if(ctx->listStats[dpy].isDisplayAnimating) {
  241. // Mark all app layers as HWC_OVERLAY for virtual during
  242. // animation, so that SF doesnt draw it on FB
  243. for(int i = 0 ;i < ctx->listStats[dpy].numAppLayers; i++) {
  244. hwc_layer_1_t *layer = &list->hwLayers[i];
  245. layer->compositionType = HWC_OVERLAY;
  246. }
  247. }
  248. } else {
  249. /* Virtual Display is in Pause state.
  250. * Mark all application layers as OVERLAY so that
  251. * GPU will not compose.
  252. */
  253. for(size_t i = 0 ;i < (size_t)(list->numHwLayers - 1); i++) {
  254. hwc_layer_1_t *layer = &list->hwLayers[i];
  255. layer->compositionType = HWC_OVERLAY;
  256. }
  257. }
  258. }
  259. return 0;
  260. }
  261.  
  262.  
  263. static int hwc_prepare(hwc_composer_device_1 *dev, size_t numDisplays,
  264. hwc_display_contents_1_t** displays)
  265. {
  266. int ret = 0;
  267. hwc_context_t* ctx = (hwc_context_t*)(dev);
  268.  
  269. if (ctx->mPanelResetStatus) {
  270. ALOGW("%s: panel is in bad state. reset the panel", __FUNCTION__);
  271. reset_panel(dev);
  272. }
  273.  
  274. //Will be unlocked at the end of set
  275. ctx->mDrawLock.lock();
  276. reset(ctx, numDisplays, displays);
  277.  
  278. ctx->mOverlay->configBegin();
  279. ctx->mRotMgr->configBegin();
  280. ctx->mNeedsRotator = false;
  281.  
  282. for (int32_t i = numDisplays; i >= 0; i--) {
  283. hwc_display_contents_1_t *list = displays[i];
  284. int dpy = getDpyforExternalDisplay(ctx, i);
  285. switch(dpy) {
  286. case HWC_DISPLAY_PRIMARY:
  287. ret = hwc_prepare_primary(dev, list);
  288. break;
  289. case HWC_DISPLAY_EXTERNAL:
  290. ret = hwc_prepare_external(dev, list);
  291. break;
  292. case HWC_DISPLAY_VIRTUAL:
  293. ret = hwc_prepare_virtual(dev, list);
  294. break;
  295. default:
  296. ret = -EINVAL;
  297. }
  298. }
  299.  
  300. ctx->mOverlay->configDone();
  301. ctx->mRotMgr->configDone();
  302.  
  303. return ret;
  304. }
  305.  
  306. static int hwc_eventControl(struct hwc_composer_device_1* dev, int dpy,
  307. int event, int enable)
  308. {
  309. int ret = 0;
  310. hwc_context_t* ctx = (hwc_context_t*)(dev);
  311.  
  312. if(!ctx->dpyAttr[dpy].isActive) {
  313. ALOGE("Display is blanked - Cannot %s vsync",
  314. enable ? "enable" : "disable");
  315. return -EINVAL;
  316. }
  317.  
  318. switch(event) {
  319. case HWC_EVENT_VSYNC:
  320. if (ctx->vstate.enable == enable)
  321. break;
  322. ret = hwc_vsync_control(ctx, dpy, enable);
  323. if(ret == 0)
  324. ctx->vstate.enable = !!enable;
  325. ALOGD_IF (VSYNC_DEBUG, "VSYNC state changed to %s",
  326. (enable)?"ENABLED":"DISABLED");
  327. break;
  328. #ifdef QCOM_BSP
  329. case HWC_EVENT_ORIENTATION:
  330. if(dpy == HWC_DISPLAY_PRIMARY) {
  331. Locker::Autolock _l(ctx->mDrawLock);
  332. // store the primary display orientation
  333. // will be used in hwc_video::configure to disable
  334. // rotation animation on external display
  335. ctx->deviceOrientation = enable;
  336. }
  337. break;
  338. #endif
  339. default:
  340. ret = -EINVAL;
  341. }
  342. return ret;
  343. }
  344.  
  345. static int hwc_blank(struct hwc_composer_device_1* dev, int dpy, int blank)
  346. {
  347. ATRACE_CALL();
  348. hwc_context_t* ctx = (hwc_context_t*)(dev);
  349.  
  350. Locker::Autolock _l(ctx->mDrawLock);
  351. int ret = 0, value = 0;
  352.  
  353. /* In case of non-hybrid WFD session, we are fooling SF by
  354. * piggybacking on HDMI display ID for virtual.
  355. * TODO: Not needed once we have WFD client working on top
  356. * of Google API's.
  357. */
  358. dpy = getDpyforExternalDisplay(ctx,dpy);
  359.  
  360. ALOGD_IF(BLANK_DEBUG, "%s: %s display: %d", __FUNCTION__,
  361. blank==1 ? "Blanking":"Unblanking", dpy);
  362. if(blank) {
  363. // free up all the overlay pipes in use
  364. // when we get a blank for either display
  365. // makes sure that all pipes are freed
  366. ctx->mOverlay->configBegin();
  367. ctx->mOverlay->configDone();
  368. ctx->mRotMgr->clear();
  369. }
  370. switch(dpy) {
  371. case HWC_DISPLAY_PRIMARY:
  372. if(blank) {
  373. int dpy = HWC_DISPLAY_PRIMARY;
  374. if(!Overlay::displayCommit(ctx->dpyAttr[dpy].fd)){
  375. ALOGE("%s: display commit fail for primary!", __FUNCTION__);
  376. ret = -1;
  377. }
  378. }
  379. value = blank ? FB_BLANK_POWERDOWN : FB_BLANK_UNBLANK;
  380. if(ioctl(ctx->dpyAttr[dpy].fd, FBIOBLANK, value) < 0 ) {
  381. ALOGE("%s: Failed to handle blank event(%d) for Primary!!",
  382. __FUNCTION__, blank );
  383. return -1;
  384. }
  385.  
  386. if(!blank) {
  387. // Enable HPD here, as during bootup unblank is called
  388. // when SF is completely initialized
  389. ctx->mExtDisplay->setHPD(1);
  390. }
  391.  
  392. ctx->dpyAttr[dpy].isActive = !blank;
  393.  
  394. if(ctx->mVirtualonExtActive) {
  395. /* if mVirtualonExtActive is true, display hal will
  396. * receive unblank calls for non-hybrid WFD solution
  397. * since we piggyback on HDMI.
  398. * TODO: Not needed once we have WFD client working on top
  399. of Google API's */
  400. break;
  401. }
  402. case HWC_DISPLAY_VIRTUAL:
  403. /* There are two ways to reach this block of code.
  404.  
  405. * Display hal has received unblank call on HWC_DISPLAY_EXTERNAL
  406. and ctx->mVirtualonExtActive is true. In this case, non-hybrid
  407. WFD is active. If so, getDpyforExternalDisplay will return dpy
  408. as HWC_DISPLAY_VIRTUAL.
  409.  
  410. * Display hal has received unblank call on HWC_DISPLAY_PRIMARY
  411. and since SF is not aware of VIRTUAL DISPLAY being handle by HWC,
  412. it wont send blank / unblank events for it. We piggyback on
  413. PRIMARY DISPLAY events to release mdp pipes and
  414. activate/deactivate VIRTUAL DISPLAY.
  415.  
  416. * TODO: This separate case statement is not needed once we have
  417. WFD client working on top of Google API's.
  418.  
  419. */
  420.  
  421. if(ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected) {
  422. if(blank) {
  423. int dpy = HWC_DISPLAY_VIRTUAL;
  424. if(!Overlay::displayCommit(ctx->dpyAttr[dpy].fd,1)) {
  425. ALOGE("%s: display commit fail for virtual!", __FUNCTION__);
  426. ret = -1;
  427. }
  428. }
  429. ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].isActive = !blank;
  430. }
  431. break;
  432. case HWC_DISPLAY_EXTERNAL:
  433. if(blank) {
  434. if(!Overlay::displayCommit(ctx->dpyAttr[dpy].fd,1)) {
  435. ALOGE("%s: display commit fail for external!", __FUNCTION__);
  436. ret = -1;
  437. }
  438. }
  439. ctx->dpyAttr[dpy].isActive = !blank;
  440. break;
  441. default:
  442. return -EINVAL;
  443. }
  444.  
  445. ALOGD_IF(BLANK_DEBUG, "%s: Done %s display: %d", __FUNCTION__,
  446. blank ? "blanking":"unblanking", dpy);
  447. return ret;
  448. }
  449.  
  450. static void reset_panel(struct hwc_composer_device_1* dev)
  451. {
  452. int ret = 0;
  453. hwc_context_t* ctx = (hwc_context_t*)(dev);
  454.  
  455. if (!ctx->mPanelResetStatus)
  456. return;
  457.  
  458. ALOGD("%s: calling BLANK DISPLAY", __FUNCTION__);
  459. ret = hwc_blank(dev, HWC_DISPLAY_PRIMARY, 1);
  460. if (ret < 0) {
  461. ALOGE("%s: FBIOBLANK failed to BLANK: %s", __FUNCTION__,
  462. strerror(errno));
  463. }
  464.  
  465. ALOGD("%s: calling UNBLANK DISPLAY and enabling vsync", __FUNCTION__);
  466. ret = hwc_blank(dev, HWC_DISPLAY_PRIMARY, 0);
  467. if (ret < 0) {
  468. ALOGE("%s: FBIOBLANK failed to UNBLANK : %s", __FUNCTION__,
  469. strerror(errno));
  470. }
  471. hwc_vsync_control(ctx, HWC_DISPLAY_PRIMARY, 1);
  472.  
  473. ctx->mPanelResetStatus = false;
  474. }
  475.  
  476.  
  477. static int hwc_query(struct hwc_composer_device_1* dev,
  478. int param, int* value)
  479. {
  480. hwc_context_t* ctx = (hwc_context_t*)(dev);
  481. int supported = HWC_DISPLAY_PRIMARY_BIT;
  482.  
  483. switch (param) {
  484. case HWC_BACKGROUND_LAYER_SUPPORTED:
  485. // Not supported for now
  486. value[0] = 0;
  487. break;
  488. case HWC_DISPLAY_TYPES_SUPPORTED:
  489. if(ctx->mMDP.hasOverlay)
  490. supported |= HWC_DISPLAY_EXTERNAL_BIT;
  491. value[0] = supported;
  492. break;
  493. default:
  494. return -EINVAL;
  495. }
  496. return 0;
  497.  
  498. }
  499.  
  500.  
  501. static int hwc_set_primary(hwc_context_t *ctx, hwc_display_contents_1_t* list) {
  502. ATRACE_CALL();
  503. int ret = 0;
  504. const int dpy = HWC_DISPLAY_PRIMARY;
  505. if (LIKELY(list) && ctx->dpyAttr[dpy].isActive) {
  506. uint32_t last = list->numHwLayers - 1;
  507. hwc_layer_1_t *fbLayer = &list->hwLayers[last];
  508. int fd = -1; //FenceFD from the Copybit(valid in async mode)
  509. bool copybitDone = false;
  510. if(ctx->mCopyBit[dpy])
  511. copybitDone = ctx->mCopyBit[dpy]->draw(ctx, list, dpy, &fd);
  512. if(list->numHwLayers > 1)
  513. hwc_sync(ctx, list, dpy, fd);
  514.  
  515. // Dump the layers for primary
  516. if(ctx->mHwcDebug[dpy])
  517. ctx->mHwcDebug[dpy]->dumpLayers(list);
  518.  
  519. if (!ctx->mMDPComp[dpy]->draw(ctx, list)) {
  520. ALOGE("%s: MDPComp draw failed", __FUNCTION__);
  521. ret = -1;
  522. }
  523.  
  524. //TODO We dont check for SKIP flag on this layer because we need PAN
  525. //always. Last layer is always FB
  526. private_handle_t *hnd = (private_handle_t *)fbLayer->handle;
  527. if(copybitDone && ctx->mMDP.version > qdutils::MDP_V4_3) {
  528. hnd = ctx->mCopyBit[dpy]->getCurrentRenderBuffer();
  529. }
  530.  
  531. if(hnd) {
  532. if (!ctx->mFBUpdate[dpy]->draw(ctx, hnd)) {
  533. ALOGE("%s: FBUpdate draw failed", __FUNCTION__);
  534. ret = -1;
  535. }
  536. }
  537.  
  538. if(!Overlay::displayCommit(ctx->dpyAttr[dpy].fd)) {
  539. ALOGE("%s: display commit fail for %d dpy!", __FUNCTION__, dpy);
  540. ret = -1;
  541. }
  542. }
  543.  
  544. closeAcquireFds(list);
  545. return ret;
  546. }
  547.  
  548. static int hwc_set_external(hwc_context_t *ctx,
  549. hwc_display_contents_1_t* list)
  550. {
  551. ATRACE_CALL();
  552. int ret = 0;
  553.  
  554. const int dpy = HWC_DISPLAY_EXTERNAL;
  555.  
  556.  
  557. if (LIKELY(list) && ctx->dpyAttr[dpy].isActive &&
  558. ctx->dpyAttr[dpy].connected &&
  559. !ctx->dpyAttr[dpy].isPause) {
  560. uint32_t last = list->numHwLayers - 1;
  561. hwc_layer_1_t *fbLayer = &list->hwLayers[last];
  562. int fd = -1; //FenceFD from the Copybit(valid in async mode)
  563. bool copybitDone = false;
  564. if(ctx->mCopyBit[dpy])
  565. copybitDone = ctx->mCopyBit[dpy]->draw(ctx, list, dpy, &fd);
  566.  
  567. if(list->numHwLayers > 1)
  568. hwc_sync(ctx, list, dpy, fd);
  569.  
  570. // Dump the layers for external
  571. if(ctx->mHwcDebug[dpy])
  572. ctx->mHwcDebug[dpy]->dumpLayers(list);
  573.  
  574. if (!ctx->mMDPComp[dpy]->draw(ctx, list)) {
  575. ALOGE("%s: MDPComp draw failed", __FUNCTION__);
  576. ret = -1;
  577. }
  578.  
  579. int extOnlyLayerIndex =
  580. ctx->listStats[dpy].extOnlyLayerIndex;
  581.  
  582. private_handle_t *hnd = (private_handle_t *)fbLayer->handle;
  583. if(extOnlyLayerIndex!= -1) {
  584. hwc_layer_1_t *extLayer = &list->hwLayers[extOnlyLayerIndex];
  585. hnd = (private_handle_t *)extLayer->handle;
  586. } else if(copybitDone && ctx->mMDP.version > qdutils::MDP_V4_3) {
  587. hnd = ctx->mCopyBit[dpy]->getCurrentRenderBuffer();
  588. }
  589.  
  590. if(hnd && !isYuvBuffer(hnd)) {
  591. if (!ctx->mFBUpdate[dpy]->draw(ctx, hnd)) {
  592. ALOGE("%s: FBUpdate::draw fail!", __FUNCTION__);
  593. ret = -1;
  594. }
  595. }
  596.  
  597. if(!Overlay::displayCommit(ctx->dpyAttr[dpy].fd)) {
  598. ALOGE("%s: display commit fail for %d dpy!", __FUNCTION__, dpy);
  599. ret = -1;
  600. }
  601. }
  602.  
  603. closeAcquireFds(list);
  604. return ret;
  605. }
  606.  
  607. static int hwc_set_virtual(hwc_context_t *ctx,
  608. hwc_display_contents_1_t* list)
  609. {
  610. ATRACE_CALL();
  611. int ret = 0;
  612.  
  613. const int dpy = HWC_DISPLAY_VIRTUAL;
  614.  
  615.  
  616. if (LIKELY(list) && ctx->dpyAttr[dpy].isActive &&
  617. ctx->dpyAttr[dpy].connected &&
  618. !ctx->dpyAttr[dpy].isPause) {
  619. uint32_t last = list->numHwLayers - 1;
  620. hwc_layer_1_t *fbLayer = &list->hwLayers[last];
  621. int fd = -1; //FenceFD from the Copybit(valid in async mode)
  622. bool copybitDone = false;
  623. if(ctx->mCopyBit[dpy])
  624. copybitDone = ctx->mCopyBit[dpy]->draw(ctx, list, dpy, &fd);
  625.  
  626. if(list->numHwLayers > 1)
  627. hwc_sync(ctx, list, dpy, fd);
  628.  
  629.  
  630. if (!ctx->mMDPComp[dpy]->draw(ctx, list)) {
  631. ALOGE("%s: MDPComp draw failed", __FUNCTION__);
  632. ret = -1;
  633. }
  634.  
  635. int extOnlyLayerIndex =
  636. ctx->listStats[dpy].extOnlyLayerIndex;
  637.  
  638. private_handle_t *hnd = (private_handle_t *)fbLayer->handle;
  639. if(extOnlyLayerIndex!= -1) {
  640. hwc_layer_1_t *extLayer = &list->hwLayers[extOnlyLayerIndex];
  641. hnd = (private_handle_t *)extLayer->handle;
  642. } else if(copybitDone) {
  643. hnd = ctx->mCopyBit[dpy]->getCurrentRenderBuffer();
  644. }
  645.  
  646. if(hnd && !isYuvBuffer(hnd)) {
  647. if (!ctx->mFBUpdate[dpy]->draw(ctx, hnd)) {
  648. ALOGE("%s: FBUpdate::draw fail!", __FUNCTION__);
  649. ret = -1;
  650. }
  651. }
  652.  
  653. if(!Overlay::displayCommit(ctx->dpyAttr[dpy].fd)) {
  654. ALOGE("%s: display commit fail for %d dpy!", __FUNCTION__, dpy);
  655. ret = -1;
  656. }
  657. }
  658.  
  659. closeAcquireFds(list);
  660.  
  661. if (list && !ctx->mVirtualonExtActive && (list->retireFenceFd < 0) ) {
  662. // SF assumes HWC waits for the acquire fence and returns a new fence
  663. // that signals when we're done. Since we don't wait, and also don't
  664. // touch the buffer, we can just handle the acquire fence back to SF
  665. // as the retire fence.
  666. list->retireFenceFd = list->outbufAcquireFenceFd;
  667. }
  668.  
  669. return ret;
  670. }
  671.  
  672.  
  673. static int hwc_set(hwc_composer_device_1 *dev,
  674. size_t numDisplays,
  675. hwc_display_contents_1_t** displays)
  676. {
  677. int ret = 0;
  678. hwc_context_t* ctx = (hwc_context_t*)(dev);
  679. for (uint32_t i = 0; i <= numDisplays; i++) {
  680. hwc_display_contents_1_t* list = displays[i];
  681. int dpy = getDpyforExternalDisplay(ctx, i);
  682. switch(dpy) {
  683. case HWC_DISPLAY_PRIMARY:
  684. ret = hwc_set_primary(ctx, list);
  685. break;
  686. case HWC_DISPLAY_EXTERNAL:
  687. ret = hwc_set_external(ctx, list);
  688. break;
  689. case HWC_DISPLAY_VIRTUAL:
  690. ret = hwc_set_virtual(ctx, list);
  691. break;
  692. default:
  693. ret = -EINVAL;
  694. }
  695. }
  696. // This is only indicative of how many times SurfaceFlinger posts
  697. // frames to the display.
  698. CALC_FPS();
  699. MDPComp::resetIdleFallBack();
  700. //Was locked at the beginning of prepare
  701. //Composition cycle is complete signal all waiting threads
  702. ctx->mDrawLock.signal();
  703. ctx->mDrawLock.unlock();
  704. return ret;
  705. }
  706.  
  707. int hwc_getDisplayConfigs(struct hwc_composer_device_1* dev, int disp,
  708. uint32_t* configs, size_t* numConfigs) {
  709. int ret = 0;
  710. hwc_context_t* ctx = (hwc_context_t*)(dev);
  711. disp = getDpyforExternalDisplay(ctx, disp);
  712. //in 1.1 there is no way to choose a config, report as config id # 0
  713. //This config is passed to getDisplayAttributes. Ignore for now.
  714. switch(disp) {
  715. case HWC_DISPLAY_PRIMARY:
  716. if(*numConfigs > 0) {
  717. configs[0] = 0;
  718. *numConfigs = 1;
  719. }
  720. ret = 0; //NO_ERROR
  721. break;
  722. case HWC_DISPLAY_EXTERNAL:
  723. case HWC_DISPLAY_VIRTUAL:
  724. ret = -1; //Not connected
  725. if(ctx->dpyAttr[disp].connected) {
  726. ret = 0; //NO_ERROR
  727. if(*numConfigs > 0) {
  728. configs[0] = 0;
  729. *numConfigs = 1;
  730. }
  731. }
  732. break;
  733. }
  734. return ret;
  735. }
  736.  
  737. int hwc_getDisplayAttributes(struct hwc_composer_device_1* dev, int disp,
  738. uint32_t config, const uint32_t* attributes, int32_t* values) {
  739.  
  740. hwc_context_t* ctx = (hwc_context_t*)(dev);
  741. disp = getDpyforExternalDisplay(ctx, disp);
  742. //If hotpluggable displays(i.e, HDMI, WFD) are inactive return error
  743. if( (disp != HWC_DISPLAY_PRIMARY) && !ctx->dpyAttr[disp].connected) {
  744. return -1;
  745. }
  746.  
  747. //From HWComposer
  748. static const uint32_t DISPLAY_ATTRIBUTES[] = {
  749. HWC_DISPLAY_VSYNC_PERIOD,
  750. HWC_DISPLAY_WIDTH,
  751. HWC_DISPLAY_HEIGHT,
  752. HWC_DISPLAY_DPI_X,
  753. HWC_DISPLAY_DPI_Y,
  754. HWC_DISPLAY_NO_ATTRIBUTE,
  755. };
  756.  
  757. const int NUM_DISPLAY_ATTRIBUTES = (sizeof(DISPLAY_ATTRIBUTES) /
  758. sizeof(DISPLAY_ATTRIBUTES)[0]);
  759.  
  760. for (size_t i = 0; i < NUM_DISPLAY_ATTRIBUTES - 1; i++) {
  761. switch (attributes[i]) {
  762. case HWC_DISPLAY_VSYNC_PERIOD:
  763. values[i] = ctx->dpyAttr[disp].vsync_period;
  764. break;
  765. case HWC_DISPLAY_WIDTH:
  766. values[i] = ctx->dpyAttr[disp].xres;
  767. ALOGD("%s disp = %d, width = %d",__FUNCTION__, disp,
  768. ctx->dpyAttr[disp].xres);
  769. break;
  770. case HWC_DISPLAY_HEIGHT:
  771. values[i] = ctx->dpyAttr[disp].yres;
  772. ALOGD("%s disp = %d, height = %d",__FUNCTION__, disp,
  773. ctx->dpyAttr[disp].yres);
  774. break;
  775. case HWC_DISPLAY_DPI_X:
  776. values[i] = (int32_t) (ctx->dpyAttr[disp].xdpi*1000.0);
  777. break;
  778. case HWC_DISPLAY_DPI_Y:
  779. values[i] = (int32_t) (ctx->dpyAttr[disp].ydpi*1000.0);
  780. break;
  781. default:
  782. ALOGE("Unknown display attribute %d",
  783. attributes[i]);
  784. return -EINVAL;
  785. }
  786. }
  787. return 0;
  788. }
  789.  
  790. void hwc_dump(struct hwc_composer_device_1* dev, char *buff, int buff_len)
  791. {
  792. hwc_context_t* ctx = (hwc_context_t*)(dev);
  793. Locker::Autolock _l(ctx->mDrawLock);
  794. android::String8 aBuf("");
  795. dumpsys_log(aBuf, "Qualcomm HWC state:\n");
  796. dumpsys_log(aBuf, " MDPVersion=%d\n", ctx->mMDP.version);
  797. dumpsys_log(aBuf, " DisplayPanel=%c\n", ctx->mMDP.panel);
  798. for(int dpy = 0; dpy < HWC_NUM_DISPLAY_TYPES; dpy++) {
  799. if(ctx->mMDPComp[dpy])
  800. ctx->mMDPComp[dpy]->dump(aBuf);
  801. }
  802. char ovDump[2048] = {'\0'};
  803. ctx->mOverlay->getDump(ovDump, 2048);
  804. dumpsys_log(aBuf, ovDump);
  805. ovDump[0] = '\0';
  806. ctx->mRotMgr->getDump(ovDump, 2048);
  807. dumpsys_log(aBuf, ovDump);
  808. strlcpy(buff, aBuf.string(), buff_len);
  809. }
  810.  
  811. static int hwc_device_close(struct hw_device_t *dev)
  812. {
  813. if(!dev) {
  814. ALOGE("%s: NULL device pointer", __FUNCTION__);
  815. return -1;
  816. }
  817. closeContext((hwc_context_t*)dev);
  818. free(dev);
  819.  
  820. return 0;
  821. }
  822.  
  823. static int hwc_device_open(const struct hw_module_t* module, const char* name,
  824. struct hw_device_t** device)
  825. {
  826. int status = -EINVAL;
  827.  
  828. if (!strcmp(name, HWC_HARDWARE_COMPOSER)) {
  829. struct hwc_context_t *dev;
  830. dev = (hwc_context_t*)malloc(sizeof(*dev));
  831. memset(dev, 0, sizeof(*dev));
  832.  
  833. //Initialize hwc context
  834. initContext(dev);
  835.  
  836. //Setup HWC methods
  837. dev->device.common.tag = HARDWARE_DEVICE_TAG;
  838. dev->device.common.version = HWC_DEVICE_API_VERSION_1_3;
  839. dev->device.common.module = const_cast<hw_module_t*>(module);
  840. dev->device.common.close = hwc_device_close;
  841. dev->device.prepare = hwc_prepare;
  842. dev->device.set = hwc_set;
  843. dev->device.eventControl = hwc_eventControl;
  844. dev->device.blank = hwc_blank;
  845. dev->device.query = hwc_query;
  846. dev->device.registerProcs = hwc_registerProcs;
  847. dev->device.dump = hwc_dump;
  848. dev->device.getDisplayConfigs = hwc_getDisplayConfigs;
  849. dev->device.getDisplayAttributes = hwc_getDisplayAttributes;
  850. *device = &dev->device.common;
  851. status = 0;
  852. }
  853. return status;
  854. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!