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 "hdf_audio_server.h"
17 #include "audio_adapter_info_common.h"
18 #include "audio_hal_log.h"
19 #include "hdf_audio_server_capture.h"
20 #include "hdf_audio_server_common.h"
21 #include "hdf_audio_server_render.h"
22
23 #define HDF_LOG_TAG hdf_audio_server
24
25 struct AudioAdapterDescriptor *g_descs = NULL;
26 struct AudioManager *g_serverManager = NULL;
27 #ifdef AUDIO_HAL_USER
28 static void *g_mpiInitSo = NULL;
29 #define SO_INTERFACE_LIB_MPI_PATH HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_mpi")
30 #endif
31 /**************************public************************/
HdiServiceGetFuncs()32 int32_t HdiServiceGetFuncs()
33 {
34 HDF_LOGE("%{public}s: enter to", __func__);
35 if (g_serverManager != NULL) {
36 return AUDIO_HAL_SUCCESS;
37 }
38 g_serverManager = GetAudioManagerFuncs();
39 if (g_serverManager == NULL) {
40 HDF_LOGE("%{public}s: GetAudioManagerFuncs FAIL!", __func__);
41 return AUDIO_HAL_ERR_INTERNAL;
42 }
43 return AUDIO_HAL_SUCCESS;
44 }
45
HdiServiceGetAllAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)46 static int32_t HdiServiceGetAllAdapter(const struct HdfDeviceIoClient *client,
47 struct HdfSBuf *data, struct HdfSBuf *reply)
48 {
49 HDF_LOGE("%{public}s: enter to", __func__);
50 if (client == NULL || data == NULL || reply == NULL) {
51 return AUDIO_HAL_ERR_INVALID_PARAM;
52 }
53 static bool getAdaptersFlag = true;
54 struct AudioAdapterDescriptor *descs = NULL;
55 struct AudioManager *manager = g_serverManager;
56 int32_t size = 0;
57
58 if (manager == NULL) {
59 HDF_LOGE("%{public}s: Manager is NULL", __func__);
60 return AUDIO_HAL_ERR_INVALID_PARAM;
61 }
62 int32_t ret = manager->GetAllAdapters(manager, &descs, &size);
63 if (ret < 0) {
64 HDF_LOGE("%{public}s: g_manager->GetAllAdapters error", __func__);
65 return AUDIO_HAL_ERR_INTERNAL;
66 }
67 if (size > MAX_AUDIO_ADAPTER_NUM_SERVER || size == 0 || descs == NULL || ret < 0) {
68 HDF_LOGE("%{public}s: size or g_descs is error", __func__);
69 return AUDIO_HAL_ERR_NOT_SUPPORT;
70 }
71 AudioSetFuzzCheckFlag(false);
72 g_descs = descs;
73 if (getAdaptersFlag == true) { // Initialize only once
74 ret = AdaptersServerManageInit(descs, size);
75 if (ret != AUDIO_HAL_SUCCESS) {
76 HDF_LOGE("%{public}s: AdapterServerManageInit fail", __func__);
77
78 return ret;
79 }
80 getAdaptersFlag = false;
81 }
82 HDF_LOGE("%{public}s: out", __func__);
83
84 return AUDIO_HAL_SUCCESS;
85 }
86
SwitchAdapter(struct AudioAdapterDescriptor * descs,const char * adapterNameCase,enum AudioPortDirection portFlag,struct AudioPort * renderPort,const int size)87 int SwitchAdapter(struct AudioAdapterDescriptor *descs, const char *adapterNameCase, enum AudioPortDirection portFlag,
88 struct AudioPort *renderPort, const int size)
89 {
90 if (descs == NULL || adapterNameCase == NULL || renderPort == NULL) {
91 return HDF_FAILURE;
92 }
93 for (int index = 0; index < size; index++) {
94 struct AudioAdapterDescriptor *desc = &descs[index];
95 if (desc == NULL) {
96 continue;
97 }
98 if (desc->adapterName == NULL) {
99 return HDF_FAILURE;
100 }
101 if (strcmp(desc->adapterName, adapterNameCase)) {
102 continue;
103 }
104 for (uint32_t port = 0; port < desc->portNum; port++) {
105 if (desc->ports[port].dir == portFlag) {
106 *renderPort = desc->ports[port];
107 HDF_LOGE("%{public}s: success!,%{public}d", __func__, portFlag);
108 return index;
109 }
110 }
111 }
112 HDF_LOGE("%{public}s: out!", __func__);
113 return HDF_FAILURE;
114 }
115
116 /* Adapter Check */
117
HdiServiceLoadAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)118 static int32_t HdiServiceLoadAdapter(const struct HdfDeviceIoClient *client,
119 struct HdfSBuf *data, struct HdfSBuf *reply)
120 {
121 if (client == NULL || data == NULL || reply == NULL) {
122 return AUDIO_HAL_ERR_INVALID_PARAM;
123 }
124 struct AudioAdapter *adapter = NULL;
125 struct AudioPort renderPort;
126 const char *adapterName = NULL;
127 uint32_t tempDir = 0;
128 if ((adapterName = HdfSbufReadString(data)) == NULL) {
129 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
130 return AUDIO_HAL_ERR_INVALID_PARAM;
131 }
132 int32_t ret = AudioAdapterCheckListExist(adapterName);
133 if (ret == AUDIO_HAL_ERR_INVALID_PARAM) {
134 return AUDIO_HAL_ERR_INTERNAL;
135 }
136 if (ret == AUDIO_HAL_SUCCESS) {
137 HDF_LOGE("%{public}s: adapte already exist !", __func__);
138 return AUDIO_HAL_SUCCESS;
139 }
140 if (!HdfSbufReadUint32(data, &tempDir)) {
141 HDF_LOGE("%{public}s: adapter need Load!", __func__);
142 return AUDIO_HAL_ERR_INTERNAL;
143 }
144 enum AudioPortDirection port = (enum AudioPortDirection)tempDir;
145 struct AudioManager *manager = g_serverManager;
146 if (adapterName == NULL || manager == NULL || g_descs == NULL) {
147 HDF_LOGE("%{public}s: Point is NULL!", __func__);
148 return AUDIO_HAL_ERR_INTERNAL;
149 }
150 int index = SwitchAdapter(g_descs, adapterName, port,
151 &renderPort, ServerManageGetAdapterNum());
152 if (index < 0) {
153 return AUDIO_HAL_ERR_NOT_SUPPORT;
154 }
155 struct AudioAdapterDescriptor *desc = &g_descs[index];
156 ret = manager->LoadAdapter(manager, desc, &adapter);
157 if (ret < 0) {
158 return AUDIO_HAL_ERR_NOT_SUPPORT;
159 }
160 if (adapter == NULL) {
161 HDF_LOGE("%{public}s: load audio device failed", __func__);
162 return AUDIO_HAL_ERR_INVALID_PARAM;
163 }
164 if (AudioAdapterListAdd(adapterName, adapter)) {
165 HDF_LOGE("%{public}s: AudioAdapterListAdd error!", __func__);
166 manager->UnloadAdapter(manager, adapter);
167 return AUDIO_HAL_ERR_INTERNAL;
168 }
169 return AUDIO_HAL_SUCCESS;
170 }
171
HdiServiceInitAllPorts(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)172 static int32_t HdiServiceInitAllPorts(const struct HdfDeviceIoClient *client,
173 struct HdfSBuf *data, struct HdfSBuf *reply)
174 {
175 HDF_LOGE("%{public}s: HdiServiceInitAllPorts", __func__);
176 if (client == NULL || data == NULL || reply == NULL) {
177 return AUDIO_HAL_ERR_INVALID_PARAM;
178 }
179 const char *adapterName = NULL;
180 struct AudioAdapter *adapter = NULL;
181 if ((adapterName = HdfSbufReadString(data)) == NULL) {
182 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
183 return AUDIO_HAL_ERR_INVALID_PARAM;
184 }
185 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
186 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
187 return AUDIO_HAL_ERR_INTERNAL;
188 }
189 if (adapter->InitAllPorts(adapter)) {
190 HDF_LOGE("%{public}s: InitAllPorts fail", __func__);
191 return AUDIO_HAL_ERR_INTERNAL;
192 }
193 return AUDIO_HAL_SUCCESS;
194 }
195
HdiServiceUnloadAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)196 static int32_t HdiServiceUnloadAdapter(const struct HdfDeviceIoClient *client,
197 struct HdfSBuf *data, struct HdfSBuf *reply)
198 {
199 if (client == NULL || data == NULL || reply == NULL) {
200 return AUDIO_HAL_ERR_INVALID_PARAM;
201 }
202 struct AudioAdapter *adapter = NULL;
203 const char *adapterName = NULL;
204 int ret;
205 struct AudioManager *manager = g_serverManager;
206 if (manager == NULL) {
207 HDF_LOGE("%{public}s: Point is NULL!", __func__);
208 return AUDIO_HAL_ERR_INVALID_PARAM;
209 }
210 if ((adapterName = HdfSbufReadString(data)) == NULL) {
211 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
212 return AUDIO_HAL_ERR_INVALID_PARAM;
213 }
214 ret = AudioAdapterListDestory(adapterName, &adapter);
215 if (ret == AUDIO_HAL_ERR_INTERNAL) {
216 HDF_LOGE("%{public}s: Other dev Use the adapter", __func__);
217 return AUDIO_HAL_SUCCESS;
218 } else if (ret == AUDIO_HAL_ERR_INVALID_PARAM) {
219 HDF_LOGE("%{public}s: param invalid!", __func__);
220 return AUDIO_HAL_ERR_INTERNAL;
221 } else {
222 HDF_LOGE("%{public}s: Unload the adapter!", __func__);
223 }
224 if (adapter == NULL) {
225 return AUDIO_HAL_ERR_INVALID_PARAM;
226 }
227 manager->UnloadAdapter(manager, adapter);
228 return AUDIO_HAL_SUCCESS;
229 }
230
HdiServiceGetPortCapability(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)231 static int32_t HdiServiceGetPortCapability(const struct HdfDeviceIoClient *client,
232 struct HdfSBuf *data, struct HdfSBuf *reply)
233 {
234 HDF_LOGE("%{public}s: enter", __func__);
235 if (client == NULL || data == NULL || reply == NULL) {
236 return AUDIO_HAL_ERR_INVALID_PARAM;
237 }
238 struct AudioPort port;
239 struct AudioPortCapability capability;
240 struct AudioAdapter *adapter = NULL;
241 const char *adapterName = NULL;
242 uint32_t tempDir = 0;
243 if ((adapterName = HdfSbufReadString(data)) == NULL) {
244 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
245 return AUDIO_HAL_ERR_INVALID_PARAM;
246 }
247 if (!HdfSbufReadUint32(data, &tempDir)) {
248 return AUDIO_HAL_ERR_INTERNAL;
249 }
250 port.dir = (enum AudioPortDirection)tempDir;
251 if (!HdfSbufReadUint32(data, &port.portId)) {
252 return AUDIO_HAL_ERR_INTERNAL;
253 }
254 if ((port.portName = HdfSbufReadString(data)) == NULL) {
255 return AUDIO_HAL_ERR_INTERNAL;
256 }
257 HDF_LOGE("port.portName = %{public}s", port.portName);
258 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
259 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
260 return AUDIO_HAL_ERR_INTERNAL;
261 }
262 if (adapter == NULL) {
263 HDF_LOGE("%{public}s: HdiServiceCreatRender adapter is NULL!", __func__);
264 return AUDIO_HAL_ERR_INVALID_PARAM;
265 }
266 int32_t ret = adapter->GetPortCapability(adapter, &port, &capability);
267 if (ret < 0) {
268 HDF_LOGE("%{public}s: ret failed", __func__);
269 return AUDIO_HAL_ERR_INTERNAL;
270 }
271 return AUDIO_HAL_SUCCESS;
272 }
273
HdiServiceSetPassthroughMode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)274 static int32_t HdiServiceSetPassthroughMode(const struct HdfDeviceIoClient *client,
275 struct HdfSBuf *data, struct HdfSBuf *reply)
276 {
277 HDF_LOGE("%{public}s: enter", __func__);
278 if (client == NULL || data == NULL || reply == NULL) {
279 return AUDIO_HAL_ERR_INVALID_PARAM;
280 }
281 struct AudioPort port;
282 enum AudioPortPassthroughMode mode;
283 struct AudioAdapter *adapter = NULL;
284 const char *adapterName = NULL;
285 if ((adapterName = HdfSbufReadString(data)) == NULL) {
286 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
287 return AUDIO_HAL_ERR_INVALID_PARAM;
288 }
289 uint32_t tempDir = 0;
290 if (!HdfSbufReadUint32(data, &tempDir)) {
291 return AUDIO_HAL_ERR_INTERNAL;
292 }
293 port.dir = (enum AudioPortDirection)tempDir;
294 HDF_LOGE("port.dir = %{public}d", port.dir);
295 if (!HdfSbufReadUint32(data, &port.portId)) {
296 return AUDIO_HAL_ERR_INTERNAL;
297 }
298 if ((port.portName = HdfSbufReadString(data)) == NULL) {
299 HDF_LOGE("port.portName = %{public}s", port.portName);
300 return AUDIO_HAL_ERR_INTERNAL;
301 }
302 HDF_LOGE("port.portName = %{public}s", port.portName);
303 uint32_t tempMode = 0;
304 if (!HdfSbufReadUint32(data, &tempMode)) {
305 return AUDIO_HAL_ERR_INTERNAL;
306 }
307 mode = (enum AudioPortPassthroughMode)tempMode;
308 HDF_LOGE("%{public}s: ready in,mode = %{public}d", __func__, mode);
309 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
310 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
311 return AUDIO_HAL_ERR_INTERNAL;
312 }
313 if (adapter == NULL) {
314 HDF_LOGE("%{public}s: HdiServiceCreatRender adapter is NULL!", __func__);
315 return AUDIO_HAL_ERR_INVALID_PARAM;
316 }
317 int ret = adapter->SetPassthroughMode(adapter, &port, mode);
318 return ret;
319 }
HdiServiceGetPassthroughMode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)320 static int32_t HdiServiceGetPassthroughMode(const struct HdfDeviceIoClient *client,
321 struct HdfSBuf *data, struct HdfSBuf *reply)
322 {
323 if (client == NULL || data == NULL || reply == NULL) {
324 return AUDIO_HAL_ERR_INVALID_PARAM;
325 }
326 enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO;
327 struct AudioAdapter *adapter = NULL;
328 const char *adapterName = NULL;
329 struct AudioPort port;
330 (void)memset_s(&port, sizeof(struct AudioPort), 0, sizeof(struct AudioPort));
331 if ((adapterName = HdfSbufReadString(data)) == NULL) {
332 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
333 return AUDIO_HAL_ERR_INVALID_PARAM;
334 }
335 uint32_t tempDir = port.dir;
336 if (!HdfSbufReadUint32(data, &tempDir)) {
337 return AUDIO_HAL_ERR_INTERNAL;
338 }
339 port.dir = (enum AudioPortDirection)tempDir;
340 if (!HdfSbufReadUint32(data, &port.portId)) {
341 return AUDIO_HAL_ERR_INTERNAL;
342 }
343 if ((port.portName = HdfSbufReadString(data)) == NULL) {
344 HDF_LOGE("port.portName = %{public}s", port.portName);
345 return AUDIO_HAL_ERR_INTERNAL;
346 }
347 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
348 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
349 return AUDIO_HAL_ERR_INTERNAL;
350 }
351 if (adapter == NULL) {
352 HDF_LOGE("%{public}s: adapter is NULL!", __func__);
353 return AUDIO_HAL_ERR_INVALID_PARAM;
354 }
355 int ret = adapter->GetPassthroughMode(adapter, &port, &mode);
356 if (ret < 0) {
357 HDF_LOGE("%{public}s: GetPassthroughMode ret failed", __func__);
358 return AUDIO_HAL_ERR_INTERNAL;
359 }
360 uint32_t tempMode = (uint32_t)mode;
361 if (!HdfSbufWriteUint32(reply, tempMode)) {
362 return AUDIO_HAL_ERR_INTERNAL;
363 }
364 return AUDIO_HAL_SUCCESS;
365 }
366
367 /*****************************end*************************/
368 struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleList[] = {
369 {AUDIO_HDI_MGR_GET_FUNCS, HdiServiceGetFuncs},
370 {AUDIO_HDI_MGR_GET_ALL_ADAPTER, HdiServiceGetAllAdapter},
371 {AUDIO_HDI_MGR_LOAD_ADAPTER, HdiServiceLoadAdapter},
372 {AUDIO_HDI_MGR_UNLOAD_ADAPTER, HdiServiceUnloadAdapter},
373 {AUDIO_HDI_ADT_INIT_PORTS, HdiServiceInitAllPorts},
374 {AUDIO_HDI_ADT_GET_PORT_CAPABILITY, HdiServiceGetPortCapability},
375 {AUDIO_HDI_ADT_SET_PASS_MODE, HdiServiceSetPassthroughMode},
376 {AUDIO_HDI_ADT_GET_PASS_MODE, HdiServiceGetPassthroughMode},
377 {AUDIO_HDI_RENDER_CREATE_RENDER, HdiServiceCreatRender},
378 {AUDIO_HDI_RENDER_DESTROY, HdiServiceRenderDestory},
379 {AUDIO_HDI_RENDER_START, HdiServiceRenderStart},
380 {AUDIO_HDI_RENDER_STOP, HdiServiceRenderStop},
381 {AUDIO_HDI_RENDER_PAUSE, HdiServiceRenderPause},
382 {AUDIO_HDI_RENDER_RESUME, HdiServiceRenderResume},
383 {AUDIO_HDI_RENDER_FLUSH, HdiServiceRenderFlush},
384 {AUDIO_HDI_RENDER_GET_FRAME_SIZE, HdiServiceRenderGetFrameSize},
385 {AUDIO_HDI_RENDER_GET_FRAME_COUNT, HdiServiceRenderGetFrameCount},
386 {AUDIO_HDI_RENDER_SET_SAMPLE_ATTR, HdiServiceRenderSetSampleAttr},
387 {AUDIO_HDI_RENDER_GET_SAMPLE_ATTR, HdiServiceRenderGetSampleAttr},
388 {AUDIO_HDI_RENDER_GET_CUR_CHANNEL_ID, HdiServiceRenderGetCurChannelId},
389 {AUDIO_HDI_RENDER_CHECK_SCENE_CAPABILITY, HdiServiceRenderCheckSceneCapability},
390 {AUDIO_HDI_RENDER_SELECT_SCENE, HdiServiceRenderSelectScene},
391 {AUDIO_HDI_RENDER_GET_MUTE, HdiServiceRenderGetMute},
392 {AUDIO_HDI_RENDER_SET_MUTE, HdiServiceRenderSetMute},
393 {AUDIO_HDI_RENDER_SET_VOLUME, HdiServiceRenderSetVolume},
394 {AUDIO_HDI_RENDER_GET_VOLUME, HdiServiceRenderGetVolume},
395 {AUDIO_HDI_RENDER_GET_GAIN_THRESHOLD, HdiServiceRenderGetGainThreshold},
396 {AUDIO_HDI_RENDER_GET_GAIN, HdiServiceRenderGetGain},
397 {AUDIO_HDI_RENDER_SET_GAIN, HdiServiceRenderSetGain},
398 {AUDIO_HDI_RENDER_GET_LATENCY, HdiServiceRenderGetLatency},
399 {AUDIO_HDI_RENDER_RENDER_FRAME, HdiServiceRenderRenderFrame},
400 {AUDIO_HDI_RENDER_GET_RENDER_POSITION, HdiServiceRenderGetRenderPosition},
401 {AUDIO_HDI_RENDER_GET_SPEED, HdiServiceRenderGetSpeed},
402 {AUDIO_HDI_RENDER_SET_SPEED, HdiServiceRenderSetSpeed},
403 {AUDIO_HDI_RENDER_SET_CHANNEL_MODE, HdiServiceRenderSetChannelMode},
404 {AUDIO_HDI_RENDER_GET_CHANNEL_MODE, HdiServiceRenderGetChannelMode},
405 {AUDIO_HDI_RENDER_SET_EXTRA_PARAMS, HdiServiceRenderSetExtraParams},
406 {AUDIO_HDI_RENDER_GET_EXTRA_PARAMS, HdiServiceRenderGetExtraParams},
407 {AUDIO_HDI_RENDER_REQ_MMAP_BUFFER, HdiServiceRenderReqMmapBuffer},
408 {AUDIO_HDI_RENDER_GET_MMAP_POSITION, HdiServiceRenderGetMmapPosition},
409 {AUDIO_HDI_RENDER_TURN_STAND_BY_MODE, HdiServiceRenderTurnStandbyMode},
410 {AUDIO_HDI_RENDER_DEV_DUMP, HdiServiceRenderDevDump},
411 {AUDIO_HDI_RENDER_REG_CALLBACK, HdiServiceRenderRegCallback},
412 {AUDIO_HDI_RENDER_DRAIN_BUFFER, HdiServiceRenderDrainBuffer},
413 };
414
415 static struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleCapList[] = {
416 {AUDIO_HDI_CAPTURE_CREATE_CAPTURE, HdiServiceCreatCapture},
417 {AUDIO_HDI_CAPTURE_DESTROY, HdiServiceCaptureDestory},
418 {AUDIO_HDI_CAPTURE_START, HdiServiceCaptureStart},
419 {AUDIO_HDI_CAPTURE_STOP, HdiServiceCaptureStop},
420 {AUDIO_HDI_CAPTURE_PAUSE, HdiServiceCapturePause},
421 {AUDIO_HDI_CAPTURE_RESUME, HdiServiceCaptureResume},
422 {AUDIO_HDI_CAPTURE_FLUSH, HdiServiceCaptureFlush},
423 {AUDIO_HDI_CAPTURE_GET_FRAME_SIZE, HdiServiceCaptureGetFrameSize},
424 {AUDIO_HDI_CAPTURE_GET_FRAME_COUNT, HdiServiceCaptureGetFrameCount},
425 {AUDIO_HDI_CAPTURE_SET_SAMPLE_ATTR, HdiServiceCaptureSetSampleAttr},
426 {AUDIO_HDI_CAPTURE_GET_SAMPLE_ATTR, HdiServiceCaptureGetSampleAttr},
427 {AUDIO_HDI_CAPTURE_GET_CUR_CHANNEL_ID, HdiServiceCaptureGetCurChannelId},
428 {AUDIO_HDI_CAPTURE_CHECK_SCENE_CAPABILITY, HdiServiceCaptureCheckSceneCapability},
429 {AUDIO_HDI_CAPTURE_SELECT_SCENE, HdiServiceCaptureSelectScene},
430 {AUDIO_HDI_CAPTURE_GET_MUTE, HdiServiceCaptureGetMute},
431 {AUDIO_HDI_CAPTURE_SET_MUTE, HdiServiceCaptureSetMute},
432 {AUDIO_HDI_CAPTURE_SET_VOLUME, HdiServiceCaptureSetVolume},
433 {AUDIO_HDI_CAPTURE_GET_VOLUME, HdiServiceCaptureGetVolume},
434 {AUDIO_HDI_CAPTURE_GET_GAIN_THRESHOLD, HdiServiceCaptureGetGainThreshold},
435 {AUDIO_HDI_CAPTURE_GET_GAIN, HdiServiceCaptureGetGain},
436 {AUDIO_HDI_CAPTURE_SET_GAIN, HdiServiceCaptureSetGain},
437 {AUDIO_HDI_CAPTURE_CAPTURE_FRAME, HdiServiceCaptureCaptureFrame},
438 {AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION, HdiServiceCaptureGetCapturePosition},
439 {AUDIO_HDI_CAPTURE_SET_EXTRA_PARAMS, HdiServiceCaptureSetExtraParams},
440 {AUDIO_HDI_CAPTURE_GET_EXTRA_PARAMS, HdiServiceCaptureGetExtraParams},
441 {AUDIO_HDI_CAPTURE_REQ_MMAP_BUFFER, HdiServiceCaptureReqMmapBuffer},
442 {AUDIO_HDI_CAPTURE_GET_MMAP_POSITION, HdiServiceCaptureGetMmapPosition},
443 {AUDIO_HDI_CAPTURE_TURN_STAND_BY_MODE, HdiServiceCaptureTurnStandbyMode},
444 {AUDIO_HDI_CAPTURE_DEV_DUMP, HdiServiceCaptureDevDump},
445 };
446
HdiServiceDispatch(struct HdfDeviceIoClient * client,int cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)447 static int32_t HdiServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data,
448 struct HdfSBuf *reply)
449 {
450 unsigned int i;
451 if (client == NULL || data == NULL || reply == NULL) {
452 HDF_LOGE("%{public}s: ControlDispatch: input para is NULL.", __func__);
453 return AUDIO_HAL_ERR_INVALID_PARAM;
454 }
455 HDF_LOGE("ControlDispatch: valid cmdId = %{public}d", cmdId);
456
457 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
458 HDF_LOGE("check interface token failed");
459 return AUDIO_HAL_ERR_INVALID_PARAM;
460 }
461 if (cmdId > AUDIO_HDI_CAPTURE_DEV_DUMP || cmdId < 0) {
462 HDF_LOGE("ControlDispatch: invalid cmdId = %{public}d", cmdId);
463 return AUDIO_HAL_ERR_INTERNAL;
464 } else if (cmdId <= AUDIO_HDI_RENDER_DRAIN_BUFFER) {
465 for (i = 0; i < sizeof(g_hdiServiceDispatchCmdHandleList) /
466 sizeof(g_hdiServiceDispatchCmdHandleList[0]); ++i) {
467 if ((cmdId == (int)(g_hdiServiceDispatchCmdHandleList[i].cmd)) &&
468 (g_hdiServiceDispatchCmdHandleList[i].func != NULL)) {
469 return g_hdiServiceDispatchCmdHandleList[i].func(client, data, reply);
470 }
471 }
472 } else {
473 for (i = 0; i < sizeof(g_hdiServiceDispatchCmdHandleCapList) /
474 sizeof(g_hdiServiceDispatchCmdHandleCapList[0]); ++i) {
475 if ((cmdId == (int)(g_hdiServiceDispatchCmdHandleCapList[i].cmd)) &&
476 (g_hdiServiceDispatchCmdHandleCapList[i].func != NULL)) {
477 return g_hdiServiceDispatchCmdHandleCapList[i].func(client, data, reply);
478 }
479 }
480 }
481 return AUDIO_HAL_ERR_INTERNAL;
482 }
483
AudioHdiServerRelease(struct HdfDeviceObject * deviceObject)484 void AudioHdiServerRelease(struct HdfDeviceObject *deviceObject)
485 {
486 LOG_FUN_INFO();
487 /* g_renderAndCaptureManage release */
488 AdaptersServerManageInfomationRecycle();
489
490 if (deviceObject == NULL) {
491 HDF_LOGE("%{public}s: deviceObject is null!", __func__);
492 return;
493 }
494 deviceObject->service = NULL;
495 #ifdef AUDIO_HAL_USER
496 if (g_mpiInitSo == NULL) {
497 return;
498 }
499 int32_t (*mpiExit)() = dlsym(g_mpiInitSo, "AudioMpiSysExit");
500 if (mpiExit == NULL) {
501 return;
502 }
503 mpiExit();
504 dlclose(g_mpiInitSo);
505 #endif
506 return;
507 }
508
AudioHdiServerBind(struct HdfDeviceObject * deviceObject)509 int AudioHdiServerBind(struct HdfDeviceObject *deviceObject)
510 {
511 LOG_FUN_INFO();
512 if (deviceObject == NULL) {
513 HDF_LOGE("%{public}s: deviceObject is null!", __func__);
514 return AUDIO_HAL_ERR_INVALID_PARAM;
515 }
516 static struct IDeviceIoService hdiService = {
517 .Dispatch = HdiServiceDispatch,
518 .Open = NULL,
519 .Release = NULL,
520 };
521 if (HdiServiceGetFuncs()) {
522 return AUDIO_HAL_ERR_INTERNAL;
523 }
524 int ret = HdfDeviceObjectSetInterfaceDesc(deviceObject, "ohos.hdi.audio_service");
525 if (ret != HDF_SUCCESS) {
526 HDF_LOGE("failed to set interface desc");
527 return ret;
528 }
529 deviceObject->service = &hdiService;
530 return AUDIO_HAL_SUCCESS;
531 }
532
AudioHdiServerInit(struct HdfDeviceObject * deviceObject)533 int AudioHdiServerInit(struct HdfDeviceObject *deviceObject)
534 {
535 LOG_FUN_INFO();
536 if (deviceObject == NULL) {
537 HDF_LOGE("%{public}s: deviceObject is null!", __func__);
538 return AUDIO_HAL_ERR_INVALID_PARAM;
539 }
540 if (HdfDeviceSetClass(deviceObject, DEVICE_CLASS_AUDIO) != true) {
541 HDF_LOGE("%{public}s: HdfDeviceSetClass is fail!", __func__);
542 }
543 #ifdef AUDIO_HAL_USER
544 void *sdkHandle;
545 int (*sdkInitSp)() = NULL;
546 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
547 sdkHandle = dlopen(sdkResolvedPath, 1);
548 if (sdkHandle == NULL) {
549 return AUDIO_HAL_ERR_INVALID_PARAM;
550 }
551 sdkInitSp = (int32_t (*)())(dlsym(sdkHandle, "MpiSdkInit"));
552 if (sdkInitSp == NULL) {
553 return AUDIO_HAL_ERR_INVALID_PARAM;
554 }
555 sdkInitSp();
556 #endif
557 return AUDIO_HAL_SUCCESS;
558 }
559
560 struct HdfDriverEntry g_hdiServerEntry = {
561 .moduleVersion = 1,
562 .moduleName = "hdi_audio_server",
563 .Bind = AudioHdiServerBind,
564 .Init = AudioHdiServerInit,
565 .Release = AudioHdiServerRelease,
566 };
567
568 HDF_INIT(g_hdiServerEntry);
569
570