1 /*
2 * Copyright (C) 2021–2022 Beijing OSWare Technology Co., Ltd
3 * This file contains confidential and proprietary information of
4 * OSWare Technology Co., Ltd
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 #include "drm_display.h"
20 #include <string>
21 #include <cerrno>
22 #include <memory>
23 #include <xf86drm.h>
24 #include <xf86drmMode.h>
25 #include "display_gralloc.h"
26 #include "display_common.h"
27 #include "drm_device.h"
28 #include "drm_vsync_worker.h"
29 #include "hdi_drm_composition.h"
30 #include "hdi_gfx_composition.h"
31
32 namespace OHOS {
33 namespace HDI {
34 namespace DISPLAY {
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 DISPLAY_LOGD("the status %{public}d ", status);
109 uint32_t drmPowerState = 0;
110 int ret = ConvertToDrmPowerState(status, drmPowerState);
111 DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_PARAM_ERR,
112 DISPLAY_LOGE("unknown power status %{public}d", status));
113 mConnector->SetDpmsState(drmPowerState);
114 return DISPLAY_SUCCESS;
115 }
116
ConvertToHdiPowerState(uint32_t drmPowerState,DispPowerStatus & hdiPowerState)117 int32_t DrmDisplay::ConvertToHdiPowerState(uint32_t drmPowerState, DispPowerStatus &hdiPowerState)
118 {
119 int32_t ret = DISPLAY_SUCCESS;
120 switch (drmPowerState) {
121 case DRM_MODE_DPMS_OFF:
122 hdiPowerState = POWER_STATUS_OFF;
123 break;
124 case DRM_MODE_DPMS_ON:
125 hdiPowerState = POWER_STATUS_ON;
126 break;
127 case DRM_MODE_DPMS_STANDBY:
128 hdiPowerState = POWER_STATUS_STANDBY;
129 break;
130 case DRM_MODE_DPMS_SUSPEND:
131 hdiPowerState = POWER_STATUS_SUSPEND;
132 break;
133 default:
134 hdiPowerState = POWER_STATUS_BUTT;
135 ret = DISPLAY_FAILURE;
136 break;
137 }
138 DISPLAY_LOGD("hdi power state %{public}u", hdiPowerState);
139 return ret;
140 }
141
ConvertToDrmPowerState(DispPowerStatus hdiPowerState,uint32_t & drmPowerState)142 int32_t DrmDisplay::ConvertToDrmPowerState(DispPowerStatus hdiPowerState, uint32_t &drmPowerState)
143 {
144 int32_t ret = DISPLAY_SUCCESS;
145 switch (hdiPowerState) {
146 case POWER_STATUS_OFF:
147 drmPowerState = DRM_MODE_DPMS_OFF;
148 break;
149 case POWER_STATUS_ON:
150 drmPowerState = DRM_MODE_DPMS_ON;
151 break;
152 case POWER_STATUS_STANDBY:
153 drmPowerState = DRM_MODE_DPMS_STANDBY;
154 break;
155 case POWER_STATUS_SUSPEND:
156 drmPowerState = DRM_MODE_DPMS_SUSPEND;
157 break;
158 default:
159 ret = DISPLAY_FAILURE;
160 break;
161 }
162 return ret;
163 }
164
CreateHdiLayer(LayerType type)165 std::unique_ptr<HdiLayer> DrmDisplay::CreateHdiLayer(LayerType type)
166 {
167 DISPLAY_LOGD();
168 return std::make_unique<HdiDrmLayer>(type);
169 }
170
WaitForVBlank(uint64_t * ns)171 int32_t DrmDisplay::WaitForVBlank(uint64_t *ns)
172 {
173 int ret;
174 constexpr uint64_t nPerS = 1000000000;
175 constexpr uint64_t nPerUS = 1000;
176 drmVBlank vbl = {
177 .request.type = DRM_VBLANK_RELATIVE,
178 .request.sequence = 0,
179 .request.signal = 0,
180 };
181 DISPLAY_CHK_RETURN((ns == nullptr), DISPLAY_NULL_PTR, DISPLAY_LOGE("in ns is nullptr"));
182 ret = drmWaitVBlank(mDrmDevice->GetDrmFd(), &vbl);
183 DISPLAY_CHK_RETURN((ret != 0), DISPLAY_FAILURE, DISPLAY_LOGE("wait vblank failed errno %{public}d", errno));
184 *ns = static_cast<uint64_t>(vbl.reply.tval_sec * nPerS + vbl.reply.tval_usec * nPerUS);
185 return DISPLAY_SUCCESS;
186 }
187
IsConnected()188 bool DrmDisplay::IsConnected()
189 {
190 DISPLAY_LOGD("conneted %{public}d", mConnector->IsConnected());
191 return mConnector->IsConnected();
192 }
193
PushFirstFrame()194 int32_t DrmDisplay::PushFirstFrame()
195 {
196 GrallocFuncs *grallocFucs = nullptr;
197 int ret = GrallocInitialize(&grallocFucs);
198 DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("Gralloc init failed"));
199 DrmMode mode;
200 ret = mConnector->GetModeFromId(mCrtc->GetActiveModeId(), mode);
201 DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE,
202 DISPLAY_LOGE("can not get the mode from id %{public}d", mCrtc->GetActiveModeId()));
203 AllocInfo info = {
204 .width = mode.GetModeInfoPtr()->hdisplay,
205 .height = mode.GetModeInfoPtr()->vdisplay,
206 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
207 .format = PIXEL_FMT_BGRA_8888
208 };
209
210 BufferHandle *buffer = nullptr;
211 ret = grallocFucs->AllocMem(&info, &buffer);
212 DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("can not alloc memory"));
213 mClientLayer->SetLayerBuffer(buffer, -1);
214
215 std::vector<HdiLayer *> layers;
216 HdiDrmComposition *drmComp = static_cast<HdiDrmComposition *>(mComposer->GetPostCompostion(0));
217 drmComp->SetLayers(layers, *mClientLayer);
218 drmComp->Apply(true);
219 return DISPLAY_SUCCESS;
220 }
221
ChosePreferenceMode()222 int32_t DrmDisplay::ChosePreferenceMode()
223 {
224 int32_t ret;
225 int32_t modeId = mConnector->GetPreferenceId();
226 if (modeId == INVALID_MODE_ID) {
227 uint32_t num = 0;
228 ret = GetDisplaySupportedModes(&num, nullptr);
229 DISPLAY_CHK_RETURN((num == 0) && (ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("can not get modes"));
230 modeId = 0;
231 }
232 ret = SetDisplayMode(modeId);
233 // Push first frame to the drm, for that the vblank must init all the componet.
234 DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("set display mode failed"));
235 return PushFirstFrame();
236 }
237
RegDisplayVBlankCallback(VBlankCallback cb,void * data)238 int32_t DrmDisplay::RegDisplayVBlankCallback(VBlankCallback cb, void *data)
239 {
240 DISPLAY_LOGD("the VBlankCallback %{public}p ", cb);
241 std::shared_ptr<VsyncCallBack> vsyncCb = std::make_shared<VsyncCallBack>(cb, data);
242 DrmVsyncWorker::GetInstance().ReqesterVBlankCb(vsyncCb);
243 return DISPLAY_SUCCESS;
244 }
245
SetDisplayVsyncEnabled(bool enabled)246 int32_t DrmDisplay::SetDisplayVsyncEnabled(bool enabled)
247 {
248 DISPLAY_LOGD("enable %{public}d", enabled);
249 DrmVsyncWorker::GetInstance().EnableVsync(enabled);
250 return DISPLAY_SUCCESS;
251 }
252
GetDisplayBacklight(uint32_t * value)253 int32_t DrmDisplay::GetDisplayBacklight(uint32_t *value)
254 {
255 DISPLAY_CHK_RETURN((value == nullptr), DISPLAY_NULL_PTR, DISPLAY_LOGE("value is nullptr"));
256 return mConnector->GetBrightness(*value);
257 }
258
SetDisplayBacklight(uint32_t value)259 int32_t DrmDisplay::SetDisplayBacklight(uint32_t value)
260 {
261 return mConnector->SetBrightness(value);
262 }
263 } // namespace OHOS
264 } // namespace HDI
265 } // namespace DISPLAY
266