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