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 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 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 */ 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 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 */ 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 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 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 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 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 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 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
