1 /*
2 * Copyright (c) 2013 The Linux Foundation. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 *    * Redistributions of source code must retain the above copyright
8 *      notice, this list of conditions and the following disclaimer.
9 *    * Redistributions in binary form must reproduce the above
10 *      copyright notice, this list of conditions and the following
11 *      disclaimer in the documentation and/or other materials provided
12 *      with the distribution.
13 *    * Neither the name of The Linux Foundation. nor the names of its
14 *      contributors may be used to endorse or promote products derived
15 *      from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29 
30 
31 #define DEBUG 0
32 #include <ctype.h>
33 #include <fcntl.h>
34 #include <media/IAudioPolicyService.h>
35 #include <media/AudioSystem.h>
36 #include <utils/threads.h>
37 #include <utils/Errors.h>
38 #include <utils/Log.h>
39 
40 #include <linux/msm_mdp.h>
41 #include <linux/fb.h>
42 #include <sys/ioctl.h>
43 #include <sys/poll.h>
44 #include <sys/resource.h>
45 #include <cutils/properties.h>
46 #include "hwc_utils.h"
47 #include "virtual.h"
48 #include "overlayUtils.h"
49 #include "overlay.h"
50 #include "qd_utils.h"
51 
52 using namespace android;
53 
54 namespace qhwc {
55 
56 #define MAX_SYSFS_FILE_PATH             255
57 
58 /* Max. resolution assignable to virtual display. */
59 #define SUPPORTED_VIRTUAL_AREA          (1920*1080)
60 
configure()61 int VirtualDisplay::configure() {
62     if(!openFrameBuffer())
63         return -1;
64 
65     if(ioctl(mFd, FBIOGET_VSCREENINFO, &mVInfo) < 0) {
66         ALOGD("%s: FBIOGET_VSCREENINFO failed with %s", __FUNCTION__,
67                 strerror(errno));
68         return -1;
69     }
70     setAttributes();
71     return 0;
72 }
73 
getAttributes(int & width,int & height)74 void VirtualDisplay::getAttributes(int& width, int& height) {
75     width = mVInfo.xres;
76     height = mVInfo.yres;
77 }
78 
teardown()79 int VirtualDisplay::teardown() {
80     closeFrameBuffer();
81     memset(&mVInfo, 0, sizeof(mVInfo));
82     // Reset the resolution when we close the fb for this device. We need
83     // this to distinguish between an ONLINE and RESUME event.
84     mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].xres = 0;
85     mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].yres = 0;
86     return 0;
87 }
88 
VirtualDisplay(hwc_context_t * ctx)89 VirtualDisplay::VirtualDisplay(hwc_context_t* ctx):mFd(-1),
90      mHwcContext(ctx)
91 {
92     memset(&mVInfo, 0, sizeof(mVInfo));
93 }
94 
~VirtualDisplay()95 VirtualDisplay::~VirtualDisplay()
96 {
97     closeFrameBuffer();
98 }
99 
100 /* Initializes the resolution attributes of the virtual display
101    that are reported to SurfaceFlinger.
102    Cases:
103        1. ONLINE event - initialize to frame buffer resolution
104        2. RESUME event - retain original resolution
105 */
initResolution(uint32_t & extW,uint32_t & extH)106 void VirtualDisplay::initResolution(uint32_t &extW, uint32_t &extH) {
107     // On ONLINE event, display resolution attributes are 0.
108     if(extW == 0 || extH == 0){
109         extW = mVInfo.xres;
110         extH = mVInfo.yres;
111     }
112 }
113 
114 /* Sets the virtual resolution to match that of the primary
115    display in the event that the virtual display currently
116    connected has a lower resolution. NB: we always report the
117    highest available resolution to SurfaceFlinger.
118 */
setToPrimary(uint32_t maxArea,uint32_t priW,uint32_t priH,uint32_t & extW,uint32_t & extH)119 void VirtualDisplay::setToPrimary(uint32_t maxArea,
120                                   uint32_t priW,
121                                   uint32_t priH,
122                                   uint32_t &extW,
123                                   uint32_t &extH) {
124     // for eg., primary in 1600p and WFD in 1080p
125     // we wont use downscale feature because MAX MDP
126     // writeback resolution supported is 1080p (tracked
127     // by SUPPORTED_VIRTUAL_AREA).
128     if((maxArea == (priW * priH))
129         && (maxArea <= SUPPORTED_VIRTUAL_AREA)) {
130         // tmpW and tmpH will hold the primary dimensions before we
131         // update the aspect ratio if necessary.
132         uint32_t tmpW = priW;
133         uint32_t tmpH = priH;
134         // If WFD is in landscape, assign the higher dimension
135         // to WFD's xres.
136         if(priH > priW) {
137             tmpW = priH;
138             tmpH = priW;
139         }
140         // The aspect ratios of the external and primary displays
141         // can be different. As a result, directly assigning primary
142         // resolution could lead to an incorrect final image.
143         // We get around this by calculating a new resolution by
144         // keeping aspect ratio intact.
145         hwc_rect r = {0, 0, 0, 0};
146         getAspectRatioPosition(tmpW, tmpH, extW, extH, r);
147         extW = r.right - r.left;
148         extH = r.bottom - r.top;
149     }
150 }
151 
152 /* Set External Display MDP Downscale mode indicator. Only set to
153    TRUE for the following scenarios:
154    1. Valid DRC scenarios i.e. when the original WFD resolution
155       is greater than the new/requested resolution in mVInfo.
156    2. WFD down scale path i.e. when WFD resolution is lower than
157       primary resolution.
158    Furthermore, downscale mode is only valid when downscaling from
159    SUPPORTED_VIRTUAL_AREA to a lower resolution.
160    (SUPPORTED_VIRTUAL_AREA represents the maximum resolution that
161    we can configure to the virtual display)
162 */
setDownScaleMode(uint32_t maxArea)163 void VirtualDisplay::setDownScaleMode(uint32_t maxArea) {
164     if((maxArea > (mVInfo.xres * mVInfo.yres))
165         && (maxArea <= SUPPORTED_VIRTUAL_AREA)) {
166         mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].mDownScaleMode = true;
167     }else {
168         mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].mDownScaleMode = false;
169     }
170 }
171 
setAttributes()172 void VirtualDisplay::setAttributes() {
173     if(mHwcContext) {
174         uint32_t &extW = mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].xres;
175         uint32_t &extH = mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].yres;
176         uint32_t priW = mHwcContext->dpyAttr[HWC_DISPLAY_PRIMARY].xres;
177         uint32_t priH = mHwcContext->dpyAttr[HWC_DISPLAY_PRIMARY].yres;
178 
179         // Dynamic Resolution Change depends on MDP downscaling.
180         // MDP downscale property will be ignored to exercise DRC use case.
181         // If DRC is in progress, ext WxH will have non-zero values.
182         bool isDRC = (extW > mVInfo.xres) && (extH > mVInfo.yres);
183 
184         initResolution(extW, extH);
185 
186         if(mHwcContext->mOverlay->isUIScalingOnExternalSupported()
187                 && (mHwcContext->mMDPDownscaleEnabled || isDRC)) {
188 
189             // maxArea represents the maximum resolution between
190             // primary and virtual display.
191             uint32_t maxArea = max((extW * extH), (priW * priH));
192 
193             setToPrimary(maxArea, priW, priH, extW, extH);
194 
195             setDownScaleMode(maxArea);
196         }
197         //Initialize the display viewFrame info
198         mHwcContext->mViewFrame[HWC_DISPLAY_VIRTUAL].left = 0;
199         mHwcContext->mViewFrame[HWC_DISPLAY_VIRTUAL].top = 0;
200         mHwcContext->mViewFrame[HWC_DISPLAY_VIRTUAL].right =
201             (int)mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].xres;
202         mHwcContext->mViewFrame[HWC_DISPLAY_VIRTUAL].bottom =
203             (int)mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].yres;
204         mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].vsync_period =
205                 1000000000l /60;
206         ALOGD_IF(DEBUG,"%s: Setting Virtual Attr: res(%d x %d)",__FUNCTION__,
207                  mVInfo.xres, mVInfo.yres);
208     }
209 }
210 
openFrameBuffer()211 bool VirtualDisplay::openFrameBuffer()
212 {
213     if (mFd == -1) {
214         int fbNum = overlay::Overlay::getInstance()->
215                                    getFbForDpy(HWC_DISPLAY_VIRTUAL);
216 
217         char strDevPath[MAX_SYSFS_FILE_PATH];
218         snprintf(strDevPath,sizeof(strDevPath), "/dev/graphics/fb%d", fbNum);
219 
220         mFd = open(strDevPath, O_RDWR);
221         if(mFd < 0) {
222             ALOGE("%s: Unable to open %s ", __FUNCTION__,strDevPath);
223             return -1;
224         }
225 
226         mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].fd = mFd;
227     }
228     return 1;
229 }
230 
closeFrameBuffer()231 bool VirtualDisplay::closeFrameBuffer()
232 {
233     if(mFd >= 0) {
234         if(close(mFd) < 0 ) {
235             ALOGE("%s: Unable to close FD(%d)", __FUNCTION__, mFd);
236             return -1;
237         }
238         mFd = -1;
239         mHwcContext->dpyAttr[HWC_DISPLAY_VIRTUAL].fd = mFd;
240     }
241     return 1;
242 }
243 };
244