1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "drm_display.h"
17 #include <string>
18 #include <cerrno>
19 #include <memory>
20 #include <xf86drm.h>
21 #include <xf86drmMode.h>
22 #include "display_gralloc.h"
23 #include "display_common.h"
24 #include "drm_device.h"
25 #include "drm_vsync_worker.h"
26 #include "hdi_drm_composition.h"
27 #include "hdi_gfx_composition.h"
28 
29 namespace OHOS {
30 namespace HDI {
31 namespace DISPLAY {
DrmDisplay(std::shared_ptr<DrmConnector> connector, std::shared_ptr<DrmCrtc> crtc, std::shared_ptr<DrmDevice> drmDevice)32 DrmDisplay::DrmDisplay(std::shared_ptr<DrmConnector> connector, std::shared_ptr<DrmCrtc> crtc,
33     std::shared_ptr<DrmDevice> drmDevice)
34     : mDrmDevice(drmDevice), mConnector(connector), mCrtc(crtc)
35 {}
36 
~DrmDisplay()37 DrmDisplay::~DrmDisplay()
38 {
39     if (mCrtc != nullptr) {
40         mCrtc->UnBindDisplay(GetId());
41     }
42 }
43 
Init()44 int32_t DrmDisplay::Init()
45 {
46     int ret;
47     DISPLAY_CHK_RETURN((mCrtc == nullptr), DISPLAY_FAILURE, DISPLAY_LOGE("crtc is null"));
48     DISPLAY_CHK_RETURN((mConnector == nullptr), DISPLAY_FAILURE, DISPLAY_LOGE("connector is null"));
49     DISPLAY_CHK_RETURN((mDrmDevice == nullptr), DISPLAY_FAILURE, DISPLAY_LOGE("drmDevice is null"));
50 
51     ret = HdiDisplay::Init();
52     DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("init failed"));
53     auto preComp = std::make_unique<HdiGfxComposition>();
54     DISPLAY_CHK_RETURN((preComp == nullptr), DISPLAY_FAILURE,
55         DISPLAY_LOGE("can not new HdiGfxComposition errno %{public}d", errno));
56     ret = preComp->Init();
57     DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("can not init HdiGfxComposition"));
58 
59     auto postComp = std::make_unique<HdiDrmComposition>(mConnector, mCrtc, mDrmDevice);
60     DISPLAY_CHK_RETURN((postComp == nullptr), DISPLAY_FAILURE,
61         DISPLAY_LOGE("can not new HdiDrmComposition errno %{public}d", errno));
62     ret = postComp->Init();
63     DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("can not init HdiDrmComposition"));
64     mComposer = std::make_unique<HdiComposer>(std::move(preComp), std::move(postComp));
65     ret = mCrtc->BindToDisplay(GetId());
66     DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("bind crtc failed"));
67 
68     ret = ChosePreferenceMode();
69     DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("choose preference mode fialed"));
70     return DISPLAY_SUCCESS;
71 }
72 
GetDisplayCapability(DisplayCapability *info)73 int32_t DrmDisplay::GetDisplayCapability(DisplayCapability *info)
74 {
75     mConnector->GetDisplayCap(*info);
76     return DISPLAY_SUCCESS;
77 }
78 
GetDisplaySupportedModes(uint32_t *num, DisplayModeInfo *modes)79 int32_t DrmDisplay::GetDisplaySupportedModes(uint32_t *num, DisplayModeInfo *modes)
80 {
81     mConnector->GetDisplaySupportedModes(num, modes);
82     return DISPLAY_SUCCESS;
83 }
84 
GetDisplayMode(uint32_t *modeId)85 int32_t DrmDisplay::GetDisplayMode(uint32_t *modeId)
86 {
87     DISPLAY_CHK_RETURN((modeId == nullptr), DISPLAY_NULL_PTR, DISPLAY_LOGE("the in modeId is nullptr"));
88     *modeId = mCrtc->GetActiveModeId();
89     return DISPLAY_SUCCESS;
90 }
91 
SetDisplayMode(uint32_t modeId)92 int32_t DrmDisplay::SetDisplayMode(uint32_t modeId)
93 {
94     return mCrtc->SetActivieMode(modeId);
95 }
96 
GetDisplayPowerStatus(DispPowerStatus *status)97 int32_t DrmDisplay::GetDisplayPowerStatus(DispPowerStatus *status)
98 {
99     DISPLAY_CHK_RETURN((status == nullptr), DISPLAY_NULL_PTR, DISPLAY_LOGE("status is nullptr"));
100     return ConvertToHdiPowerState(mConnector->GetDpmsState(), *status);
101 }
102 
SetDisplayPowerStatus(DispPowerStatus status)103 int32_t DrmDisplay::SetDisplayPowerStatus(DispPowerStatus status)
104 {
105     static int32_t fb_fd  = -1;
106     int32_t err = -1;
107     const uint32_t FBIOBLANK = 0x4611; /* arg: 0 or vesa level + 1 */
108     const uint32_t FB_BLANK_UNBLANK = 0;  /* screen: unblanked, hsync: on,  vsync: on */
109     const uint32_t FB_BLANK_POWERDOWN = 4; /* screen: blanked,   hsync: off, vsync: off */
110 
111     DISPLAY_DEBUGLOG("SetDisplayPowerStatus power state %{public}u", status);
112     if (fb_fd < 0) {
113         fb_fd = open("/dev/graphics/fb0", O_RDWR);
114         if (fb_fd < 0) {
115             DISPLAY_LOGE("oepn fb0 file failed\n");
116             return DISPLAY_NOT_SUPPORT;
117         }
118     }
119     switch (status) {
120         case POWER_STATUS_OFF:
121         case POWER_STATUS_STANDBY:
122         case POWER_STATUS_SUSPEND:
123             err = ioctl(fb_fd, FBIOBLANK, FB_BLANK_POWERDOWN);
124             break;
125         case POWER_STATUS_ON:
126             err = ioctl(fb_fd, FBIOBLANK, FB_BLANK_UNBLANK);
127             break;
128         default:
129             err = DISPLAY_FAILURE;
130             break;
131     }
132     if (err < 0) {
133         DISPLAY_LOGE("ioctl fb0 failed\n");
134         return DISPLAY_FAILURE;
135     }
136 
137     return DISPLAY_SUCCESS;
138 }
139 
ConvertToHdiPowerState(uint32_t drmPowerState, DispPowerStatus &hdiPowerState)140 int32_t DrmDisplay::ConvertToHdiPowerState(uint32_t drmPowerState, DispPowerStatus &hdiPowerState)
141 {
142     int32_t ret = DISPLAY_SUCCESS;
143     switch (drmPowerState) {
144         case DRM_MODE_DPMS_OFF:
145             hdiPowerState = POWER_STATUS_OFF;
146             break;
147         case DRM_MODE_DPMS_ON:
148             hdiPowerState = POWER_STATUS_ON;
149             break;
150         case DRM_MODE_DPMS_STANDBY:
151             hdiPowerState = POWER_STATUS_STANDBY;
152             break;
153         case DRM_MODE_DPMS_SUSPEND:
154             hdiPowerState = POWER_STATUS_SUSPEND;
155             break;
156         default:
157             hdiPowerState = POWER_STATUS_BUTT;
158             ret = DISPLAY_FAILURE;
159             break;
160     }
161     DISPLAY_DEBUGLOG("hdi power state %{public}u", hdiPowerState);
162     return ret;
163 }
164 
ConvertToDrmPowerState(DispPowerStatus hdiPowerState, uint32_t &drmPowerState)165 int32_t DrmDisplay::ConvertToDrmPowerState(DispPowerStatus hdiPowerState, uint32_t &drmPowerState)
166 {
167     int32_t ret = DISPLAY_SUCCESS;
168     switch (hdiPowerState) {
169         case POWER_STATUS_OFF:
170             drmPowerState = DRM_MODE_DPMS_OFF;
171             break;
172         case POWER_STATUS_ON:
173             drmPowerState = DRM_MODE_DPMS_ON;
174             break;
175         case POWER_STATUS_STANDBY:
176             drmPowerState = DRM_MODE_DPMS_STANDBY;
177             break;
178         case POWER_STATUS_SUSPEND:
179             drmPowerState = DRM_MODE_DPMS_SUSPEND;
180             break;
181         default:
182             ret = DISPLAY_FAILURE;
183             break;
184     }
185     return ret;
186 }
187 
CreateHdiLayer(LayerType type)188 std::unique_ptr<HdiLayer> DrmDisplay::CreateHdiLayer(LayerType type)
189 {
190     DISPLAY_DEBUGLOG();
191     return std::make_unique<HdiDrmLayer>(type);
192 }
193 
WaitForVBlank(uint64_t *ns)194 int32_t DrmDisplay::WaitForVBlank(uint64_t *ns)
195 {
196     int ret;
197     constexpr uint64_t nPerS = 1000000000;
198     constexpr uint64_t nPerUS = 1000;
199     drmVBlank vbl = {
200         .request.type = DRM_VBLANK_RELATIVE,
201         .request.sequence = 0,
202         .request.signal = 0,
203     };
204     DISPLAY_CHK_RETURN((ns == nullptr), DISPLAY_NULL_PTR, DISPLAY_LOGE("in ns is nullptr"));
205     ret = drmWaitVBlank(mDrmDevice->GetDrmFd(), &vbl);
206     DISPLAY_CHK_RETURN((ret != 0), DISPLAY_FAILURE, DISPLAY_LOGE("wait vblank failed errno %{public}d", errno));
207     *ns = static_cast<uint64_t>(vbl.reply.tval_sec * nPerS + vbl.reply.tval_usec * nPerUS);
208     return DISPLAY_SUCCESS;
209 }
210 
IsConnected()211 bool DrmDisplay::IsConnected()
212 {
213     DISPLAY_DEBUGLOG("conneted %{public}d", mConnector->IsConnected());
214     return mConnector->IsConnected();
215 }
216 
PushFirstFrame()217 int32_t DrmDisplay::PushFirstFrame()
218 {
219     GrallocFuncs *grallocFucs = nullptr;
220     int ret = GrallocInitialize(&grallocFucs);
221     DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("Gralloc init failed"));
222     DrmMode mode;
223     ret = mConnector->GetModeFromId(mCrtc->GetActiveModeId(), mode);
224     DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE,
225         DISPLAY_LOGE("can not get the mode from id %{public}d", mCrtc->GetActiveModeId()));
226     AllocInfo info = {
227         .width = mode.GetModeInfoPtr()->hdisplay,
228         .height = mode.GetModeInfoPtr()->vdisplay,
229         .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
230         .format = PIXEL_FMT_BGRA_8888
231     };
232 
233     BufferHandle *buffer = nullptr;
234     ret = grallocFucs->AllocMem(&info, &buffer);
235     DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("can not alloc memory"));
236     mClientLayer->SetLayerBuffer(buffer, -1);
237 
238     std::vector<HdiLayer *> layers;
239     HdiDrmComposition *drmComp = static_cast<HdiDrmComposition *>(mComposer->GetPostCompostion());
240     drmComp->SetLayers(layers, *mClientLayer);
241     drmComp->Apply(true);
242     return DISPLAY_SUCCESS;
243 }
244 
ChosePreferenceMode()245 int32_t DrmDisplay::ChosePreferenceMode()
246 {
247     int32_t ret;
248     int32_t modeId = mConnector->GetPreferenceId();
249     if (modeId == INVALID_MODE_ID) {
250         uint32_t num = 0;
251         ret = GetDisplaySupportedModes(&num, nullptr);
252         DISPLAY_CHK_RETURN((num == 0) && (ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("can not get modes"));
253         modeId = 0;
254     }
255     ret = SetDisplayMode(modeId);
256     // Push first frame to the drm, for that the vblank must init all the componet.
257     DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("set display mode failed"));
258     return PushFirstFrame();
259 }
260 
RegDisplayVBlankCallback(VBlankCallback cb, void *data)261 int32_t DrmDisplay::RegDisplayVBlankCallback(VBlankCallback cb, void *data)
262 {
263     DISPLAY_DEBUGLOG("the VBlankCallback %{public}p ", cb);
264     (void)data;
265     std::shared_ptr<VsyncCallBack> vsyncCb = std::make_shared<VsyncCallBack>(cb, nullptr, mCrtc->GetPipe());
266     DrmVsyncWorker::GetInstance().ReqesterVBlankCb(vsyncCb);
267     return DISPLAY_SUCCESS;
268 }
269 
SetDisplayVsyncEnabled(bool enabled)270 int32_t DrmDisplay::SetDisplayVsyncEnabled(bool enabled)
271 {
272     DISPLAY_DEBUGLOG("enable %{public}d", enabled);
273     DrmVsyncWorker::GetInstance().EnableVsync(enabled);
274     return DISPLAY_SUCCESS;
275 }
276 
GetDisplayBacklight(uint32_t *value)277 int32_t DrmDisplay::GetDisplayBacklight(uint32_t *value)
278 {
279     DISPLAY_CHK_RETURN((value == nullptr), DISPLAY_NULL_PTR, DISPLAY_LOGE("value is nullptr"));
280     return mConnector->GetBrightness(*value);
281 }
282 
SetDisplayBacklight(uint32_t value)283 int32_t DrmDisplay::SetDisplayBacklight(uint32_t value)
284 {
285     return mConnector->SetBrightness(value);
286 }
287 } // namespace OHOS
288 } // namespace HDI
289 } // namespace DISPLAY
290