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"
37using namespace overlay;
38namespace qhwc {
39#define HWC_UEVENT_SWITCH_STR  "change@/devices/virtual/switch/"
40#define HWC_UEVENT_THREAD_NAME "hwcUeventThread"
41
42static 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
48static 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 */
61static 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
70static 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 */
89static 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
102void handle_pause(hwc_context_t* ctx, int dpy) {
103    if(ctx->mHWCVirtual) {
104        ctx->mHWCVirtual->pause(ctx, dpy);
105    }
106    return;
107}
108
109void handle_resume(hwc_context_t* ctx, int dpy) {
110    if(ctx->mHWCVirtual) {
111        ctx->mHWCVirtual->resume(ctx, dpy);
112    }
113    return;
114}
115
116static 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
160static 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
319static 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
340void 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