• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "hdf_audio_server_common.h"
17 #include "audio_adapter_info_common.h"
18 #include "audio_events.h"
19 #include "audio_types.h"
20 #include "audio_uhdf_log.h"
21 #include "hdf_audio_events.h"
22 #include "hdf_audio_server.h"
23 #include "hdf_audio_server_capture.h"
24 #include "hdf_audio_server_render.h"
25 #include "hdf_audio_server_manager.h"
26 #include "hdf_device_object.h"
27 #include "osal_mem.h"
28 
29 #define HDF_LOG_TAG HDF_AUDIO_HAL_STUB
30 
31 struct AudioAdapterDescriptor *g_descs = NULL;
32 struct AudioManager *g_serverManager = NULL;
33 
34 #define MAX_AUDIO_ADAPTER_NUM_SERVER    8 // Limit the number of sound cards supported to a maximum of 8
35 
36 #define SERVER_INFO_LEN 128
37 
38 #define SUPPORT_PORT_NUM_MAX 10
39 
40 static struct AudioEvent g_audioEventPnp = {
41     .eventType = HDF_AUDIO_EVENT_UNKOWN,
42     .deviceType = HDF_AUDIO_DEVICE_UNKOWN,
43 };
44 
45 static struct AudioEvent g_audioEventLoad = {
46     .eventType = HDF_AUDIO_EVENT_UNKOWN,
47     .deviceType = HDF_AUDIO_DEVICE_UNKOWN,
48 };
49 
50 static struct AudioEvent g_audioEventService = {
51     .eventType = HDF_AUDIO_EVENT_UNKOWN,
52     .deviceType = HDF_AUDIO_DEVICE_UNKOWN,
53 };
54 
AdaptersServerManageInit(const struct AudioAdapterDescriptor * descs,int32_t num)55 static int32_t AdaptersServerManageInit(const struct AudioAdapterDescriptor *descs, int32_t num)
56 {
57     num = ServerManageGetAdapterNum(num);
58     if (AdapterManageInit(descs, num) != HDF_SUCCESS) {
59         AUDIO_FUNC_LOGE("AdapterManageInit Failed");
60         return HDF_FAILURE;
61     }
62 
63     return HDF_SUCCESS;
64 }
65 
HdiServiceRenderCaptureReadData(struct HdfSBuf * data,const char ** adapterName,uint32_t * pid)66 int32_t HdiServiceRenderCaptureReadData(struct HdfSBuf *data, const char **adapterName, uint32_t *pid)
67 {
68     if (adapterName == NULL || data == NULL || pid == NULL) {
69         return HDF_FAILURE;
70     }
71     if ((*adapterName = HdfSbufReadString(data)) == NULL) {
72         AUDIO_FUNC_LOGE("adapterName Is NULL ");
73         return HDF_FAILURE;
74     }
75     if (!HdfSbufReadUint32(data, pid)) {
76         AUDIO_FUNC_LOGE("read buf fail ");
77         return HDF_FAILURE;
78     }
79     return HDF_SUCCESS;
80 }
81 
WriteAudioSampleAttributes(struct HdfSBuf * reply,const struct AudioSampleAttributes * attrs)82 int32_t WriteAudioSampleAttributes(struct HdfSBuf *reply, const struct AudioSampleAttributes *attrs)
83 {
84     if (reply == NULL || attrs == NULL) {
85         return HDF_FAILURE;
86     }
87     uint32_t tempAttrParam = (uint32_t)attrs->type;
88     if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
89         return HDF_FAILURE;
90     }
91     tempAttrParam = (uint32_t)attrs->interleaved;
92     if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
93         return HDF_FAILURE;
94     }
95     tempAttrParam = (uint32_t)attrs->format;
96     if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
97         return HDF_FAILURE;
98     }
99     if (!HdfSbufWriteUint32(reply, attrs->sampleRate)) {
100         return HDF_FAILURE;
101     }
102     if (!HdfSbufWriteUint32(reply, attrs->channelCount)) {
103         return HDF_FAILURE;
104     }
105     if (!HdfSbufWriteUint32(reply, attrs->period)) {
106         return HDF_FAILURE;
107     }
108     if (!HdfSbufWriteUint32(reply, attrs->frameSize)) {
109         return HDF_FAILURE;
110     }
111     tempAttrParam = (uint32_t)(attrs->isBigEndian);
112     if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
113         return HDF_FAILURE;
114     }
115     tempAttrParam = (uint32_t)(attrs->isSignedData);
116     if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
117         return HDF_FAILURE;
118     }
119     if (!HdfSbufWriteUint32(reply, attrs->startThreshold)) {
120         return HDF_FAILURE;
121     }
122     if (!HdfSbufWriteUint32(reply, attrs->stopThreshold)) {
123         return HDF_FAILURE;
124     }
125     if (!HdfSbufWriteUint32(reply, attrs->silenceThreshold)) {
126         return HDF_FAILURE;
127     }
128     return HDF_SUCCESS;
129 }
130 
ReadAudioSapmleAttrbutes(struct HdfSBuf * data,struct AudioSampleAttributes * attrs)131 int32_t ReadAudioSapmleAttrbutes(struct HdfSBuf *data, struct AudioSampleAttributes *attrs)
132 {
133     if (data == NULL || attrs == NULL) {
134         return HDF_FAILURE;
135     }
136     uint32_t tempAttrParam = 0;
137     if (!HdfSbufReadUint32(data, &tempAttrParam)) {
138         return HDF_FAILURE;
139     }
140     attrs->type = (enum AudioCategory)tempAttrParam;
141     if (!HdfSbufReadUint32(data, &tempAttrParam)) {
142         return HDF_FAILURE;
143     }
144     attrs->interleaved = (bool)tempAttrParam;
145     if (!HdfSbufReadUint32(data, &tempAttrParam)) {
146         return HDF_FAILURE;
147     }
148     attrs->format = (enum AudioFormat)tempAttrParam;
149     if (!HdfSbufReadUint32(data, &(attrs->sampleRate))) {
150         return HDF_FAILURE;
151     }
152     if (!HdfSbufReadUint32(data, &(attrs->channelCount))) {
153         return HDF_FAILURE;
154     }
155     if (!HdfSbufReadUint32(data, &(attrs->period))) {
156         return HDF_FAILURE;
157     }
158     if (!HdfSbufReadUint32(data, &(attrs->frameSize))) {
159         return HDF_FAILURE;
160     }
161     if (!HdfSbufReadUint32(data, &tempAttrParam)) {
162         return HDF_FAILURE;
163     }
164     attrs->isBigEndian = (bool)tempAttrParam;
165     if (!HdfSbufReadUint32(data, &tempAttrParam)) {
166         return HDF_FAILURE;
167     }
168     attrs->isSignedData = (bool)tempAttrParam;
169     if (!HdfSbufReadUint32(data, &(attrs->startThreshold))) {
170         return HDF_FAILURE;
171     }
172     if (!HdfSbufReadUint32(data, &(attrs->stopThreshold))) {
173         return HDF_FAILURE;
174     }
175     if (!HdfSbufReadUint32(data, &(attrs->silenceThreshold))) {
176         return HDF_FAILURE;
177     }
178     return HDF_SUCCESS;
179 }
180 
AudioAdapterListCheckAndGetRender(struct AudioRender ** render,struct HdfSBuf * data)181 int32_t AudioAdapterListCheckAndGetRender(struct AudioRender **render, struct HdfSBuf *data)
182 {
183     if (render == NULL || data == NULL) {
184         AUDIO_FUNC_LOGE("render or data is null!");
185         return HDF_FAILURE;
186     }
187     struct AudioRender *renderTemp = NULL;
188     const char *adapterName = NULL;
189     uint32_t pid = 0;
190     if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
191         AUDIO_FUNC_LOGE("HdiServiceRenderStart: HdiServiceRenderCaptureReadData fail ");
192         return HDF_FAILURE;
193     }
194     int ret = AudioAdapterListGetRender(adapterName, &renderTemp, pid);
195     if (ret < 0) {
196         return ret;
197     }
198     if (renderTemp == NULL) {
199         return HDF_FAILURE;
200     }
201     *render = renderTemp;
202     return HDF_SUCCESS;
203 }
204 
AudioAdapterListCheckAndGetCapture(struct AudioCapture ** capture,struct HdfSBuf * data)205 int32_t AudioAdapterListCheckAndGetCapture(struct AudioCapture **capture, struct HdfSBuf *data)
206 {
207     if (capture == NULL || data == NULL) {
208         AUDIO_FUNC_LOGE("capture or data is null!");
209         return HDF_FAILURE;
210     }
211     struct AudioCapture *captureTemp = NULL;
212     const char *adapterName = NULL;
213     uint32_t pid = 0;
214     if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
215         AUDIO_FUNC_LOGE("HdiServiceCaptureStart: HdiServiceRenderCaptureReadData fail ");
216         return HDF_FAILURE;
217     }
218     int ret = AudioAdapterListGetCapture(adapterName, &captureTemp, pid);
219     if (ret < 0) {
220         return ret;
221     }
222     if (captureTemp == NULL) {
223         return HDF_FAILURE;
224     }
225     *capture = captureTemp;
226     return HDF_SUCCESS;
227 }
228 
HdiServicePositionWrite(struct HdfSBuf * reply,uint64_t frames,struct AudioTimeStamp time)229 int32_t HdiServicePositionWrite(struct HdfSBuf *reply,
230     uint64_t frames, struct AudioTimeStamp time)
231 {
232     if (reply == NULL) {
233         return HDF_FAILURE;
234     }
235     if (!HdfSbufWriteUint64(reply, frames)) {
236         return HDF_FAILURE;
237     }
238     if (!HdfSbufWriteInt64(reply, time.tvSec)) {
239         return HDF_FAILURE;
240     }
241     if (!HdfSbufWriteInt64(reply, time.tvNSec)) {
242         return HDF_FAILURE;
243     }
244     return HDF_SUCCESS;
245 }
246 
HdiServiceReqMmapBuffer(struct AudioMmapBufferDescriptor * desc,struct HdfSBuf * data)247 int32_t HdiServiceReqMmapBuffer(struct AudioMmapBufferDescriptor *desc, struct HdfSBuf *data)
248 {
249     int32_t ret;
250     if (desc == NULL || data == NULL) {
251         AUDIO_FUNC_LOGE("desc or data is null!");
252         return AUDIO_HAL_ERR_INTERNAL;
253     }
254     uint64_t memAddr = 0;
255     if (!HdfSbufReadUint64(data, &memAddr)) {
256         AUDIO_FUNC_LOGE("memAddr Is NULL");
257         return AUDIO_HAL_ERR_INTERNAL;
258     }
259     desc->memoryAddress = (void *)(uintptr_t)memAddr;
260     ret = HdfSbufReadFileDescriptor(data);
261     if (ret < 0) {
262         return AUDIO_HAL_ERR_INTERNAL;
263     }
264     desc->memoryFd = ret;
265     if (!HdfSbufReadInt32(data, &desc->totalBufferFrames)) {
266         return AUDIO_HAL_ERR_INTERNAL;
267     }
268     if (!HdfSbufReadInt32(data, &desc->transferFrameSize)) {
269         return AUDIO_HAL_ERR_INTERNAL;
270     }
271     if (!HdfSbufReadInt32(data, &desc->isShareable)) {
272         return AUDIO_HAL_ERR_INTERNAL;
273     }
274     if (!HdfSbufReadUint32(data, &desc->offset)) {
275         return AUDIO_HAL_ERR_INTERNAL;
276     }
277     return AUDIO_HAL_SUCCESS;
278 }
279 
AudioPortBlockMarshalling(struct HdfSBuf * data,const struct AudioPort * dataBlock)280 static bool AudioPortBlockMarshalling(struct HdfSBuf *data, const struct AudioPort *dataBlock)
281 {
282     if (data == NULL) {
283         HDF_LOGE("%{public}s: invalid sbuf", __func__);
284         return false;
285     }
286     if (dataBlock == NULL) {
287         HDF_LOGE("%{public}s: invalid data block", __func__);
288         return false;
289     }
290 
291     if (!HdfSbufWriteInt32(data, dataBlock->dir)) {
292         HDF_LOGE("%{public}s: write dataBlock->dir failed!", __func__);
293         return false;
294     }
295 
296     if (!HdfSbufWriteUint32(data, dataBlock->portId)) {
297         HDF_LOGE("%{public}s: write dataBlock->portId failed!", __func__);
298         return false;
299     }
300 
301     if (!HdfSbufWriteString(data, dataBlock->portName)) {
302         HDF_LOGE("%{public}s: write dataBlock->portName failed!", __func__);
303         return false;
304     }
305 
306     return true;
307 }
308 
AudioAdapterDescriptorBlockMarshalling(struct HdfSBuf * data,const struct AudioAdapterDescriptor * dataBlock)309 static bool AudioAdapterDescriptorBlockMarshalling(struct HdfSBuf *data, const struct AudioAdapterDescriptor *dataBlock)
310 {
311     if (data == NULL) {
312         HDF_LOGE("%{public}s: invalid sbuf", __func__);
313         return false;
314     }
315 
316     if (dataBlock == NULL) {
317         HDF_LOGE("%{public}s: invalid data block", __func__);
318         return false;
319     }
320 
321     if (!HdfSbufWriteString(data, dataBlock->adapterName)) {
322         HDF_LOGE("%{public}s: write dataBlock->adapterName failed!", __func__);
323         return false;
324     }
325 
326     if (!HdfSbufWriteUint32(data, dataBlock->portNum)) {
327         HDF_LOGE("%{public}s: write dataBlock->portNum failed!", __func__);
328         return false;
329     }
330 
331     if (dataBlock->portNum == 0 || dataBlock->portNum > SUPPORT_PORT_NUM_MAX) {
332         HDF_LOGE("%{public}s: error portNum is %{public}u", __func__, dataBlock->portNum);
333         return false;
334     }
335 
336     for (uint32_t i = 0; i < dataBlock->portNum; i++) {
337         if (!AudioPortBlockMarshalling(data, &(dataBlock->ports)[i])) {
338             HDF_LOGE("%{public}s: write (dataBlock->ports)[i] failed!", __func__);
339             return false;
340         }
341     }
342 
343     return true;
344 }
345 
AudioSubPortCapabilityBlockMarshalling(struct HdfSBuf * data,const struct AudioPortCapability * dataBlock)346 static bool AudioSubPortCapabilityBlockMarshalling(struct HdfSBuf *data, const struct AudioPortCapability *dataBlock)
347 {
348     if (!HdfSbufWriteUint32(data, dataBlock->subPortsNum)) {
349         HDF_LOGE("%{public}s: write dataBlock->subPortsLen failed!", __func__);
350         return false;
351     }
352 
353     for (uint32_t i = 0; i < dataBlock->subPortsNum; i++) {
354         struct AudioSubPortCapability *item = &dataBlock->subPorts[i];
355         if (!HdfSbufWriteUint32(data, item->portId)) {
356             HDF_LOGE("%{public}s: write dataBlock->portId failed!", __func__);
357             return false;
358         }
359 
360         if (!HdfSbufWriteString(data, item->desc)) {
361             HDF_LOGE("%{public}s: write dataBlock->desc failed!", __func__);
362             return false;
363         }
364 
365         if (!HdfSbufWriteInt32(data, (int32_t)item->mask)) {
366             HDF_LOGE("%{public}s: write dataBlock->mask failed!", __func__);
367             return false;
368         }
369     }
370 
371     return true;
372 }
373 
AudioPortCapabilityBlockMarshalling(struct HdfSBuf * data,const struct AudioPortCapability * dataBlock)374 bool AudioPortCapabilityBlockMarshalling(struct HdfSBuf *data, const struct AudioPortCapability *dataBlock)
375 {
376     if (data == NULL || dataBlock == NULL) {
377         HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
378         return false;
379     }
380 
381     if (!HdfSbufWriteUint32(data, dataBlock->deviceType)) {
382         HDF_LOGE("%{public}s: write dataBlock->deviceType failed!", __func__);
383         return false;
384     }
385 
386     if (!HdfSbufWriteUint32(data, dataBlock->deviceId)) {
387         HDF_LOGE("%{public}s: write dataBlock->deviceId failed!", __func__);
388         return false;
389     }
390 
391     if (!HdfSbufWriteInt8(data, dataBlock->hardwareMode ? 1 : 0)) {
392         HDF_LOGE("%{public}s: write dataBlock->hardwareMode failed!", __func__);
393         return false;
394     }
395 
396     if (!HdfSbufWriteUint32(data, dataBlock->formatNum)) {
397         HDF_LOGE("%{public}s: write dataBlock->formatNum failed!", __func__);
398         return false;
399     }
400 
401     if (!HdfSbufWriteInt32(data, *(dataBlock->formats))) {
402         HDF_LOGE("%{public}s: failed to write dataBlock->formats", __func__);
403         return false;
404     }
405 
406     if (!HdfSbufWriteUint32(data, dataBlock->sampleRateMasks)) {
407         HDF_LOGE("%{public}s: write dataBlock->sampleRateMasks failed!", __func__);
408         return false;
409     }
410 
411     if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->channelMasks)) {
412         HDF_LOGE("%{public}s: write dataBlock->channelMasks failed!", __func__);
413         return false;
414     }
415 
416     if (!HdfSbufWriteUint32(data, dataBlock->channelCount)) {
417         HDF_LOGE("%{public}s: write dataBlock->channelCount failed!", __func__);
418         return false;
419     }
420 
421     if (!AudioSubPortCapabilityBlockMarshalling(data, dataBlock)) {
422         HDF_LOGE("%{public}s: write (dataBlock->subPorts)[i] failed!", __func__);
423         return false;
424     }
425 
426     return true;
427 }
428 
429 /**************************public************************/
HdiServiceGetFuncs()430 int32_t HdiServiceGetFuncs()
431 {
432     AUDIO_FUNC_LOGD("enter");
433     if (g_serverManager != NULL) {
434         return AUDIO_HAL_SUCCESS;
435     }
436 
437     char *error = NULL;
438     struct AudioManager *(*managerFuncs)(void);
439     const char *hdiAudioVendorLibPath = HDF_LIBRARY_FULL_PATH("libhdi_audio");
440     void *handle = dlopen(hdiAudioVendorLibPath, RTLD_LAZY);
441     if (handle == NULL) {
442         error = dlerror();
443         AUDIO_FUNC_LOGE("audio load path %{public}s, dlopen err=%{public}s", hdiAudioVendorLibPath, error);
444         return AUDIO_HAL_ERR_INTERNAL;
445     }
446     managerFuncs = dlsym(handle, "GetAudioManagerFuncs");
447     if (managerFuncs == NULL) {
448         error = dlerror();
449         AUDIO_FUNC_LOGE("dlsym GetAudioManagerFuncs failed, err=%{public}s", error);
450         dlclose(handle);
451         handle = NULL;
452         return AUDIO_HAL_ERR_INTERNAL;
453     }
454     g_serverManager = managerFuncs();
455     if (g_serverManager == NULL) {
456         error = dlerror();
457         AUDIO_FUNC_LOGE("dlsym GetAudioManagerFuncs err=%{public}s", error);
458         dlclose(handle);
459         handle = NULL;
460         return AUDIO_HAL_ERR_INTERNAL;
461     }
462     dlclose(handle);
463     handle = NULL;
464     AUDIO_FUNC_LOGD("end");
465     return AUDIO_HAL_SUCCESS;
466 }
467 
AudioHdiServerRelease(void)468 void AudioHdiServerRelease(void)
469 {
470     AUDIO_FUNC_LOGI("enter to %{public}s!", __func__);
471 
472     if (g_serverManager == NULL) {
473         AUDIO_FUNC_LOGE("manager func is null!");
474         return;
475     }
476     ReleaseAudioManagerObjectComm(g_serverManager);
477     AUDIO_FUNC_LOGD("%{public}s success", __func__);
478     return;
479 }
480 
HdiServiceGetAllAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)481 int32_t HdiServiceGetAllAdapter(const struct HdfDeviceIoClient *client,
482     struct HdfSBuf *data, struct HdfSBuf *reply)
483 {
484     (void)data;
485     (void)client;
486 
487     if (reply == NULL) {
488         AUDIO_FUNC_LOGE("reply is NULL!");
489         return AUDIO_HAL_ERR_INVALID_PARAM;
490     }
491 
492     int32_t index;
493     int32_t size = 0;
494     struct AudioAdapterDescriptor *descs = NULL;
495 
496     int32_t ret = g_serverManager->GetAllAdapters(g_serverManager, &descs, &size);
497     if (ret < 0) {
498         AUDIO_FUNC_LOGE("g_manager->GetAllAdapters error");
499         return AUDIO_HAL_ERR_INTERNAL;
500     }
501     if (size > MAX_AUDIO_ADAPTER_NUM_SERVER || size <= 0 || descs == NULL) {
502         AUDIO_FUNC_LOGE("size or g_descs is error");
503         return AUDIO_HAL_ERR_NOT_SUPPORT;
504     }
505 
506     if (!HdfSbufWriteUint32(reply, size)) {
507         AUDIO_FUNC_LOGE("write descs failed!");
508         return AUDIO_HAL_ERR_INTERNAL;
509     }
510 
511     for (index = 0; index < size; index++) {
512         if (!AudioAdapterDescriptorBlockMarshalling(reply, &descs[index])) {
513             AUDIO_FUNC_LOGE("write &descs[%{public}d] failed!", index);
514             return AUDIO_HAL_ERR_INTERNAL;
515         }
516     }
517 
518     g_descs = descs;
519 
520     ret = AdaptersServerManageInit(descs, size);
521     if (ret != AUDIO_HAL_SUCCESS) {
522         AUDIO_FUNC_LOGE("AdapterServerManageInit fail");
523         return ret;
524     }
525     return AUDIO_HAL_SUCCESS;
526 }
527 
HdiServiceReleaseAudioManagerObject(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)528 int32_t HdiServiceReleaseAudioManagerObject(const struct HdfDeviceIoClient *client,
529     struct HdfSBuf *data, struct HdfSBuf *reply)
530 {
531     (void)data;
532     (void)reply;
533     (void)client;
534     AUDIO_FUNC_LOGI();
535 
536     if (g_descs == NULL) {
537         AUDIO_FUNC_LOGI("g_descs is NULL");
538         return AUDIO_HAL_SUCCESS;
539     }
540 
541     AudioAdapterReleaseDescs(g_descs, AudioServerGetAdapterNum());
542 
543     g_descs = NULL;
544     return AUDIO_HAL_SUCCESS;
545 }
546 
SwitchAdapter(struct AudioAdapterDescriptor * descs,const char * adapterNameCase,enum AudioPortDirection portFlag,struct AudioPort * renderPort,const int size)547 static int SwitchAdapter(struct AudioAdapterDescriptor *descs, const char *adapterNameCase,
548     enum AudioPortDirection portFlag, struct AudioPort *renderPort, const int size)
549 {
550     if (descs == NULL || adapterNameCase == NULL || renderPort == NULL) {
551         return HDF_FAILURE;
552     }
553     for (int index = 0; index < size; index++) {
554         struct AudioAdapterDescriptor *desc = &descs[index];
555         if (desc == NULL) {
556             continue;
557         }
558         if (desc->adapterName == NULL) {
559             return HDF_FAILURE;
560         }
561 
562         if (strcmp(desc->adapterName, adapterNameCase) != 0) {
563             continue;
564         }
565         for (uint32_t port = 0; port < desc->portNum; port++) {
566             if (desc->ports[port].dir == portFlag) {
567                 *renderPort = desc->ports[port];
568                 AUDIO_FUNC_LOGI("portFlag=%{public}d index=%{public}d success!", portFlag, index);
569                 return index;
570             }
571         }
572     }
573     AUDIO_FUNC_LOGE("out! adapterNameCase=%{public}s", adapterNameCase);
574     return HDF_FAILURE;
575 }
576 
577 /* Adapter Check */
578 static enum AudioServerType g_loadServerFlag = AUDIO_SERVER_BOTTOM;
AudioHdiGetLoadServerFlag(void)579 enum AudioServerType AudioHdiGetLoadServerFlag(void)
580 {
581     return g_loadServerFlag;
582 }
583 
AudioHdiSetLoadServerFlag(enum AudioServerType serverType)584 void AudioHdiSetLoadServerFlag(enum AudioServerType serverType)
585 {
586     g_loadServerFlag = serverType;
587 }
588 
AudioHdiClearLoadServerFlag(void)589 void AudioHdiClearLoadServerFlag(void)
590 {
591     g_loadServerFlag = AUDIO_SERVER_BOTTOM;
592 }
593 
MatchAppropriateAdapter(enum AudioAdapterType adapterType)594 static int32_t MatchAppropriateAdapter(enum AudioAdapterType adapterType)
595 {
596     switch (adapterType) {
597         case AUDIO_ADAPTER_PRIMARY:
598         case AUDIO_ADAPTER_PRIMARY_EXT:
599         case AUDIO_ADAPTER_HDMI:
600             if (AudioHdiGetLoadServerFlag() != AUDIO_SERVER_PRIMARY) {
601                 AUDIO_FUNC_LOGE("Can't loadAdapterPrimary.");
602                 return AUDIO_HAL_ERR_INTERNAL;
603             }
604             break;
605         case AUDIO_ADAPTER_USB:
606             if (AudioHdiGetLoadServerFlag() != AUDIO_SERVER_USB) {
607                 AUDIO_FUNC_LOGE("Can't loadAdapterUsb.");
608                 return AUDIO_HAL_ERR_INTERNAL;
609             }
610             break;
611         case AUDIO_ADAPTER_A2DP:
612             if (AudioHdiGetLoadServerFlag() != AUDIO_SERVER_A2DP) {
613                 AUDIO_FUNC_LOGE("Can't loadAdapterA2dp.");
614                 return AUDIO_HAL_ERR_INTERNAL;
615             }
616             break;
617         default:
618             AUDIO_FUNC_LOGE("An unsupported Adapter.");
619             return AUDIO_HAL_ERR_NOT_SUPPORT;
620     }
621 
622     return AUDIO_HAL_SUCCESS;
623 }
624 
AudioServiceUpateDevice(struct HdfDeviceObject * device,const char * servInfo)625 static int AudioServiceUpateDevice(struct HdfDeviceObject *device, const char *servInfo)
626 {
627     if (device == NULL || servInfo == NULL) {
628         AUDIO_FUNC_LOGE("device or servInfo is null!");
629         return AUDIO_HAL_ERR_INVALID_PARAM;
630     }
631     if (HdfDeviceObjectSetServInfo(device, servInfo) != HDF_SUCCESS) {
632         AUDIO_FUNC_LOGW("HdfDeviceObjectSetServInfo failed!");
633         return AUDIO_HAL_ERR_INTERNAL;
634     }
635     if (HdfDeviceObjectUpdate(device) != AUDIO_HAL_SUCCESS) {
636         AUDIO_FUNC_LOGW("HdfDeviceObjectUpdate failed!");
637         return AUDIO_HAL_ERR_INTERNAL;
638     }
639 
640     return AUDIO_HAL_SUCCESS;
641 }
642 
AudioServiceStateChange(struct HdfDeviceObject * device,struct AudioEvent * audioSrvEvent)643 int32_t AudioServiceStateChange(struct HdfDeviceObject *device, struct AudioEvent *audioSrvEvent)
644 {
645     if (device == NULL || audioSrvEvent == NULL) {
646         AUDIO_FUNC_LOGE("device or audioSrvEvent is null!");
647         return AUDIO_HAL_ERR_INVALID_PARAM;
648     }
649     g_audioEventService.eventType = audioSrvEvent->eventType;
650     g_audioEventService.deviceType = audioSrvEvent->deviceType;
651     char strMsg[AUDIO_PNP_MSG_LEN_MAX] = {0};
652     int ret = snprintf_s(strMsg, AUDIO_PNP_MSG_LEN_MAX, AUDIO_PNP_MSG_LEN_MAX - 1,
653                          "EVENT_SERVICE_TYPE=0x%x;EVENT_LOAD_TYPE=0x%x;DEVICE_TYPE=0x%x",
654                          g_audioEventService.eventType,
655                          g_audioEventLoad.eventType,
656                          g_audioEventService.deviceType);
657     if (ret >= 0) {
658         if (AudioServiceUpateDevice(device, (const char *)strMsg) != AUDIO_HAL_SUCCESS) {
659             AUDIO_FUNC_LOGW("AudioServiceUpate fail!");
660             return AUDIO_HAL_ERR_INTERNAL;
661         }
662     }
663     return AUDIO_HAL_SUCCESS;
664 }
665 
AudioLoadStateChange(struct HdfDeviceObject * device,struct AudioEvent * audioLoadEvent)666 static int32_t AudioLoadStateChange(struct HdfDeviceObject *device, struct AudioEvent *audioLoadEvent)
667 {
668     if (device == NULL || audioLoadEvent == NULL) {
669         AUDIO_FUNC_LOGE("device or audioLoadEvent is null!");
670         return AUDIO_HAL_ERR_INVALID_PARAM;
671     }
672     g_audioEventLoad.eventType = audioLoadEvent->eventType;
673     g_audioEventLoad.deviceType = audioLoadEvent->deviceType;
674     char strMsg[AUDIO_PNP_MSG_LEN_MAX] = {0};
675     int ret = snprintf_s(strMsg, AUDIO_PNP_MSG_LEN_MAX, AUDIO_PNP_MSG_LEN_MAX - 1,
676                          "EVENT_SERVICE_TYPE=0x%x;EVENT_LOAD_TYPE=0x%x;DEVICE_TYPE=0x%x",
677                          g_audioEventService.eventType,
678                          g_audioEventLoad.eventType,
679                          g_audioEventLoad.deviceType);
680     if (ret >= 0) {
681         if (AudioServiceUpateDevice(device, (const char *)strMsg) != AUDIO_HAL_SUCCESS) {
682             AUDIO_FUNC_LOGE("AudioLoadUpate fail!");
683             return AUDIO_HAL_ERR_INTERNAL;
684         }
685     }
686     return AUDIO_HAL_SUCCESS;
687 }
688 
HdiServiceDevOnLine(struct HdfDeviceObject * device,struct AudioManager * manager,const struct AudioAdapterDescriptor * desc,struct AudioAdapter ** adapter,const char * adapterName)689 static int32_t HdiServiceDevOnLine(struct HdfDeviceObject *device, struct AudioManager *manager,
690     const struct AudioAdapterDescriptor *desc, struct AudioAdapter **adapter, const char* adapterName)
691 {
692     if (device == NULL || manager == NULL || desc == NULL || adapter == NULL || adapterName == NULL) {
693         AUDIO_FUNC_LOGE("param is null!");
694         return AUDIO_HAL_ERR_INVALID_PARAM;
695     }
696     int32_t ret = manager->LoadAdapter(manager, desc, adapter);
697     if (ret < 0) {
698         g_audioEventLoad.eventType = HDF_AUDIO_LOAD_FAILURE;
699     } else {
700         g_audioEventLoad.eventType = HDF_AUDIO_LOAD_SUCCESS;
701     }
702     if (AudioLoadStateChange(device, &g_audioEventLoad) != AUDIO_HAL_SUCCESS) {
703         AUDIO_FUNC_LOGE("AudioLoadStateChange fail!");
704     }
705     if (*adapter == NULL) {
706         AUDIO_FUNC_LOGE("load audio device failed");
707         return AUDIO_HAL_ERR_INVALID_PARAM;
708     }
709     if (AudioAdapterListAdd(adapterName, *adapter)) {
710         AUDIO_FUNC_LOGE("AudioAdapterListAdd error!");
711         manager->UnloadAdapter(manager, *adapter);
712         return AUDIO_HAL_ERR_INTERNAL;
713     }
714     return AUDIO_HAL_SUCCESS;
715 }
716 
HdiServiceDevOffLine(struct HdfDeviceObject * device)717 static int32_t HdiServiceDevOffLine(struct HdfDeviceObject *device)
718 {
719     if (device == NULL) {
720         AUDIO_FUNC_LOGE("device is null!");
721         return AUDIO_HAL_ERR_INVALID_PARAM;
722     }
723     g_audioEventLoad.eventType = HDF_AUDIO_LOAD_FAILURE;
724     if (AudioLoadStateChange(device, &g_audioEventLoad) != AUDIO_HAL_SUCCESS) {
725         AUDIO_FUNC_LOGE("AudioLoadStateChange fail!");
726         return AUDIO_HAL_ERR_INTERNAL;
727     }
728     return AUDIO_HAL_SUCCESS;
729 }
730 
HdiServiceLoadAdapterSubUsb(struct HdfDeviceObject * device,struct AudioManager * manager,const struct AudioAdapterDescriptor * desc,struct AudioAdapter ** adapter,const char * adapterName)731 static int32_t HdiServiceLoadAdapterSubUsb(struct HdfDeviceObject *device, struct AudioManager *manager,
732     const struct AudioAdapterDescriptor *desc, struct AudioAdapter **adapter, const char* adapterName)
733 {
734     if (device == NULL || manager == NULL || desc == NULL || adapter == NULL || adapterName == NULL) {
735         AUDIO_FUNC_LOGE("param is null!");
736         return AUDIO_HAL_ERR_INVALID_PARAM;
737     }
738 
739     if (g_audioEventPnp.eventType == HDF_AUDIO_DEVICE_REMOVE || g_audioEventPnp.eventType == HDF_AUDIO_EVENT_UNKOWN) {
740         HdiServiceDevOffLine(device);
741         AUDIO_FUNC_LOGE("eventType=0x%{public}x", g_audioEventPnp.eventType);
742         return AUDIO_HAL_ERR_NOT_SUPPORT;
743     } else if (g_audioEventPnp.eventType == HDF_AUDIO_DEVICE_ADD) {
744         return HdiServiceDevOnLine(device, manager, desc, adapter, adapterName);
745     } else {
746         AUDIO_FUNC_LOGE("eventType=0x%{public}x nothing", g_audioEventPnp.eventType);
747         return AUDIO_HAL_ERR_INTERNAL;
748     }
749 }
750 
HdiServiceLoadAdapterSub(struct HdfDeviceObject * device,struct AudioManager * manager,const struct AudioAdapterDescriptor * desc,struct AudioAdapter ** adapter,const char * adapterName)751 static int32_t HdiServiceLoadAdapterSub(struct HdfDeviceObject *device, struct AudioManager *manager,
752     const struct AudioAdapterDescriptor *desc, struct AudioAdapter **adapter, const char* adapterName)
753 {
754     AUDIO_FUNC_LOGD("enter");
755     if (device == NULL || manager == NULL || desc == NULL || adapter == NULL || adapterName == NULL) {
756         AUDIO_FUNC_LOGE("param is null!");
757         return AUDIO_HAL_ERR_INVALID_PARAM;
758     }
759     enum AudioAdapterType sndCardType = MatchAdapterType(adapterName, desc->ports[0].portId);
760     int32_t ret = MatchAppropriateAdapter(sndCardType);
761     if (ret != AUDIO_HAL_SUCCESS) {
762         AUDIO_FUNC_LOGE("load audio device not matched");
763         return AUDIO_HAL_ERR_INTERNAL;
764     }
765     switch (sndCardType) {
766         case AUDIO_ADAPTER_PRIMARY:
767         case AUDIO_ADAPTER_PRIMARY_EXT:
768         case AUDIO_ADAPTER_HDMI:
769             g_audioEventService.eventType = HDF_AUDIO_SERVICE_VALID;
770             g_audioEventLoad.deviceType = HDF_AUDIO_PRIMARY_DEVICE;
771             return HdiServiceDevOnLine(device, manager, desc, adapter, adapterName);
772         case AUDIO_ADAPTER_USB:
773             g_audioEventLoad.deviceType = HDF_AUDIO_USB_DEVICE;
774             return HdiServiceLoadAdapterSubUsb(device, manager, desc, adapter, adapterName);
775         case AUDIO_ADAPTER_A2DP:
776             return AUDIO_HAL_ERR_NOT_SUPPORT;
777         default:
778             return AUDIO_HAL_ERR_NOT_SUPPORT;
779     }
780 }
781 
HdiServiceLoadAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)782 int32_t HdiServiceLoadAdapter(const struct HdfDeviceIoClient *client,
783     struct HdfSBuf *data, struct HdfSBuf *reply)
784 {
785     AUDIO_FUNC_LOGD("enter");
786     if (client == NULL || data == NULL || reply == NULL) {
787         return AUDIO_HAL_ERR_INVALID_PARAM;
788     }
789     struct AudioAdapter *adapter = NULL;
790     struct AudioPort renderPort;
791     const char *adapterName = NULL;
792     uint32_t tempDir = 0;
793     if ((adapterName = HdfSbufReadString(data)) == NULL) {
794         AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
795         return AUDIO_HAL_ERR_INVALID_PARAM;
796     }
797     int32_t ret = AudioAdapterCheckListExist(adapterName);
798     if (ret == AUDIO_HAL_ERR_INVALID_PARAM) {
799         return AUDIO_HAL_ERR_INTERNAL;
800     }
801     if (ret == AUDIO_HAL_SUCCESS) {
802         AUDIO_FUNC_LOGE("adapte[%{public}s] already exist !", adapterName);
803         return AUDIO_HAL_SUCCESS;
804     }
805     if (!HdfSbufReadUint32(data, &tempDir)) {
806         AUDIO_FUNC_LOGE("sbuf read tempDir failed!");
807         return AUDIO_HAL_ERR_INTERNAL;
808     }
809     enum AudioPortDirection port = (enum AudioPortDirection)tempDir;
810     struct AudioManager *manager = g_serverManager;
811     if (adapterName == NULL || manager == NULL || g_descs == NULL) {
812         AUDIO_FUNC_LOGE("Point is NULL!");
813         return AUDIO_HAL_ERR_INTERNAL;
814     }
815     int index = SwitchAdapter(g_descs, adapterName, port,
816         &renderPort, ServerManageGetAdapterNum(AudioServerGetAdapterNum()));
817     if (index < 0) {
818         return AUDIO_HAL_ERR_NOT_SUPPORT;
819     }
820     struct AudioAdapterDescriptor *desc = &g_descs[index];
821     ret = HdiServiceLoadAdapterSub(client->device, manager, desc, &adapter, adapterName);
822     return ret;
823 }
824 
HdiServiceInitAllPorts(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)825 int32_t HdiServiceInitAllPorts(const struct HdfDeviceIoClient *client,
826     struct HdfSBuf *data, struct HdfSBuf *reply)
827 {
828     if (client == NULL || data == NULL || reply == NULL) {
829         return AUDIO_HAL_ERR_INVALID_PARAM;
830     }
831     const char *adapterName = NULL;
832     struct AudioAdapter *adapter = NULL;
833     if ((adapterName = HdfSbufReadString(data)) == NULL) {
834         AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
835         return AUDIO_HAL_ERR_INVALID_PARAM;
836     }
837     if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
838         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
839         return AUDIO_HAL_ERR_INTERNAL;
840     }
841     if (adapter == NULL) {
842         AUDIO_FUNC_LOGE("adapter is NULL");
843         return AUDIO_HAL_ERR_INTERNAL;
844     }
845     if (adapter->InitAllPorts(adapter)) {
846         AUDIO_FUNC_LOGE("InitAllPorts fail");
847         return AUDIO_HAL_ERR_INTERNAL;
848     }
849     return AUDIO_HAL_SUCCESS;
850 }
851 
HdiServiceUnloadAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)852 int32_t HdiServiceUnloadAdapter(const struct HdfDeviceIoClient *client,
853     struct HdfSBuf *data, struct HdfSBuf *reply)
854 {
855     if (client == NULL || data == NULL || reply == NULL) {
856         return AUDIO_HAL_ERR_INVALID_PARAM;
857     }
858     struct AudioAdapter *adapter = NULL;
859     const char *adapterName = NULL;
860     int ret;
861     struct AudioManager *manager = g_serverManager;
862     if (manager == NULL) {
863         AUDIO_FUNC_LOGE("Point is NULL!");
864         return AUDIO_HAL_ERR_INVALID_PARAM;
865     }
866     if ((adapterName = HdfSbufReadString(data)) == NULL) {
867         AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
868         return AUDIO_HAL_ERR_INVALID_PARAM;
869     }
870     ret = AudioAdapterListDestory(adapterName, &adapter);
871     if (ret == AUDIO_HAL_ERR_INTERNAL) {
872         AUDIO_FUNC_LOGI("Other dev Use the adapter");
873         return AUDIO_HAL_SUCCESS;
874     } else if (ret == AUDIO_HAL_ERR_INVALID_PARAM) {
875         AUDIO_FUNC_LOGE("param invalid!");
876         return AUDIO_HAL_ERR_INTERNAL;
877     }
878     if (adapter == NULL) {
879         return AUDIO_HAL_ERR_INVALID_PARAM;
880     }
881     manager->UnloadAdapter(manager, adapter);
882     g_audioEventLoad.eventType = HDF_AUDIO_UNLOAD;
883     if (AudioLoadStateChange(client->device, &g_audioEventLoad) != AUDIO_HAL_SUCCESS) {
884         AUDIO_FUNC_LOGE("AudioLoadStateChange fail!");
885     }
886     AUDIO_FUNC_LOGI("Unload the adapter success!");
887     return AUDIO_HAL_SUCCESS;
888 }
889 
HdiServiceGetPortCapability(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)890 int32_t HdiServiceGetPortCapability(const struct HdfDeviceIoClient *client,
891     struct HdfSBuf *data, struct HdfSBuf *reply)
892 {
893     if (client == NULL || data == NULL || reply == NULL) {
894         return AUDIO_HAL_ERR_INVALID_PARAM;
895     }
896     struct AudioPort port;
897     struct AudioPortCapability capability;
898     struct AudioAdapter *adapter = NULL;
899 
900     const char *adapterName = HdfSbufReadString(data);
901     if (adapterName == NULL) {
902         AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
903         return AUDIO_HAL_ERR_INVALID_PARAM;
904     }
905 
906     if (!HdfSbufReadUint32(data, (uint32_t *)&port.dir)) {
907         AUDIO_FUNC_LOGE("read port.dir error");
908         return AUDIO_HAL_ERR_INTERNAL;
909     }
910 
911     if (!HdfSbufReadUint32(data, &port.portId)) {
912         AUDIO_FUNC_LOGE("read port.portId error");
913         return AUDIO_HAL_ERR_INTERNAL;
914     }
915 
916     if ((port.portName = HdfSbufReadString(data)) == NULL) {
917         AUDIO_FUNC_LOGE("read port.portName error");
918         return AUDIO_HAL_ERR_INTERNAL;
919     }
920 
921     if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
922         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
923         return AUDIO_HAL_ERR_INTERNAL;
924     }
925 
926     if (adapter == NULL) {
927         AUDIO_FUNC_LOGE("HdiServiceCreatRender adapter is NULL!");
928         return AUDIO_HAL_ERR_INVALID_PARAM;
929     }
930 
931     int32_t ret = adapter->GetPortCapability(adapter, &port, &capability);
932     if (ret < 0) {
933         AUDIO_FUNC_LOGE("GetPortCapability failed ret = %{public}d", ret);
934         return AUDIO_HAL_ERR_INTERNAL;
935     }
936 
937     if (!AudioPortCapabilityBlockMarshalling(reply, &capability)) {
938         AUDIO_FUNC_LOGE("AudioPortCapabilityBlockMarshalling failed");
939         return AUDIO_HAL_ERR_INTERNAL;
940     }
941     return AUDIO_HAL_SUCCESS;
942 }
943 
HdiServiceSetPassthroughMode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)944 int32_t HdiServiceSetPassthroughMode(const struct HdfDeviceIoClient *client,
945     struct HdfSBuf *data, struct HdfSBuf *reply)
946 {
947     if (client == NULL || data == NULL || reply == NULL) {
948         return AUDIO_HAL_ERR_INVALID_PARAM;
949     }
950     struct AudioPort port;
951     enum AudioPortPassthroughMode mode;
952     struct AudioAdapter *adapter = NULL;
953     const char *adapterName = NULL;
954     if ((adapterName = HdfSbufReadString(data)) == NULL) {
955         AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
956         return AUDIO_HAL_ERR_INVALID_PARAM;
957     }
958     uint32_t tempDir = 0;
959     if (!HdfSbufReadUint32(data, &tempDir)) {
960         return AUDIO_HAL_ERR_INTERNAL;
961     }
962     port.dir = (enum AudioPortDirection)tempDir;
963     AUDIO_FUNC_LOGD("port.dir = %{public}d", port.dir);
964     if (!HdfSbufReadUint32(data, &port.portId)) {
965         return AUDIO_HAL_ERR_INTERNAL;
966     }
967     if ((port.portName = HdfSbufReadString(data)) == NULL) {
968         AUDIO_FUNC_LOGE("read port.portName failed");
969         return AUDIO_HAL_ERR_INTERNAL;
970     }
971     uint32_t tempMode = 0;
972     if (!HdfSbufReadUint32(data, &tempMode)) {
973         return AUDIO_HAL_ERR_INTERNAL;
974     }
975     mode = (enum AudioPortPassthroughMode)tempMode;
976     AUDIO_FUNC_LOGD("ready in, mode = %{public}d", mode);
977     if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
978         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
979         return AUDIO_HAL_ERR_INTERNAL;
980     }
981     if (adapter == NULL) {
982         AUDIO_FUNC_LOGE("HdiServiceCreatRender adapter is NULL!");
983         return AUDIO_HAL_ERR_INVALID_PARAM;
984     }
985     if (adapter->SetPassthroughMode == NULL) {
986         AUDIO_FUNC_LOGE("SetPassthroughMode is NULL");
987         return AUDIO_HAL_ERR_INTERNAL;
988     }
989     int ret = adapter->SetPassthroughMode(adapter, &port, mode);
990     return ret;
991 }
992 
HdiServiceGetPassthroughMode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)993 int32_t HdiServiceGetPassthroughMode(const struct HdfDeviceIoClient *client,
994     struct HdfSBuf *data, struct HdfSBuf *reply)
995 {
996     if (client == NULL || data == NULL || reply == NULL) {
997         return AUDIO_HAL_ERR_INVALID_PARAM;
998     }
999     enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO;
1000     struct AudioAdapter *adapter = NULL;
1001     const char *adapterName = NULL;
1002     struct AudioPort port;
1003     int32_t ret = memset_s(&port, sizeof(struct AudioPort), 0, sizeof(struct AudioPort));
1004     if (ret != HDF_SUCCESS) {
1005         AUDIO_FUNC_LOGE("memset_s failed");
1006         return AUDIO_HAL_ERR_INTERNAL;
1007     }
1008     if ((adapterName = HdfSbufReadString(data)) == NULL) {
1009         AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1010         return AUDIO_HAL_ERR_INVALID_PARAM;
1011     }
1012     uint32_t tempDir = port.dir;
1013     if (!HdfSbufReadUint32(data, &tempDir)) {
1014         return AUDIO_HAL_ERR_INTERNAL;
1015     }
1016     port.dir = (enum AudioPortDirection)tempDir;
1017     if (!HdfSbufReadUint32(data, &port.portId)) {
1018         return AUDIO_HAL_ERR_INTERNAL;
1019     }
1020     if ((port.portName = HdfSbufReadString(data)) == NULL) {
1021         AUDIO_FUNC_LOGE("read port.portName failed");
1022         return AUDIO_HAL_ERR_INTERNAL;
1023     }
1024     if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1025         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1026         return AUDIO_HAL_ERR_INTERNAL;
1027     }
1028     CHECK_NULL_PTR_RETURN_VALUE(adapter, AUDIO_HAL_ERR_INVALID_PARAM);
1029     if (adapter->GetPassthroughMode == NULL) {
1030         AUDIO_FUNC_LOGE("GetPassthroughMode is NULL");
1031         return AUDIO_HAL_ERR_INTERNAL;
1032     }
1033     ret = adapter->GetPassthroughMode(adapter, &port, &mode);
1034     if (ret < 0) {
1035         AUDIO_FUNC_LOGE("GetPassthroughMode ret failed");
1036         return AUDIO_HAL_ERR_INTERNAL;
1037     }
1038     uint32_t tempMode = (uint32_t)mode;
1039     if (!HdfSbufWriteUint32(reply, tempMode)) {
1040         return AUDIO_HAL_ERR_INTERNAL;
1041     }
1042     return AUDIO_HAL_SUCCESS;
1043 }
1044 
HdiServiceGetDevStatusByPnp(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1045 static int32_t HdiServiceGetDevStatusByPnp(const struct HdfDeviceIoClient *client,
1046     struct HdfSBuf *data, struct HdfSBuf *reply)
1047 {
1048     (void)reply;
1049     const char *strDevPlugMsg = NULL;
1050     if (client == NULL || data == NULL) {
1051         AUDIO_FUNC_LOGE("client or data is  null!");
1052         return AUDIO_HAL_ERR_INVALID_PARAM;
1053     }
1054     if ((strDevPlugMsg = HdfSbufReadString(data)) == NULL) {
1055         AUDIO_FUNC_LOGE("data is null!");
1056         return AUDIO_HAL_ERR_INTERNAL;
1057     }
1058 
1059     if ((AudioPnpMsgReadValue(strDevPlugMsg, "EVENT_TYPE", &(g_audioEventPnp.eventType)) != HDF_SUCCESS) ||
1060         (AudioPnpMsgReadValue(strDevPlugMsg, "DEVICE_TYPE", &(g_audioEventPnp.deviceType)) != HDF_SUCCESS)) {
1061         AUDIO_FUNC_LOGE("DeSerialize fail!");
1062         return AUDIO_HAL_ERR_INTERNAL;
1063     }
1064     if (g_audioEventPnp.deviceType == HDF_AUDIO_USB_HEADSET ||
1065         g_audioEventPnp.deviceType == HDF_AUDIO_USB_HEADPHONE ||
1066         g_audioEventPnp.deviceType == HDF_AUDIO_USBA_HEADSET ||
1067         g_audioEventPnp.deviceType == HDF_AUDIO_USBA_HEADPHONE) {
1068         g_audioEventService.deviceType = HDF_AUDIO_USB_DEVICE;
1069         if (g_audioEventPnp.eventType == HDF_AUDIO_DEVICE_ADD) {
1070             g_audioEventService.eventType = HDF_AUDIO_SERVICE_VALID;
1071         } else if (g_audioEventPnp.eventType == HDF_AUDIO_DEVICE_REMOVE) {
1072             g_audioEventService.eventType = HDF_AUDIO_SERVICE_INVALID;
1073         }
1074     }
1075     if (AudioServiceStateChange(client->device, &g_audioEventService) != AUDIO_HAL_SUCCESS) {
1076         AUDIO_FUNC_LOGE("AudioServiceStateChange fail!");
1077         return AUDIO_HAL_ERR_INTERNAL;
1078     }
1079     return AUDIO_HAL_SUCCESS;
1080 }
1081 
AudioDevExtInfoBlockUnmarshalling(struct HdfSBuf * data,struct AudioDevExtInfo * dataBlock)1082 static bool AudioDevExtInfoBlockUnmarshalling(struct HdfSBuf *data, struct AudioDevExtInfo *dataBlock)
1083 {
1084     if (dataBlock == NULL) {
1085         HDF_LOGE("%{public}s: invalid data block", __func__);
1086         return false;
1087     }
1088     if (data == NULL) {
1089         HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1090         goto ERROR;
1091     }
1092 
1093     if (!HdfSbufReadInt32(data, &dataBlock->moduleId)) {
1094         HDF_LOGE("%{public}s: read dataBlock->moduleId failed!", __func__);
1095         goto ERROR;
1096     }
1097 
1098     if (!HdfSbufReadInt32(data, (int32_t*)&dataBlock->type)) {
1099         HDF_LOGE("%{public}s: read dataBlock->type failed!", __func__);
1100         goto ERROR;
1101     }
1102 
1103     const char *descCp = HdfSbufReadString(data);
1104     if (descCp == NULL) {
1105         HDF_LOGE("%{public}s: read descCp failed!", __func__);
1106         goto ERROR;
1107     }
1108 
1109     dataBlock->desc = strdup(descCp);
1110     if (dataBlock->desc == NULL) {
1111         HDF_LOGE("strdup fail in %{public}s", __func__);
1112         goto ERROR;
1113     }
1114 
1115     return true;
1116 ERROR:
1117     if (dataBlock->desc != NULL) {
1118         OsalMemFree((void*)dataBlock->desc);
1119         dataBlock->desc = NULL;
1120     }
1121 
1122     return false;
1123 }
1124 
AudioMixExtInfoBlockUnmarshalling(struct HdfSBuf * data,struct AudioMixExtInfo * dataBlock)1125 static bool AudioMixExtInfoBlockUnmarshalling(struct HdfSBuf *data, struct AudioMixExtInfo *dataBlock)
1126 {
1127     if (data == NULL || dataBlock == NULL) {
1128         HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1129         return false;
1130     }
1131 
1132     const struct AudioMixExtInfo *dataBlockPtr = (const struct AudioMixExtInfo *)HdfSbufReadUnpadBuffer(data,
1133         sizeof(struct AudioMixExtInfo));
1134     if (dataBlockPtr == NULL) {
1135         HDF_LOGE("%{public}s: failed to read buffer data", __func__);
1136         return false;
1137     }
1138 
1139     if (memcpy_s(dataBlock, sizeof(struct AudioMixExtInfo), dataBlockPtr, sizeof(struct AudioMixExtInfo)) != EOK) {
1140         HDF_LOGE("%{public}s: failed to memcpy data", __func__);
1141         return false;
1142     }
1143 
1144     return true;
1145 }
1146 
AudioSessionExtInfoBlockUnmarshalling(struct HdfSBuf * data,struct AudioSessionExtInfo * dataBlock)1147 static bool AudioSessionExtInfoBlockUnmarshalling(struct HdfSBuf *data, struct AudioSessionExtInfo *dataBlock)
1148 {
1149     if (data == NULL || dataBlock == NULL) {
1150         HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1151         return false;
1152     }
1153 
1154     const struct AudioSessionExtInfo *dataBlockPtr = (const struct AudioSessionExtInfo *)HdfSbufReadUnpadBuffer(data,
1155                                                       sizeof(struct AudioSessionExtInfo));
1156     if (dataBlockPtr == NULL) {
1157         HDF_LOGE("%{public}s: failed to read buffer data", __func__);
1158         return false;
1159     }
1160 
1161     if (memcpy_s(dataBlock, sizeof(struct AudioSessionExtInfo), dataBlockPtr,
1162                  sizeof(struct AudioSessionExtInfo)) != EOK) {
1163         HDF_LOGE("%{public}s: failed to memcpy data", __func__);
1164         return false;
1165     }
1166 
1167     return true;
1168 }
1169 
AudioDevExtInfoFree(struct AudioDevExtInfo * dataBlock,bool freeSelf)1170 static void AudioDevExtInfoFree(struct AudioDevExtInfo *dataBlock, bool freeSelf)
1171 {
1172     if (dataBlock == NULL) {
1173         return;
1174     }
1175 
1176     if (dataBlock->desc != NULL) {
1177         OsalMemFree((void*)dataBlock->desc);
1178         dataBlock->desc = NULL;
1179     }
1180 
1181     if (freeSelf) {
1182         OsalMemFree(dataBlock);
1183     }
1184 }
1185 
AudioInfoBlockUnmarshalling(enum AudioPortType type,struct HdfSBuf * data,RouteExtInfo * dataBlock)1186 static bool AudioInfoBlockUnmarshalling(enum AudioPortType type, struct HdfSBuf *data, RouteExtInfo *dataBlock)
1187 {
1188     if (data == NULL || dataBlock == NULL) {
1189         HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1190         return false;
1191     }
1192     bool ret = true;
1193     switch (type) {
1194         case AUDIO_PORT_DEVICE_TYPE:
1195             if (!AudioDevExtInfoBlockUnmarshalling(data, &dataBlock->device)) {
1196                 HDF_LOGE("%{public}s: write dataBlock->device failed!", __func__);
1197                 AudioDevExtInfoFree(&dataBlock->device, false);
1198                 ret = false;
1199             }
1200             break;
1201         case AUDIO_PORT_MIX_TYPE:
1202             if (!AudioMixExtInfoBlockUnmarshalling(data, &dataBlock->mix)) {
1203                 HDF_LOGE("%{public}s: write dataBlock->mix failed!", __func__);
1204                 ret = false;
1205             }
1206             break;
1207         case AUDIO_PORT_SESSION_TYPE:
1208             if (!AudioSessionExtInfoBlockUnmarshalling(data, &dataBlock->session)) {
1209                 HDF_LOGE("%{public}s: write dataBlock->session failed!", __func__);
1210                 ret = false;
1211             }
1212             break;
1213         case AUDIO_PORT_UNASSIGNED_TYPE:
1214         default:
1215             ret = false;
1216             break;
1217     }
1218 
1219     return ret;
1220 }
1221 
AudioRouteNodeBlockUnmarshalling(struct HdfSBuf * data,struct AudioRouteNode * dataBlock)1222 static bool AudioRouteNodeBlockUnmarshalling(struct HdfSBuf *data, struct AudioRouteNode *dataBlock)
1223 {
1224     if (data == NULL || dataBlock == NULL) {
1225         HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1226         return false;
1227     }
1228 
1229     if (!HdfSbufReadInt32(data, &dataBlock->portId)) {
1230         HDF_LOGE("%{public}s: read dataBlock->portId failed!", __func__);
1231         return false;
1232     }
1233 
1234     if (!HdfSbufReadInt32(data, (int32_t*)&dataBlock->role)) {
1235         HDF_LOGE("%{public}s: read dataBlock->role failed!", __func__);
1236         return false;
1237     }
1238 
1239     if (!HdfSbufReadInt32(data, (int32_t*)&dataBlock->type)) {
1240         HDF_LOGE("%{public}s: read dataBlock->type failed!", __func__);
1241         return false;
1242     }
1243 
1244     if (!AudioInfoBlockUnmarshalling(dataBlock->type, data, (RouteExtInfo*)&dataBlock->ext)) {
1245         HDF_LOGE("%{public}s: read &dataBlock->ext failed!", __func__);
1246         return false;
1247     }
1248 
1249     return true;
1250 }
1251 
AudioRouteSinksBlockUnmarshalling(struct HdfSBuf * data,struct AudioRouteNode ** sourcesOrSinksCp,uint32_t * sourcesOrSinksNum)1252 static bool AudioRouteSinksBlockUnmarshalling(
1253     struct HdfSBuf *data,
1254     struct AudioRouteNode **sourcesOrSinksCp,
1255     uint32_t *sourcesOrSinksNum)
1256 {
1257     if (!HdfSbufReadUint32(data, sourcesOrSinksNum)) {
1258         HDF_LOGE("%{public}s: read sourcesOrSinksNum failed!", __func__);
1259         return false;
1260     }
1261     if (*sourcesOrSinksNum > 0) {
1262         *sourcesOrSinksCp = (struct AudioRouteNode*)OsalMemCalloc(sizeof(struct AudioRouteNode) * (*sourcesOrSinksNum));
1263         if (*sourcesOrSinksCp == NULL) {
1264             return false;
1265         }
1266         for (uint32_t i = 0; i < *sourcesOrSinksNum; i++) {
1267             if (!AudioRouteNodeBlockUnmarshalling(data, (*sourcesOrSinksCp) + i)) {
1268                 HDF_LOGE("%{public}s: read &sourcesOrSinksCp[i] failed!", __func__);
1269                 OsalMemFree((void*)*sourcesOrSinksCp);
1270                 return false;
1271             }
1272         }
1273     }
1274 
1275     return true;
1276 }
1277 
AudioRouteSourceBlockUnmarshalling(struct HdfSBuf * data,struct AudioRoute * dataBlock)1278 static bool AudioRouteSourceBlockUnmarshalling(struct HdfSBuf *data, struct AudioRoute *dataBlock)
1279 {
1280     if (data == NULL || dataBlock == NULL) {
1281         HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1282         return false;
1283     }
1284 
1285     struct AudioRouteNode* sourcesCp = NULL;
1286     uint32_t sourcesNum = 0;
1287     struct AudioRouteNode* sinksCp = NULL;
1288     uint32_t sinksNum = 0;
1289 
1290     if (!AudioRouteSinksBlockUnmarshalling(data, &sourcesCp, &sourcesNum)) {
1291         HDF_LOGE("%{public}s: read sources failed!", __func__);
1292         return false;
1293     }
1294     dataBlock->sources = sourcesCp;
1295     dataBlock->sourcesNum = sourcesNum;
1296 
1297     if (!AudioRouteSinksBlockUnmarshalling(data, &sinksCp, &sinksNum)) {
1298         HDF_LOGE("%{public}s: read sinks failed!", __func__);
1299         OsalMemFree((void*)sourcesCp);
1300         return false;
1301     }
1302     dataBlock->sinks = sinksCp;
1303     dataBlock->sinksNum = sinksNum;
1304 
1305     return true;
1306 }
1307 
AudioRouteDevFreeByNum(const struct AudioRouteNode * routeNode,uint32_t num)1308 static void AudioRouteDevFreeByNum(const struct AudioRouteNode *routeNode, uint32_t num)
1309 {
1310     uint32_t nodeCnt;
1311     if (routeNode == NULL) {
1312         AUDIO_FUNC_LOGI("routeNode has been freed");
1313         return;
1314     }
1315 
1316     for (nodeCnt = 0; nodeCnt < num; nodeCnt++) {
1317         if (routeNode[nodeCnt].type == AUDIO_PORT_DEVICE_TYPE) {
1318             AudioDevExtInfoFree((struct AudioDevExtInfo *)&routeNode[nodeCnt].ext.device, false);
1319         }
1320     }
1321 }
1322 
AudioRouteFree(struct AudioRoute * dataBlock,bool freeSelf)1323 static void AudioRouteFree(struct AudioRoute *dataBlock, bool freeSelf)
1324 {
1325     if (dataBlock == NULL) {
1326         AUDIO_FUNC_LOGI("dataBlock has been freed");
1327         return;
1328     }
1329 
1330     if (dataBlock->sources != NULL) {
1331         AudioRouteDevFreeByNum(dataBlock->sources, dataBlock->sourcesNum);
1332         OsalMemFree((void*)dataBlock->sources);
1333     }
1334 
1335     if (dataBlock->sinks != NULL) {
1336         AudioRouteDevFreeByNum(dataBlock->sinks, dataBlock->sinksNum);
1337         OsalMemFree((void*)dataBlock->sinks);
1338     }
1339 
1340     if (freeSelf) {
1341         OsalMemFree((void*)dataBlock);
1342     }
1343 }
1344 
HdiSerStubUpdateAudioRoute(const struct HdfDeviceIoClient * client,struct HdfSBuf * audioAdapterData,struct HdfSBuf * audioAdapterReply)1345 static int32_t HdiSerStubUpdateAudioRoute(const struct HdfDeviceIoClient *client, struct HdfSBuf *audioAdapterData,
1346                                           struct HdfSBuf *audioAdapterReply)
1347 {
1348     int32_t audioAdapterRet = HDF_FAILURE;
1349     struct AudioRoute* route = NULL;
1350     int32_t routeHandle = 0;
1351     struct AudioAdapter *adapter = NULL;
1352     const char *adapterName = NULL;
1353 
1354     if ((adapterName = HdfSbufReadString(audioAdapterData)) == NULL) {
1355         AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1356         return AUDIO_HAL_ERR_INVALID_PARAM;
1357     }
1358 
1359     route = (struct AudioRoute*)OsalMemAlloc(sizeof(struct AudioRoute));
1360     if (route == NULL) {
1361         HDF_LOGE("%{public}s: malloc route failed", __func__);
1362         audioAdapterRet = HDF_ERR_MALLOC_FAIL;
1363         goto FINISHED;
1364     }
1365 
1366     if (!AudioRouteSourceBlockUnmarshalling(audioAdapterData, route)) {
1367         HDF_LOGE("%{public}s: read route failed!", __func__);
1368         audioAdapterRet = HDF_ERR_INVALID_PARAM;
1369         goto FINISHED;
1370     }
1371 
1372     if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1373         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1374         goto FINISHED;
1375     }
1376     if (adapter == NULL) {
1377         AUDIO_FUNC_LOGE("adapter is NULL!");
1378         goto FINISHED;
1379     }
1380 
1381     if (adapter->UpdateAudioRoute == NULL) {
1382         AUDIO_FUNC_LOGE("UpdateAudioRoute is NULL");
1383         goto FINISHED;
1384     }
1385     audioAdapterRet = adapter->UpdateAudioRoute(adapter, route, &routeHandle);
1386     if (audioAdapterRet != HDF_SUCCESS) {
1387         HDF_LOGE("%{public}s: call UpdateAudioRoute function failed!", __func__);
1388         goto FINISHED;
1389     }
1390 
1391     if (!HdfSbufWriteInt32(audioAdapterReply, routeHandle)) {
1392         HDF_LOGE("%{public}s: write routeHandle failed!", __func__);
1393         audioAdapterRet = HDF_ERR_INVALID_PARAM;
1394         goto FINISHED;
1395     }
1396 
1397 FINISHED:
1398     if (route != NULL) {
1399         AudioRouteFree(route, true);
1400         route = NULL;
1401     }
1402     return audioAdapterRet;
1403 }
1404 
HdiSerStubReleaseAudioRoute(const struct HdfDeviceIoClient * client,struct HdfSBuf * audioAdapterData,struct HdfSBuf * audioAdapterReply)1405 static int32_t HdiSerStubReleaseAudioRoute(const struct HdfDeviceIoClient *client, struct HdfSBuf *audioAdapterData,
1406                                            struct HdfSBuf *audioAdapterReply)
1407 {
1408     int32_t audioAdapterRet = HDF_FAILURE;
1409     int32_t routeHandle = 0;
1410     struct AudioAdapter *adapter = NULL;
1411     const char *adapterName = NULL;
1412 
1413     if ((adapterName = HdfSbufReadString(audioAdapterData)) == NULL) {
1414         AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1415         return AUDIO_HAL_ERR_INVALID_PARAM;
1416     }
1417 
1418     if (!HdfSbufReadInt32(audioAdapterData, &routeHandle)) {
1419         HDF_LOGE("%{public}s: read &routeHandle failed!", __func__);
1420         return HDF_ERR_INVALID_PARAM;
1421     }
1422 
1423     if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1424         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1425         return AUDIO_HAL_ERR_INTERNAL;
1426     }
1427 
1428     if (adapter == NULL || adapter->ReleaseAudioRoute == NULL) {
1429         AUDIO_FUNC_LOGE("adapter or ReleaseAudioRoute is NULL");
1430         return AUDIO_HAL_ERR_INTERNAL;
1431     }
1432     audioAdapterRet = adapter->ReleaseAudioRoute(adapter, routeHandle);
1433     if (audioAdapterRet != HDF_SUCCESS) {
1434         HDF_LOGE("%{public}s: call ReleaseAudioRoute function failed!", __func__);
1435     }
1436 
1437     return audioAdapterRet;
1438 }
1439 
HdiServiceAdapterSetMicMute(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1440 static int32_t HdiServiceAdapterSetMicMute(const struct HdfDeviceIoClient *client,
1441     struct HdfSBuf *data, struct HdfSBuf *reply)
1442 {
1443     bool mute = false;
1444     uint32_t tempMute = 0;
1445     struct AudioAdapter *adapter = NULL;
1446     const char *adapterName = NULL;
1447 
1448     if (client == NULL || data == NULL || reply == NULL) {
1449         AUDIO_FUNC_LOGE("client or data or reply is NULL");
1450         return AUDIO_HAL_ERR_INVALID_PARAM;
1451     }
1452 
1453     if ((adapterName = HdfSbufReadString(data)) == NULL) {
1454         AUDIO_FUNC_LOGE("adapterName Is NULL ");
1455         return HDF_FAILURE;
1456     }
1457 
1458     if (!HdfSbufReadUint32(data, &tempMute)) {
1459         AUDIO_FUNC_LOGE("tempMute Is NULL ");
1460         return HDF_FAILURE;
1461     }
1462     mute = (bool)tempMute;
1463 
1464     if (AudioAdapterListGetAdapter(adapterName, &adapter) != HDF_SUCCESS) {
1465         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1466         return AUDIO_HAL_ERR_INTERNAL;
1467     }
1468 
1469     if (adapter == NULL || adapter->SetMicMute == NULL) {
1470         AUDIO_FUNC_LOGE("adapter or SetMicMute is NULL");
1471         return AUDIO_HAL_ERR_INTERNAL;
1472     }
1473 
1474     return adapter->SetMicMute(adapter, mute);
1475 }
1476 
HdiServiceAdapterGetMicMute(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1477 static int32_t HdiServiceAdapterGetMicMute(const struct HdfDeviceIoClient *client,
1478     struct HdfSBuf *data, struct HdfSBuf *reply)
1479 {
1480     if (client == NULL || data == NULL || reply == NULL) {
1481         AUDIO_FUNC_LOGE("client or data or reply is NULL");
1482         return AUDIO_HAL_ERR_INVALID_PARAM;
1483     }
1484 
1485     bool mute = false;
1486     struct AudioAdapter *adapter = NULL;
1487     const char *adapterName = NULL;
1488 
1489     if ((adapterName = HdfSbufReadString(data)) == NULL) {
1490         AUDIO_FUNC_LOGE("adapterName Is NULL ");
1491         return HDF_FAILURE;
1492     }
1493 
1494     if (AudioAdapterListGetAdapter(adapterName, &adapter) != HDF_SUCCESS) {
1495         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1496         return AUDIO_HAL_ERR_INTERNAL;
1497     }
1498 
1499     if (adapter == NULL || adapter->GetMicMute == NULL) {
1500         AUDIO_FUNC_LOGE("adapter or SetMicMute is NULL");
1501         return AUDIO_HAL_ERR_INTERNAL;
1502     }
1503 
1504     int ret = adapter->GetMicMute(adapter, &mute);
1505     if (ret < 0) {
1506         AUDIO_FUNC_LOGE("GetMicMute FAIL");
1507         return ret;
1508     }
1509 
1510     if (!HdfSbufWriteUint32(reply, (uint32_t)mute)) {
1511         return AUDIO_HAL_ERR_INTERNAL;
1512     }
1513 
1514     return AUDIO_HAL_SUCCESS;
1515 }
1516 
HdiServiceAdapterSetVoiceVolume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1517 static int32_t HdiServiceAdapterSetVoiceVolume(const struct HdfDeviceIoClient *client,
1518                                                struct HdfSBuf *data, struct HdfSBuf *reply)
1519 {
1520     float volume = 0;
1521     struct AudioAdapter *adapter = NULL;
1522     const char *adapterName = NULL;
1523 
1524     if (client == NULL || data == NULL || reply == NULL) {
1525         AUDIO_FUNC_LOGE("client or data or reply is NULL");
1526         return AUDIO_HAL_ERR_INVALID_PARAM;
1527     }
1528 
1529     if ((adapterName = HdfSbufReadString(data)) == NULL) {
1530         AUDIO_FUNC_LOGE("adapterName Is NULL ");
1531         return HDF_FAILURE;
1532     }
1533 
1534     if (!HdfSbufReadFloat(data, &volume)) {
1535         AUDIO_FUNC_LOGE("volume Is NULL ");
1536         return HDF_FAILURE;
1537     }
1538 
1539     if (AudioAdapterListGetAdapter(adapterName, &adapter) != HDF_SUCCESS) {
1540         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1541         return AUDIO_HAL_ERR_INTERNAL;
1542     }
1543 
1544     if (adapter == NULL || adapter->SetVoiceVolume == NULL) {
1545         AUDIO_FUNC_LOGE("adapter or SetVoiceVolume is NULL");
1546         return AUDIO_HAL_ERR_INTERNAL;
1547     }
1548 
1549     return adapter->SetVoiceVolume(adapter, volume);
1550 }
1551 
HdiServiceAdapterSetExtraParams(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1552 static int32_t HdiServiceAdapterSetExtraParams(const struct HdfDeviceIoClient *client,
1553                                                struct HdfSBuf *data, struct HdfSBuf *reply)
1554 {
1555     if (client == NULL || data == NULL || reply == NULL) {
1556         AUDIO_FUNC_LOGE("the parameter is empty");
1557         return AUDIO_HAL_ERR_INVALID_PARAM;
1558     }
1559 
1560     struct AudioAdapter *adapter = NULL;
1561     const char *adapterName = NULL;
1562     const char *value = NULL;
1563     enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
1564     const char *condition = NULL;
1565 
1566     if ((adapterName = HdfSbufReadString(data)) == NULL) {
1567         AUDIO_FUNC_LOGE("adapterName is NULL");
1568         return HDF_FAILURE;
1569     }
1570 
1571     if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1572         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter FAIL");
1573         return AUDIO_HAL_ERR_INTERNAL;
1574     }
1575     if (adapter == NULL) {
1576         AUDIO_FUNC_LOGE("adapter is NULL");
1577         return AUDIO_HAL_ERR_INTERNAL;
1578     }
1579 
1580     value = HdfSbufReadString(data);
1581     if (value == NULL) {
1582         AUDIO_FUNC_LOGE("value is NULL");
1583         return AUDIO_HAL_ERR_INTERNAL;
1584     }
1585 
1586     if (adapter->SetExtraParams == NULL) {
1587         AUDIO_FUNC_LOGE("adapter or SetExtraParams is NULL");
1588         return AUDIO_HAL_ERR_INTERNAL;
1589     }
1590 
1591     return adapter->SetExtraParams(adapter, key, condition, value);
1592 }
1593 
HdiServiceAdapterGetExtraParams(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1594 static int32_t HdiServiceAdapterGetExtraParams(const struct HdfDeviceIoClient *client,
1595                                                struct HdfSBuf *data, struct HdfSBuf *reply)
1596 {
1597     if (client == NULL || data == NULL || reply == NULL) {
1598         AUDIO_FUNC_LOGE("the parameter is empty");
1599         return AUDIO_HAL_ERR_INVALID_PARAM;
1600     }
1601 
1602     int32_t length = 0;
1603     struct AudioAdapter *adapter = NULL;
1604     const char *adapterName = NULL;
1605     enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
1606     const char *condition = NULL;
1607     char value[STR_MAX] = { 0 };
1608 
1609     if ((adapterName = HdfSbufReadString(data)) == NULL) {
1610         AUDIO_FUNC_LOGE("adapterName is NULL");
1611         return HDF_FAILURE;
1612     }
1613 
1614     if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1615         AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter FAIL");
1616         return AUDIO_HAL_ERR_INTERNAL;
1617     }
1618     if (adapter == NULL) {
1619         AUDIO_FUNC_LOGE("adapter is NULL");
1620         return AUDIO_HAL_ERR_INTERNAL;
1621     }
1622 
1623     if (!HdfSbufReadInt32(data, &length)) {
1624         AUDIO_FUNC_LOGE("HdiServiceAdapterGetExtraParams FAIL! length is 0.");
1625         return AUDIO_HAL_ERR_INTERNAL;
1626     }
1627 
1628     if (adapter->GetExtraParams == NULL) {
1629         AUDIO_FUNC_LOGE("adapter or GetExtraParams is NULL");
1630         return AUDIO_HAL_ERR_INTERNAL;
1631     }
1632 
1633     int32_t ret = adapter->GetExtraParams(adapter, key, condition, value, length);
1634     if (ret < 0) {
1635         AUDIO_FUNC_LOGE("GetExtraParams FAIL");
1636         return ret;
1637     }
1638 
1639     if (!HdfSbufWriteString(reply, value)) {
1640         AUDIO_FUNC_LOGE("value write fail");
1641         return AUDIO_HAL_ERR_INTERNAL;
1642     }
1643 
1644     return AUDIO_HAL_SUCCESS;
1645 }
1646 
1647 struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleList[] = {
1648     {AUDIO_HDI_MGR_GET_FUNCS, HdiServiceGetFuncs},
1649     {AUDIO_HDI_MGR_GET_ALL_ADAPTER, HdiServiceGetAllAdapter},
1650     {AUDIO_HDI_MGR_RELEASE, HdiServiceReleaseAudioManagerObject},
1651     {AUDIO_HDI_MGR_LOAD_ADAPTER, HdiServiceLoadAdapter},
1652     {AUDIO_HDI_MGR_UNLOAD_ADAPTER, HdiServiceUnloadAdapter},
1653     {AUDIO_HDI_ADT_INIT_PORTS, HdiServiceInitAllPorts},
1654     {AUDIO_HDI_ADT_GET_PORT_CAPABILITY, HdiServiceGetPortCapability},
1655     {AUDIO_HDI_ADT_SET_PASS_MODE, HdiServiceSetPassthroughMode},
1656     {AUDIO_HDI_ADT_GET_PASS_MODE, HdiServiceGetPassthroughMode},
1657     {AUDIO_HDI_ADT_UPDATE_ROUTE, HdiSerStubUpdateAudioRoute},
1658     {AUDIO_HDI_ADT_RELEASE_ROUTE, HdiSerStubReleaseAudioRoute},
1659     {AUDIO_HDI_ADT_SET_MIC_MUTE, HdiServiceAdapterSetMicMute},
1660     {AUDIO_HDI_ADT_GET_MIC_MUTE, HdiServiceAdapterGetMicMute},
1661     {AUDIO_HDI_ADT_SET_VOICE_VOLUME, HdiServiceAdapterSetVoiceVolume},
1662     {AUDIO_HDI_ADT_SET_EXTRA_PARAMS, HdiServiceAdapterSetExtraParams},
1663     {AUDIO_HDI_ADT_GET_EXTRA_PARAMS, HdiServiceAdapterGetExtraParams},
1664     {AUDIO_HDI_PNP_DEV_STATUS, HdiServiceGetDevStatusByPnp},
1665     {AUDIO_HDI_RENDER_CREATE_RENDER, HdiServiceCreatRender},
1666     {AUDIO_HDI_RENDER_DESTROY, HdiServiceRenderDestory},
1667     {AUDIO_HDI_RENDER_START, HdiServiceRenderStart},
1668     {AUDIO_HDI_RENDER_STOP, HdiServiceRenderStop},
1669     {AUDIO_HDI_RENDER_PAUSE, HdiServiceRenderPause},
1670     {AUDIO_HDI_RENDER_RESUME, HdiServiceRenderResume},
1671     {AUDIO_HDI_RENDER_FLUSH, HdiServiceRenderFlush},
1672     {AUDIO_HDI_RENDER_GET_FRAME_SIZE, HdiServiceRenderGetFrameSize},
1673     {AUDIO_HDI_RENDER_GET_FRAME_COUNT, HdiServiceRenderGetFrameCount},
1674     {AUDIO_HDI_RENDER_SET_SAMPLE_ATTR, HdiServiceRenderSetSampleAttr},
1675     {AUDIO_HDI_RENDER_GET_SAMPLE_ATTR, HdiServiceRenderGetSampleAttr},
1676     {AUDIO_HDI_RENDER_GET_CUR_CHANNEL_ID, HdiServiceRenderGetCurChannelId},
1677     {AUDIO_HDI_RENDER_CHECK_SCENE_CAPABILITY, HdiServiceRenderCheckSceneCapability},
1678     {AUDIO_HDI_RENDER_SELECT_SCENE, HdiServiceRenderSelectScene},
1679     {AUDIO_HDI_RENDER_GET_MUTE, HdiServiceRenderGetMute},
1680     {AUDIO_HDI_RENDER_SET_MUTE, HdiServiceRenderSetMute},
1681     {AUDIO_HDI_RENDER_SET_VOLUME, HdiServiceRenderSetVolume},
1682     {AUDIO_HDI_RENDER_GET_VOLUME, HdiServiceRenderGetVolume},
1683     {AUDIO_HDI_RENDER_GET_GAIN_THRESHOLD, HdiServiceRenderGetGainThreshold},
1684     {AUDIO_HDI_RENDER_GET_GAIN, HdiServiceRenderGetGain},
1685     {AUDIO_HDI_RENDER_SET_GAIN, HdiServiceRenderSetGain},
1686     {AUDIO_HDI_RENDER_GET_LATENCY, HdiServiceRenderGetLatency},
1687     {AUDIO_HDI_RENDER_RENDER_FRAME, HdiServiceRenderRenderFrame},
1688     {AUDIO_HDI_RENDER_GET_RENDER_POSITION, HdiServiceRenderGetRenderPosition},
1689     {AUDIO_HDI_RENDER_GET_SPEED, HdiServiceRenderGetSpeed},
1690     {AUDIO_HDI_RENDER_SET_SPEED, HdiServiceRenderSetSpeed},
1691     {AUDIO_HDI_RENDER_SET_CHANNEL_MODE, HdiServiceRenderSetChannelMode},
1692     {AUDIO_HDI_RENDER_GET_CHANNEL_MODE, HdiServiceRenderGetChannelMode},
1693     {AUDIO_HDI_RENDER_SET_EXTRA_PARAMS, HdiServiceRenderSetExtraParams},
1694     {AUDIO_HDI_RENDER_GET_EXTRA_PARAMS, HdiServiceRenderGetExtraParams},
1695     {AUDIO_HDI_RENDER_REQ_MMAP_BUFFER, HdiServiceRenderReqMmapBuffer},
1696     {AUDIO_HDI_RENDER_GET_MMAP_POSITION, HdiServiceRenderGetMmapPosition},
1697     {AUDIO_HDI_RENDER_ADD_EFFECT, HdiServiceRenderAddEffect},
1698     {AUDIO_HDI_RENDER_REMOVE_EFFECT, HdiServiceRenderRemoveEffect},
1699     {AUDIO_HDI_RENDER_TURN_STAND_BY_MODE, HdiServiceRenderTurnStandbyMode},
1700     {AUDIO_HDI_RENDER_DEV_DUMP, HdiServiceRenderDevDump},
1701     {AUDIO_HDI_RENDER_REG_CALLBACK, HdiServiceRenderRegCallback},
1702     {AUDIO_HDI_RENDER_DRAIN_BUFFER, HdiServiceRenderDrainBuffer},
1703 };
1704 
1705 static struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleCapList[] = {
1706     {AUDIO_HDI_CAPTURE_CREATE_CAPTURE, HdiServiceCreatCapture},
1707     {AUDIO_HDI_CAPTURE_DESTROY, HdiServiceCaptureDestory},
1708     {AUDIO_HDI_CAPTURE_START, HdiServiceCaptureStart},
1709     {AUDIO_HDI_CAPTURE_STOP, HdiServiceCaptureStop},
1710     {AUDIO_HDI_CAPTURE_PAUSE, HdiServiceCapturePause},
1711     {AUDIO_HDI_CAPTURE_RESUME, HdiServiceCaptureResume},
1712     {AUDIO_HDI_CAPTURE_FLUSH, HdiServiceCaptureFlush},
1713     {AUDIO_HDI_CAPTURE_GET_FRAME_SIZE, HdiServiceCaptureGetFrameSize},
1714     {AUDIO_HDI_CAPTURE_GET_FRAME_COUNT, HdiServiceCaptureGetFrameCount},
1715     {AUDIO_HDI_CAPTURE_SET_SAMPLE_ATTR, HdiServiceCaptureSetSampleAttr},
1716     {AUDIO_HDI_CAPTURE_GET_SAMPLE_ATTR, HdiServiceCaptureGetSampleAttr},
1717     {AUDIO_HDI_CAPTURE_GET_CUR_CHANNEL_ID, HdiServiceCaptureGetCurChannelId},
1718     {AUDIO_HDI_CAPTURE_CHECK_SCENE_CAPABILITY, HdiServiceCaptureCheckSceneCapability},
1719     {AUDIO_HDI_CAPTURE_SELECT_SCENE, HdiServiceCaptureSelectScene},
1720     {AUDIO_HDI_CAPTURE_GET_MUTE, HdiServiceCaptureGetMute},
1721     {AUDIO_HDI_CAPTURE_SET_MUTE, HdiServiceCaptureSetMute},
1722     {AUDIO_HDI_CAPTURE_SET_VOLUME, HdiServiceCaptureSetVolume},
1723     {AUDIO_HDI_CAPTURE_GET_VOLUME, HdiServiceCaptureGetVolume},
1724     {AUDIO_HDI_CAPTURE_GET_GAIN_THRESHOLD, HdiServiceCaptureGetGainThreshold},
1725     {AUDIO_HDI_CAPTURE_GET_GAIN, HdiServiceCaptureGetGain},
1726     {AUDIO_HDI_CAPTURE_SET_GAIN, HdiServiceCaptureSetGain},
1727     {AUDIO_HDI_CAPTURE_CAPTURE_FRAME, HdiServiceCaptureCaptureFrame},
1728     {AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION, HdiServiceCaptureGetCapturePosition},
1729     {AUDIO_HDI_CAPTURE_SET_EXTRA_PARAMS, HdiServiceCaptureSetExtraParams},
1730     {AUDIO_HDI_CAPTURE_GET_EXTRA_PARAMS, HdiServiceCaptureGetExtraParams},
1731     {AUDIO_HDI_CAPTURE_REQ_MMAP_BUFFER, HdiServiceCaptureReqMmapBuffer},
1732     {AUDIO_HDI_CAPTURE_GET_MMAP_POSITION, HdiServiceCaptureGetMmapPosition},
1733     {AUDIO_HDI_CAPTURE_ADD_EFFECT, HdiServiceCaptureAddEffect},
1734     {AUDIO_HDI_CAPTURE_REMOVE_EFFECT, HdiServiceCaptureRemoveEffect},
1735     {AUDIO_HDI_CAPTURE_TURN_STAND_BY_MODE, HdiServiceCaptureTurnStandbyMode},
1736     {AUDIO_HDI_CAPTURE_DEV_DUMP, HdiServiceCaptureDevDump},
1737 };
1738 
HdiServiceDispatch(struct HdfDeviceIoClient * client,int cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)1739 int32_t HdiServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data,
1740     struct HdfSBuf *reply)
1741 {
1742     unsigned int i;
1743     AUDIO_FUNC_LOGD("cmdId = %{public}d", cmdId);
1744     if (client == NULL) {
1745         AUDIO_FUNC_LOGE("ControlDispatch: input para is NULL.");
1746         return AUDIO_HAL_ERR_INVALID_PARAM;
1747     }
1748 
1749     if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
1750         AUDIO_FUNC_LOGE("check interface token failed");
1751         return AUDIO_HAL_ERR_INVALID_PARAM;
1752     }
1753     if (cmdId > AUDIO_HDI_CAPTURE_DEV_DUMP || cmdId < 0) {
1754         AUDIO_FUNC_LOGE("ControlDispatch: invalid cmdId = %{public}d", cmdId);
1755         return AUDIO_HAL_ERR_INTERNAL;
1756     } else if (cmdId <= AUDIO_HDI_RENDER_DRAIN_BUFFER) {
1757         for (i = 0; i < sizeof(g_hdiServiceDispatchCmdHandleList) /
1758             sizeof(g_hdiServiceDispatchCmdHandleList[0]); ++i) {
1759             if ((cmdId == (int)(g_hdiServiceDispatchCmdHandleList[i].cmd)) &&
1760                 (g_hdiServiceDispatchCmdHandleList[i].func != NULL)) {
1761                 return g_hdiServiceDispatchCmdHandleList[i].func(client, data, reply);
1762             }
1763         }
1764     } else {
1765         for (i = 0; i < sizeof(g_hdiServiceDispatchCmdHandleCapList) /
1766             sizeof(g_hdiServiceDispatchCmdHandleCapList[0]); ++i) {
1767             if ((cmdId == (int)(g_hdiServiceDispatchCmdHandleCapList[i].cmd)) &&
1768                 (g_hdiServiceDispatchCmdHandleCapList[i].func != NULL)) {
1769                 return g_hdiServiceDispatchCmdHandleCapList[i].func(client, data, reply);
1770             }
1771         }
1772     }
1773     return AUDIO_HAL_ERR_INTERNAL;
1774 }
1775