1 
2 /*
3  * Copyright (C) 2010 The Android Open Source Project
4  * Copyright (C) 2012-14, The Linux Foundation. All rights reserved.
5  *
6  * Not a Contribution, Apache license notifications and license are
7  * retained for attribution purposes only.
8 
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  */
21 #define UEVENT_DEBUG 0
22 #include <hardware_legacy/uevent.h>
23 #include <utils/Log.h>
24 #include <sys/resource.h>
25 #include <sys/prctl.h>
26 #include <string.h>
27 #include <stdlib.h>
28 #include "hwc_utils.h"
29 #include "hwc_fbupdate.h"
30 #include "hwc_mdpcomp.h"
31 #include "hwc_copybit.h"
32 #include "comptype.h"
33 #include "external.h"
34 #include "virtual.h"
35 #include "hwc_virtual.h"
36 #include "mdp_version.h"
37 using namespace overlay;
38 namespace qhwc {
39 #define HWC_UEVENT_SWITCH_STR  "change@/devices/virtual/switch/"
40 #define HWC_UEVENT_THREAD_NAME "hwcUeventThread"
41 
setup(hwc_context_t * ctx,int dpy)42 static void setup(hwc_context_t* ctx, int dpy)
43 {
44     ctx->mFBUpdate[dpy] = IFBUpdate::getObject(ctx, dpy);
45     ctx->mMDPComp[dpy] =  MDPComp::getObject(ctx, dpy);
46 }
47 
clear(hwc_context_t * ctx,int dpy)48 static void clear(hwc_context_t* ctx, int dpy)
49 {
50     if(ctx->mFBUpdate[dpy]) {
51         delete ctx->mFBUpdate[dpy];
52         ctx->mFBUpdate[dpy] = NULL;
53     }
54     if(ctx->mMDPComp[dpy]) {
55         delete ctx->mMDPComp[dpy];
56         ctx->mMDPComp[dpy] = NULL;
57     }
58 }
59 
60 /* Parse uevent data for devices which we are interested */
getConnectedDisplay(const char * strUdata)61 static int getConnectedDisplay(const char* strUdata)
62 {
63     if(strcasestr("change@/devices/virtual/switch/hdmi", strUdata))
64         return HWC_DISPLAY_EXTERNAL;
65     if(strcasestr("change@/devices/virtual/switch/wfd", strUdata))
66         return HWC_DISPLAY_VIRTUAL;
67     return -1;
68 }
69 
getPanelResetStatus(hwc_context_t * ctx,const char * strUdata,int len)70 static bool getPanelResetStatus(hwc_context_t* ctx, const char* strUdata, int len)
71 {
72     const char* iter_str = strUdata;
73     if (strcasestr("change@/devices/virtual/graphics/fb0", strUdata)) {
74         while(((iter_str - strUdata) <= len) && (*iter_str)) {
75             char* pstr = strstr(iter_str, "PANEL_ALIVE=0");
76             if (pstr != NULL) {
77                 ALOGI("%s: got change event in fb0 with PANEL_ALIVE=0",
78                                                            __FUNCTION__);
79                 ctx->mPanelResetStatus = true;
80                 return true;
81             }
82             iter_str += strlen(iter_str)+1;
83         }
84     }
85     return false;
86 }
87 
88 /* Parse uevent data for action requested for the display */
getConnectedState(const char * strUdata,int len)89 static int getConnectedState(const char* strUdata, int len)
90 {
91     const char* iter_str = strUdata;
92     while(((iter_str - strUdata) <= len) && (*iter_str)) {
93         char* pstr = strstr(iter_str, "SWITCH_STATE=");
94         if (pstr != NULL) {
95             return (atoi(pstr + strlen("SWITCH_STATE=")));
96         }
97         iter_str += strlen(iter_str)+1;
98     }
99     return -1;
100 }
101 
handle_pause(hwc_context_t * ctx,int dpy)102 void handle_pause(hwc_context_t* ctx, int dpy) {
103     if(ctx->mHWCVirtual) {
104         ctx->mHWCVirtual->pause(ctx, dpy);
105     }
106     return;
107 }
108 
handle_resume(hwc_context_t * ctx,int dpy)109 void handle_resume(hwc_context_t* ctx, int dpy) {
110     if(ctx->mHWCVirtual) {
111         ctx->mHWCVirtual->resume(ctx, dpy);
112     }
113     return;
114 }
115 
teardownWfd(hwc_context_t * ctx)116 static void teardownWfd(hwc_context_t* ctx) {
117     // Teardown WFD display
118     ALOGD_IF(UEVENT_DEBUG,"Received HDMI connection request when WFD is "
119             "active");
120     {
121         Locker::Autolock _l(ctx->mDrawLock);
122         clear(ctx, HWC_DISPLAY_VIRTUAL);
123         ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected = false;
124         ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].isActive = false;
125     }
126 
127     ctx->mVirtualDisplay->teardown();
128 
129     /* Need to send hotplug only when connected WFD in proprietary path */
130     if(ctx->mVirtualonExtActive) {
131         ALOGE_IF(UEVENT_DEBUG,"%s: Sending EXTERNAL OFFLINE"
132                 "hotplug event for wfd display", __FUNCTION__);
133         ctx->proc->hotplug(ctx->proc, HWC_DISPLAY_EXTERNAL,
134                 EXTERNAL_OFFLINE);
135         {
136             Locker::Autolock _l(ctx->mDrawLock);
137             ctx->mVirtualonExtActive = false;
138         }
139     }
140 
141     if(ctx->mVDSEnabled) {
142         ctx->mWfdSyncLock.lock();
143         ALOGD_IF(HWC_WFDDISPSYNC_LOG,
144                  "%s: Waiting for wfd-teardown to be signalled",__FUNCTION__);
145         ctx->mWfdSyncLock.wait();
146         ALOGD_IF(HWC_WFDDISPSYNC_LOG,
147                  "%s: Teardown signalled. Completed waiting in uevent thread",
148                  __FUNCTION__);
149         ctx->mWfdSyncLock.unlock();
150     } else {
151         /*TODO: Remove this else block and have wait rather than usleep
152           once wfd module issues binder call on teardown.*/
153 
154         /* For now, Wait for few frames for SF to tear down the WFD session.*/
155         usleep(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period
156                * 2 / 1000);
157     }
158 }
159 
handle_uevent(hwc_context_t * ctx,const char * udata,int len)160 static void handle_uevent(hwc_context_t* ctx, const char* udata, int len)
161 {
162     bool bpanelReset = getPanelResetStatus(ctx, udata, len);
163     if (bpanelReset) {
164         ctx->proc->invalidate(ctx->proc);
165         return;
166     }
167 
168     int dpy = getConnectedDisplay(udata);
169     if(dpy < 0) {
170         ALOGD_IF(UEVENT_DEBUG, "%s: Not disp Event ", __FUNCTION__);
171         return;
172     }
173 
174     int switch_state = getConnectedState(udata, len);
175 
176     ALOGE_IF(UEVENT_DEBUG,"%s: uevent received: %s switch state: %d",
177              __FUNCTION__,udata, switch_state);
178 
179     switch(switch_state) {
180     case EXTERNAL_OFFLINE:
181         {
182             /* Display not connected */
183             if(!ctx->dpyAttr[dpy].connected){
184                 ALOGE_IF(UEVENT_DEBUG,"%s: Ignoring EXTERNAL_OFFLINE event"
185                          "for display: %d", __FUNCTION__, dpy);
186                 break;
187             }
188 
189             Locker::Autolock _l(ctx->mDrawLock);
190             clear(ctx, dpy);
191             ctx->dpyAttr[dpy].connected = false;
192             ctx->dpyAttr[dpy].isActive = false;
193 
194             if(dpy == HWC_DISPLAY_EXTERNAL) {
195                 ctx->mExtDisplay->teardown();
196             } else {
197                 ctx->mVirtualDisplay->teardown();
198             }
199 
200             /* We need to send hotplug to SF only when we are disconnecting
201              * (1) HDMI OR (2) proprietary WFD session */
202             if(dpy == HWC_DISPLAY_EXTERNAL ||
203                ctx->mVirtualonExtActive) {
204                 ALOGE_IF(UEVENT_DEBUG,"%s:Sending EXTERNAL OFFLINE hotplug"
205                          "event", __FUNCTION__);
206                 ctx->proc->hotplug(ctx->proc, HWC_DISPLAY_EXTERNAL,
207                                    EXTERNAL_OFFLINE);
208                 ctx->mVirtualonExtActive = false;
209             }
210             break;
211         }
212     case EXTERNAL_ONLINE:
213         {
214             /* Display already connected */
215             if(ctx->dpyAttr[dpy].connected) {
216                 ALOGE_IF(UEVENT_DEBUG,"%s: Ignoring EXTERNAL_ONLINE event"
217                          "for display: %d", __FUNCTION__, dpy);
218                 break;
219             }
220             {
221                 //Force composition to give up resources like pipes and
222                 //close fb. For example if assertive display is going on,
223                 //fb2 could be open, thus connecting Layer Mixer#0 to
224                 //WriteBack module. If HDMI attempts to open fb1, the driver
225                 //will try to attach Layer Mixer#0 to HDMI INT, which will
226                 //fail, since Layer Mixer#0 is still connected to WriteBack.
227                 //This block will force composition to close fb2 in above
228                 //example.
229                 Locker::Autolock _l(ctx->mDrawLock);
230                 ctx->dpyAttr[dpy].isConfiguring = true;
231                 ctx->proc->invalidate(ctx->proc);
232             }
233             //2 cycles for slower content
234             usleep(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period
235                    * 2 / 1000);
236 
237             if(dpy == HWC_DISPLAY_EXTERNAL) {
238                 if(ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected) {
239                     // Triple Display is supported on 8084 target
240                     // WFD can be initiated by Wfd-client or Settings app
241                     // 1. wfd-client use hdmi hotplug mechanism.
242                     //    If wfd is connected via wfd-client and if HDMI is
243                     //    connected, we have to teardown wfd session.
244                     //    (as SF support only one active External display
245                     //     at a given time).
246                     //    (ToDo: Once wfd-client migrates using virtual display
247                     //     apis, second condition is redundant).
248                     // 2. Settings app use virtual display mechanism.
249                     //    In this approach, there is no limitation of supporting
250                     //    triple display.
251                     if(!(qdutils::MDPVersion::getInstance().is8084() &&
252                                 !ctx->mVirtualonExtActive)) {
253                         teardownWfd(ctx);
254                     }
255                 }
256                 ctx->mExtDisplay->configure();
257             } else {
258                 {
259                     Locker::Autolock _l(ctx->mDrawLock);
260                     /* TRUE only when we are on proprietary WFD session */
261                     ctx->mVirtualonExtActive = true;
262                     char property[PROPERTY_VALUE_MAX];
263                     if((property_get("persist.sys.wfd.virtual",
264                                                   property, NULL) > 0) &&
265                        (!strncmp(property, "1", PROPERTY_VALUE_MAX ) ||
266                        (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
267                         // This means we are on Google's WFD session
268                         ctx->mVirtualonExtActive = false;
269                     }
270                 }
271                 ctx->mVirtualDisplay->configure();
272             }
273 
274             Locker::Autolock _l(ctx->mDrawLock);
275             setup(ctx, dpy);
276             ctx->dpyAttr[dpy].isPause = false;
277             ctx->dpyAttr[dpy].connected = true;
278             ctx->dpyAttr[dpy].isConfiguring = true;
279 
280             if(dpy == HWC_DISPLAY_EXTERNAL ||
281                ctx->mVirtualonExtActive) {
282                 /* External display is HDMI or non-hybrid WFD solution */
283                 ALOGE_IF(UEVENT_DEBUG, "%s: Sending EXTERNAL_OFFLINE ONLINE"
284                          "hotplug event", __FUNCTION__);
285                 ctx->proc->hotplug(ctx->proc,HWC_DISPLAY_EXTERNAL,
286                                    EXTERNAL_ONLINE);
287             } else {
288                 /* We wont be getting unblank for VIRTUAL DISPLAY and its
289                  * always guaranteed from WFD stack that CONNECT uevent for
290                  * VIRTUAL DISPLAY will be triggered before creating
291                  * surface for the same. */
292                 ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].isActive = true;
293             }
294             break;
295         }
296         case EXTERNAL_PAUSE:
297             {   // pause case
298                 ALOGD("%s Received Pause event",__FUNCTION__);
299                 handle_pause(ctx, dpy);
300                 break;
301             }
302         case EXTERNAL_RESUME:
303             {  // resume case
304                 ALOGD("%s Received resume event",__FUNCTION__);
305                 //Treat Resume as Online event
306                 //Since external didnt have any pipes, force primary to give up
307                 //its pipes; we don't allow inter-mixer pipe transfers.
308                 handle_resume(ctx, dpy);
309                 break;
310             }
311     default:
312         {
313             ALOGE("%s: Invalid state to swtich:%d", __FUNCTION__, switch_state);
314             break;
315         }
316     }
317 }
318 
uevent_loop(void * param)319 static void *uevent_loop(void *param)
320 {
321     int len = 0;
322     static char udata[PAGE_SIZE];
323     hwc_context_t * ctx = reinterpret_cast<hwc_context_t *>(param);
324     char thread_name[64] = HWC_UEVENT_THREAD_NAME;
325     prctl(PR_SET_NAME, (unsigned long) &thread_name, 0, 0, 0);
326     setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
327     if(!uevent_init()) {
328         ALOGE("%s: failed to init uevent ",__FUNCTION__);
329         return NULL;
330     }
331 
332     while(1) {
333         len = uevent_next_event(udata, (int)sizeof(udata) - 2);
334         handle_uevent(ctx, udata, len);
335     }
336 
337     return NULL;
338 }
339 
init_uevent_thread(hwc_context_t * ctx)340 void init_uevent_thread(hwc_context_t* ctx)
341 {
342     pthread_t uevent_thread;
343     int ret;
344 
345     ALOGI("Initializing UEVENT Thread");
346     ret = pthread_create(&uevent_thread, NULL, uevent_loop, (void*) ctx);
347     if (ret) {
348         ALOGE("%s: failed to create %s: %s", __FUNCTION__,
349             HWC_UEVENT_THREAD_NAME, strerror(ret));
350     }
351 }
352 
353 }; //namespace
354