1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  *
4  * HDF is dual licensed: you can use it either under the terms of
5  * the GPL, or the BSD license, at your option.
6  * See the LICENSE file in the root of this repository for complete details.
7  */
8 
9 #include "audio_stream_dispatch.h"
10 #include "audio_driver_log.h"
11 #include "audio_platform_base.h"
12 
13 #define HDF_LOG_TAG HDF_AUDIO_KADM
14 
15 #define BUFF_SIZE_MAX 64
16 
StreamHostFromDevice(const struct HdfDeviceObject * device)17 static inline struct StreamHost *StreamHostFromDevice(const struct HdfDeviceObject *device)
18 {
19     return (device == NULL) ? NULL : (struct StreamHost *)device->service;
20 }
21 
HwCpuDaiDispatch(const struct AudioCard * audioCard,const struct AudioPcmHwParams * params)22 static int32_t HwCpuDaiDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params)
23 {
24     struct AudioRuntimeDeivces *rtd = NULL;
25     struct DaiDevice *cpuDai = NULL;
26     int32_t ret;
27     if ((audioCard == NULL) || (params == NULL)) {
28         ADM_LOG_ERR("CpuDai input param is NULL.");
29         return HDF_FAILURE;
30     }
31 
32     rtd = audioCard->rtd;
33     if (rtd == NULL) {
34         ADM_LOG_ERR("CpuDai audioCard rtd is NULL.");
35         return HDF_FAILURE;
36     }
37 
38     cpuDai = rtd->cpuDai;
39     /* If there are HwParams function, it will be executed directly.
40      * If not, skip the if statement and execute in sequence.
41      */
42     if (cpuDai != NULL && cpuDai->devData != NULL && cpuDai->devData->ops != NULL &&
43         cpuDai->devData->ops->HwParams != NULL) {
44         ret = cpuDai->devData->ops->HwParams(audioCard, params);
45         if (ret < 0) {
46             ADM_LOG_ERR("cpuDai hardware params failed ret=%d", ret);
47             return HDF_ERR_IO;
48         }
49     } else {
50         ADM_LOG_WARNING("cpuDai not support the function of setting hardware parameter");
51     }
52 
53     return HDF_SUCCESS;
54 }
55 
HwCodecDaiDispatch(const struct AudioCard * audioCard,const struct AudioPcmHwParams * params)56 static int32_t HwCodecDaiDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params)
57 {
58     struct AudioRuntimeDeivces *rtd = NULL;
59     struct DaiDevice *codecDai = NULL;
60     int32_t ret;
61     if ((audioCard == NULL) || (params == NULL)) {
62         ADM_LOG_ERR("CodecDai input param is NULL.");
63         return HDF_FAILURE;
64     }
65 
66     rtd = audioCard->rtd;
67     if (rtd == NULL) {
68         ADM_LOG_ERR("CodecDai audioCard rtd is NULL.");
69         return HDF_FAILURE;
70     }
71     codecDai = rtd->codecDai;
72     /* If there are HwParams function, it will be executed directly.
73      * If not, skip the if statement and execute in sequence.
74      */
75     if (codecDai != NULL && codecDai->devData != NULL && codecDai->devData->ops != NULL &&
76         codecDai->devData->ops->HwParams != NULL) {
77         ret = codecDai->devData->ops->HwParams(audioCard, params);
78         if (ret < 0) {
79             ADM_LOG_ERR("codecDai hardware params failed ret=%d", ret);
80             return HDF_ERR_IO;
81         }
82     } else {
83         ADM_LOG_WARNING("codecDai not support the function of setting hardware parameter");
84     }
85 
86     return HDF_SUCCESS;
87 }
88 
HwDspDaiDispatch(const struct AudioCard * audioCard,const struct AudioPcmHwParams * params)89 static int32_t HwDspDaiDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params)
90 {
91     struct AudioRuntimeDeivces *rtd = NULL;
92     struct DaiDevice *dspDai = NULL;
93     int32_t ret;
94     if ((audioCard == NULL) || (params == NULL)) {
95         ADM_LOG_ERR("DspDai input param is NULL.");
96         return HDF_FAILURE;
97     }
98     rtd = audioCard->rtd;
99     if (rtd == NULL) {
100         ADM_LOG_ERR("DspDai audioCard rtd is NULL.");
101         return HDF_FAILURE;
102     }
103     dspDai = rtd->dspDai;
104 
105     if (dspDai != NULL && dspDai->devData != NULL && dspDai->devData->ops != NULL &&
106         dspDai->devData->ops->HwParams != NULL) {
107         ret = dspDai->devData->ops->HwParams(audioCard, params);
108         if (ret < 0) {
109             ADM_LOG_ERR("dspDai hardware params failed ret=%d", ret);
110             return HDF_ERR_IO;
111         }
112     } else {
113         ADM_LOG_WARNING("dspDai not support the function of setting hardware parameter ");
114     }
115     return HDF_SUCCESS;
116 }
117 
HwPlatformDispatch(const struct AudioCard * audioCard,const struct AudioPcmHwParams * params)118 static int32_t HwPlatformDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params)
119 {
120     int32_t ret;
121     struct AudioRuntimeDeivces *rtd = NULL;
122     if ((audioCard == NULL) || (params == NULL)) {
123         ADM_LOG_ERR("Platform input param is NULL.");
124         return HDF_FAILURE;
125     }
126 
127     rtd = audioCard->rtd;
128     if (rtd == NULL) {
129         ADM_LOG_ERR("audioCard rtd is NULL.");
130         return HDF_FAILURE;
131     }
132 
133     /* If there are HwParams function, it will be executed directly.
134      * If not, skip the if statement and execute in sequence.
135      */
136     ret = AudioHwParams(audioCard, params);
137     if (ret < 0) {
138         ADM_LOG_ERR("platform hardware params failed ret=%d", ret);
139         return HDF_ERR_IO;
140     }
141 
142     return HDF_SUCCESS;
143 }
144 
HwParamsDispatch(const struct AudioCard * audioCard,const struct AudioPcmHwParams * params)145 static int32_t HwParamsDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params)
146 {
147     if ((audioCard == NULL) || (params == NULL)) {
148         ADM_LOG_ERR("input param is NULL.");
149         return HDF_FAILURE;
150     }
151 #ifndef CONFIG_DRIVERS_HDF_AUDIO_IMX8MM
152     /* Traverse through each driver method; Enter if you have, if not, exectue in order */
153     if (HwCodecDaiDispatch(audioCard, params) != HDF_SUCCESS) {
154         ADM_LOG_ERR("codec dai hardware params failed.");
155         return HDF_FAILURE;
156     }
157 #endif
158     if (HwCpuDaiDispatch(audioCard, params) != HDF_SUCCESS) {
159         ADM_LOG_ERR("cpu dai hardware params failed.");
160         return HDF_FAILURE;
161     }
162 
163     if (HwPlatformDispatch(audioCard, params) != HDF_SUCCESS) {
164         ADM_LOG_ERR("platform dai hardware params failed.");
165         return HDF_FAILURE;
166     }
167 
168     if (HwDspDaiDispatch(audioCard, params) != HDF_SUCCESS) {
169         ADM_LOG_ERR("dsp dai hardware params failed.");
170         return HDF_FAILURE;
171     }
172 
173 #ifdef CONFIG_DRIVERS_HDF_AUDIO_IMX8MM
174     if (HwCodecDaiDispatch(audioCard, params) != HDF_SUCCESS) {
175         ADM_LOG_ERR("codec dai hardware params failed.");
176         return HDF_FAILURE;
177     }
178 #endif
179 
180     return HDF_SUCCESS;
181 }
182 
CpuDaiDevStartup(const struct AudioCard * audioCard,const struct DaiDevice * cpuDai)183 static int32_t CpuDaiDevStartup(const struct AudioCard *audioCard, const struct DaiDevice *cpuDai)
184 {
185     int32_t ret;
186     if (audioCard == NULL) {
187         ADM_LOG_ERR("audioCard is null.");
188         return HDF_FAILURE;
189     }
190     if (cpuDai != NULL && cpuDai->devData != NULL && cpuDai->devData->ops != NULL &&
191         cpuDai->devData->ops->Startup != NULL) {
192         ret = cpuDai->devData->ops->Startup(audioCard, cpuDai);
193         if (ret != HDF_SUCCESS) {
194             ADM_LOG_ERR("cpuDai Startup failed.");
195             return HDF_FAILURE;
196         }
197     } else {
198         ADM_LOG_DEBUG("cpu dai startup is null.");
199     }
200     return HDF_SUCCESS;
201 }
202 
CodecDaiDevStartup(const struct AudioCard * audioCard,const struct DaiDevice * codecDai)203 static int32_t CodecDaiDevStartup(const struct AudioCard *audioCard, const struct DaiDevice *codecDai)
204 {
205     int32_t ret;
206     if (audioCard == NULL) {
207         ADM_LOG_ERR("audioCard is null.");
208         return HDF_FAILURE;
209     }
210     if (codecDai != NULL && codecDai->devData != NULL && codecDai->devData->ops != NULL &&
211         codecDai->devData->ops->Startup != NULL) {
212         ret = codecDai->devData->ops->Startup(audioCard, codecDai);
213         if (ret != HDF_SUCCESS) {
214             ADM_LOG_ERR("codecDai Startup failed.");
215             return HDF_FAILURE;
216         }
217     } else {
218         ADM_LOG_DEBUG("codec dai startup is null.");
219     }
220 
221     return HDF_SUCCESS;
222 }
223 
DspDaiDevStartup(const struct AudioCard * audioCard,const struct DaiDevice * dspDai)224 static int32_t DspDaiDevStartup(const struct AudioCard *audioCard, const struct DaiDevice *dspDai)
225 {
226     int32_t ret;
227     if (audioCard == NULL) {
228         ADM_LOG_ERR("audioCard is null.");
229         return HDF_FAILURE;
230     }
231     if (dspDai != NULL && dspDai->devData != NULL && dspDai->devData->ops != NULL &&
232         dspDai->devData->ops->Startup != NULL) {
233         ret = dspDai->devData->ops->Startup(audioCard, dspDai);
234         if (ret != HDF_SUCCESS) {
235             ADM_LOG_ERR("dspDai Startup failed.");
236             return HDF_FAILURE;
237         }
238     } else {
239         ADM_LOG_DEBUG("dsp dai startup is null.");
240     }
241     return HDF_SUCCESS;
242 }
243 
AudioDaiDeviceStartup(const struct AudioCard * audioCard)244 static int32_t AudioDaiDeviceStartup(const struct AudioCard *audioCard)
245 {
246     struct DaiDevice *cpuDai = NULL;
247     struct DaiDevice *codecDai = NULL;
248     struct DaiDevice *dspDai = NULL;
249     int32_t ret;
250 
251     if (audioCard == NULL || audioCard->rtd == NULL) {
252         ADM_LOG_ERR("audioCard is null.");
253         return HDF_FAILURE;
254     }
255     cpuDai = audioCard->rtd->cpuDai;
256     ret = CpuDaiDevStartup(audioCard, cpuDai);
257     if (ret != HDF_SUCCESS) {
258         ADM_LOG_ERR("CpuDaiDevStartup failed.");
259         return HDF_FAILURE;
260     }
261     codecDai = audioCard->rtd->codecDai;
262     ret = CodecDaiDevStartup(audioCard, codecDai);
263     if (ret != HDF_SUCCESS) {
264         ADM_LOG_ERR("CodecDaiDevStartup failed.");
265         return HDF_FAILURE;
266     }
267     dspDai = audioCard->rtd->dspDai;
268     ret = DspDaiDevStartup(audioCard, dspDai);
269     if (ret != HDF_SUCCESS) {
270         ADM_LOG_ERR("DspDaiDevStartup failed.");
271         return HDF_FAILURE;
272     }
273     return HDF_SUCCESS;
274 }
275 
CpuDaiDevShutdown(const struct AudioCard * audioCard,const struct DaiDevice * cpuDai)276 static int32_t CpuDaiDevShutdown(const struct AudioCard *audioCard, const struct DaiDevice *cpuDai)
277 {
278     int32_t ret;
279     if (audioCard == NULL) {
280         ADM_LOG_ERR("audioCard is null.");
281         return HDF_FAILURE;
282     }
283     if (cpuDai != NULL && cpuDai->devData != NULL && cpuDai->devData->ops != NULL &&
284         cpuDai->devData->ops->Shutdown != NULL) {
285         ret = cpuDai->devData->ops->Shutdown(audioCard, cpuDai);
286         if (ret != HDF_SUCCESS) {
287             ADM_LOG_ERR("cpuDai Shutdown failed ret=%d.", ret);
288             return HDF_FAILURE;
289         }
290     } else {
291         ADM_LOG_DEBUG("cpu dai Shutdown is null.");
292     }
293     return HDF_SUCCESS;
294 }
295 
CodecDaiDevShutdown(const struct AudioCard * audioCard,const struct DaiDevice * codecDai)296 static int32_t CodecDaiDevShutdown(const struct AudioCard *audioCard, const struct DaiDevice *codecDai)
297 {
298     int32_t ret;
299     if (audioCard == NULL) {
300         ADM_LOG_ERR("audioCard is null.");
301         return HDF_FAILURE;
302     }
303     if (codecDai != NULL && codecDai->devData != NULL && codecDai->devData->ops != NULL &&
304         codecDai->devData->ops->Shutdown != NULL) {
305         ret = codecDai->devData->ops->Shutdown(audioCard, codecDai);
306         if (ret != HDF_SUCCESS) {
307             ADM_LOG_ERR("codecDai Shutdown failed ret=%d.", ret);
308             return HDF_FAILURE;
309         }
310     } else {
311         ADM_LOG_DEBUG("codec dai Shutdown is null.");
312     }
313 
314     return HDF_SUCCESS;
315 }
316 
DspDaiDevShutdown(const struct AudioCard * audioCard,const struct DaiDevice * dspDai)317 static int32_t DspDaiDevShutdown(const struct AudioCard *audioCard, const struct DaiDevice *dspDai)
318 {
319     int32_t ret;
320     if (audioCard == NULL) {
321         ADM_LOG_ERR("audioCard is null.");
322         return HDF_FAILURE;
323     }
324     if (dspDai != NULL && dspDai->devData != NULL && dspDai->devData->ops != NULL &&
325         dspDai->devData->ops->Shutdown != NULL) {
326         ret = dspDai->devData->ops->Shutdown(audioCard, dspDai);
327         if (ret != HDF_SUCCESS) {
328             ADM_LOG_ERR("dspDai Shutdown failed ret=%d.", ret);
329             return HDF_FAILURE;
330         }
331     } else {
332         ADM_LOG_DEBUG("dsp dai Shutdown is null.");
333     }
334     return HDF_SUCCESS;
335 }
336 
AudioDaiDeviceShutdown(const struct AudioCard * audioCard)337 static int32_t AudioDaiDeviceShutdown(const struct AudioCard *audioCard)
338 {
339     int32_t ret;
340 
341     if (audioCard == NULL || audioCard->rtd == NULL) {
342         ADM_LOG_ERR("audioCard is null.");
343         return HDF_FAILURE;
344     }
345 
346     ret = CpuDaiDevShutdown(audioCard, audioCard->rtd->cpuDai);
347     if (ret != HDF_SUCCESS) {
348         ADM_LOG_ERR("CpuDaiDevShutdown failed.");
349         return HDF_FAILURE;
350     }
351 
352     ret = CodecDaiDevShutdown(audioCard, audioCard->rtd->codecDai);
353     if (ret != HDF_SUCCESS) {
354         ADM_LOG_ERR("CodecDaiDevShutdown failed.");
355         return HDF_FAILURE;
356     }
357 
358     ret = DspDaiDevShutdown(audioCard, audioCard->rtd->dspDai);
359     if (ret != HDF_SUCCESS) {
360         ADM_LOG_ERR("DspDaiDevShutdown failed.");
361         return HDF_FAILURE;
362     }
363     return HDF_SUCCESS;
364 }
365 
CpuDaiDevMuteStream(const struct AudioCard * audioCard,const struct DaiDevice * cpuDai,bool mute,int32_t direction)366 static int32_t CpuDaiDevMuteStream(const struct AudioCard *audioCard, const struct DaiDevice *cpuDai,
367     bool mute, int32_t direction)
368 {
369     int32_t ret;
370     if (audioCard == NULL) {
371         ADM_LOG_ERR("audioCard is null.");
372         return HDF_FAILURE;
373     }
374     if (cpuDai != NULL && cpuDai->devData != NULL && cpuDai->devData->ops != NULL &&
375         cpuDai->devData->ops->MuteStream != NULL) {
376         ret = cpuDai->devData->ops->MuteStream(audioCard, cpuDai, mute, direction);
377         if (ret != HDF_SUCCESS) {
378             ADM_LOG_ERR("cpuDai MuteStream failed ret=%d.", ret);
379             return HDF_FAILURE;
380         }
381     } else {
382         ADM_LOG_DEBUG("cpu dai MuteStream is null.");
383     }
384     return HDF_SUCCESS;
385 }
386 
CodecDaiDevMuteStream(const struct AudioCard * audioCard,const struct DaiDevice * codecDai,bool mute,int32_t direction)387 static int32_t CodecDaiDevMuteStream(const struct AudioCard *audioCard, const struct DaiDevice *codecDai,
388     bool mute, int32_t direction)
389 {
390     int32_t ret;
391     if (audioCard == NULL) {
392         ADM_LOG_ERR("audioCard is null.");
393         return HDF_FAILURE;
394     }
395     if (codecDai != NULL && codecDai->devData != NULL && codecDai->devData->ops != NULL &&
396         codecDai->devData->ops->MuteStream != NULL) {
397         ret = codecDai->devData->ops->MuteStream(audioCard, codecDai, mute, direction);
398         if (ret != HDF_SUCCESS) {
399             ADM_LOG_ERR("codecDai MuteStream failed ret=%d.", ret);
400             return HDF_FAILURE;
401         }
402     } else {
403         ADM_LOG_DEBUG("codec dai MuteStream is null.");
404     }
405 
406     return HDF_SUCCESS;
407 }
408 
DspDaiDevMuteStream(const struct AudioCard * audioCard,const struct DaiDevice * dspDai,bool mute,int32_t direction)409 static int32_t DspDaiDevMuteStream(const struct AudioCard *audioCard, const struct DaiDevice *dspDai,
410     bool mute, int32_t direction)
411 {
412     int32_t ret;
413     if (audioCard == NULL) {
414         ADM_LOG_ERR("audioCard is null.");
415         return HDF_FAILURE;
416     }
417     if (dspDai != NULL && dspDai->devData != NULL && dspDai->devData->ops != NULL &&
418         dspDai->devData->ops->MuteStream != NULL) {
419         ret = dspDai->devData->ops->MuteStream(audioCard, dspDai, mute, direction);
420         if (ret != HDF_SUCCESS) {
421             ADM_LOG_ERR("dspDai Shutdown failed ret=%d.", ret);
422             return HDF_FAILURE;
423         }
424     } else {
425         ADM_LOG_DEBUG("dsp dai Shutdown is null.");
426     }
427     return HDF_SUCCESS;
428 }
429 
AudioDaiDeviceMuteStream(const struct AudioCard * audioCard,bool mute,int32_t direction)430 static int32_t AudioDaiDeviceMuteStream(const struct AudioCard *audioCard, bool mute, int32_t direction)
431 {
432     int32_t ret;
433 
434     if (audioCard == NULL || audioCard->rtd == NULL) {
435         ADM_LOG_ERR("audioCard is null.");
436         return HDF_FAILURE;
437     }
438 
439     ret = CpuDaiDevMuteStream(audioCard, audioCard->rtd->cpuDai, mute, direction);
440     if (ret != HDF_SUCCESS) {
441         ADM_LOG_ERR("CpuDaiDevMuteStream failed.");
442         return HDF_FAILURE;
443     }
444 
445     ret = CodecDaiDevMuteStream(audioCard, audioCard->rtd->codecDai, mute, direction);
446     if (ret != HDF_SUCCESS) {
447         ADM_LOG_ERR("CodecDaiDevMuteStream failed.");
448         return HDF_FAILURE;
449     }
450 
451     ret = DspDaiDevMuteStream(audioCard, audioCard->rtd->dspDai, mute, direction);
452     if (ret != HDF_SUCCESS) {
453         ADM_LOG_ERR("DspDaiDevMuteStream failed.");
454         return HDF_FAILURE;
455     }
456     return HDF_SUCCESS;
457 }
458 
HwParamsDataAnalysis(struct HdfSBuf * reqData,struct AudioPcmHwParams * params)459 static int32_t HwParamsDataAnalysis(struct HdfSBuf *reqData, struct AudioPcmHwParams *params)
460 {
461     if (!HdfSbufReadUint32(reqData, &params->streamType)) {
462         ADM_LOG_ERR("read request streamType failed!");
463         return HDF_FAILURE;
464     }
465     if (!HdfSbufReadUint32(reqData, &params->channels)) {
466         ADM_LOG_ERR("read request channels failed!");
467         return HDF_FAILURE;
468     }
469     if (!HdfSbufReadUint32(reqData, &params->rate)) {
470         ADM_LOG_ERR("read request rate failed!");
471         return HDF_FAILURE;
472     }
473     if (!HdfSbufReadUint32(reqData, &params->periodSize) ||
474         !HdfSbufReadUint32(reqData, &params->periodCount)) {
475         ADM_LOG_ERR("read request periodSize or periodCount failed!");
476         return HDF_FAILURE;
477     }
478     if (!HdfSbufReadUint32(reqData, (uint32_t *)&params->format)) {
479         ADM_LOG_ERR("read request format failed!");
480         return HDF_FAILURE;
481     }
482     if (!(params->cardServiceName = HdfSbufReadString(reqData))) {
483         ADM_LOG_ERR("read request cardServiceName failed!");
484         return HDF_FAILURE;
485     }
486     if (!HdfSbufReadUint32(reqData, &params->period)) {
487         HDF_LOGE("read request perid failed!");
488         return HDF_FAILURE;
489     }
490     ADM_LOG_INFO("params->period = %d", params->period);
491     if (!HdfSbufReadUint32(reqData, &params->frameSize)) {
492         HDF_LOGE("read request frameSize failed!");
493         return HDF_FAILURE;
494     }
495     if (!HdfSbufReadUint32(reqData, (uint32_t *)&params->isBigEndian) ||
496         !HdfSbufReadUint32(reqData, (uint32_t *)&params->isSignedData)) {
497         HDF_LOGE("read request isBigEndian or isSignedData failed!");
498         return HDF_FAILURE;
499     }
500     if (!HdfSbufReadUint32(reqData, &params->startThreshold) ||
501         !HdfSbufReadUint32(reqData, &params->stopThreshold) ||
502         !HdfSbufReadUint32(reqData, &params->silenceThreshold)) {
503         HDF_LOGE("read request Threshold params failed!");
504         return HDF_FAILURE;
505     }
506     return HDF_SUCCESS;
507 }
508 
StreamHostGetCardInstance(struct HdfSBuf * data)509 static struct AudioCard *StreamHostGetCardInstance(struct HdfSBuf *data)
510 {
511     struct AudioCard *audioCard = NULL;
512     const char *cardServiceName = NULL;
513 
514     cardServiceName = HdfSbufReadString(data);
515     if (cardServiceName == NULL) {
516         ADM_LOG_ERR("Read request cardServiceName failed!");
517         return NULL;
518     }
519 
520     audioCard = GetCardInstance(cardServiceName);
521     return audioCard;
522 }
523 
StreamHostHwParams(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)524 static int32_t StreamHostHwParams(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
525     struct HdfSBuf *reply)
526 {
527     struct AudioPcmHwParams params;
528     struct AudioCard *audioCard = NULL;
529     int32_t ret;
530     ADM_LOG_INFO("entry.");
531 
532     if ((client == NULL || client->device == NULL) || (data == NULL)) {
533         ADM_LOG_ERR("input param is NULL.");
534         return HDF_FAILURE;
535     }
536     (void)reply;
537 
538     (void)memset_s(&params, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams));
539 
540     ret = HwParamsDataAnalysis(data, &params);
541     if (ret != HDF_SUCCESS) {
542         ADM_LOG_ERR("hwparams data analysis failed ret=%d", ret);
543         return HDF_FAILURE;
544     }
545     audioCard = GetCardInstance(params.cardServiceName);
546     if (audioCard == NULL) {
547         ADM_LOG_ERR("get card instance failed.");
548         return HDF_FAILURE;
549     }
550     ret = HwParamsDispatch(audioCard, &params);
551     if (ret != HDF_SUCCESS) {
552         ADM_LOG_ERR("hwparams dispatch failed ret=%d", ret);
553         return HDF_FAILURE;
554     }
555     ADM_LOG_INFO("params->period = %d", params.period);
556     ADM_LOG_DEBUG("success.");
557     return HDF_SUCCESS;
558 }
559 
StreamHostCapturePrepare(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)560 static int32_t StreamHostCapturePrepare(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
561     struct HdfSBuf *reply)
562 {
563     struct AudioCard *audioCard = NULL;
564     int32_t ret;
565 
566     if (client == NULL) {
567         ADM_LOG_ERR("CapturePrepare input param is NULL.");
568         return HDF_FAILURE;
569     }
570 
571     (void)reply;
572 
573     audioCard = StreamHostGetCardInstance(data);
574     if (audioCard == NULL) {
575         ADM_LOG_ERR("CapturePrepare get card instance or rtd failed.");
576         return HDF_FAILURE;
577     }
578 
579     ret = AudioCapturePrepare(audioCard);
580     if (ret != HDF_SUCCESS) {
581         ADM_LOG_ERR("platform CapturePrepare failed ret=%d", ret);
582         return HDF_ERR_IO;
583     }
584 
585     ret = AudioDaiDeviceMuteStream(audioCard, false, AUDIO_CAPTURE_STREAM_IN);
586     if (ret != HDF_SUCCESS) {
587         ADM_LOG_ERR("platform MuteStream failed ret=%d", ret);
588         return HDF_ERR_IO;
589     }
590 
591     ADM_LOG_DEBUG("success.");
592     return HDF_SUCCESS;
593 }
594 
StreamHostCaptureOpen(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)595 static int32_t StreamHostCaptureOpen(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
596     struct HdfSBuf *reply)
597 {
598     struct AudioCard *audioCard = NULL;
599 
600     ADM_LOG_INFO("entry.");
601 
602     if (data == NULL) {
603         ADM_LOG_ERR("StreamHostCaptureOpen input param is NULL.");
604         return HDF_FAILURE;
605     }
606     (void)reply;
607     (void)client;
608 
609     audioCard = StreamHostGetCardInstance(data);
610     if (audioCard == NULL) {
611         ADM_LOG_ERR("StreamHostCaptureOpen get card instance or rtd failed.");
612         return HDF_FAILURE;
613     }
614 
615     if (AudioCaptureOpen(audioCard) != HDF_SUCCESS) {
616         ADM_LOG_ERR("platform CaptureOpen failed");
617         return HDF_ERR_IO;
618     }
619 
620     if (AudioDaiDeviceStartup(audioCard) != HDF_SUCCESS) {
621         ADM_LOG_ERR("Dai Device Startup failed.");
622         return HDF_FAILURE;
623     }
624 
625     ADM_LOG_DEBUG("success.");
626     return HDF_SUCCESS;
627 }
628 
StreamHostRenderPrepare(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)629 static int32_t StreamHostRenderPrepare(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
630     struct HdfSBuf *reply)
631 {
632     struct AudioCard *audioCard = NULL;
633     int32_t ret;
634 
635     if (data == NULL) {
636         ADM_LOG_ERR("RenderPrepare input param is NULL.");
637         return HDF_FAILURE;
638     }
639 
640     (void)reply;
641     (void)client;
642 
643     audioCard = StreamHostGetCardInstance(data);
644     if (audioCard == NULL || audioCard->rtd == NULL) {
645         ADM_LOG_ERR("RenderPrepare get card instance or rtd failed.");
646         return HDF_FAILURE;
647     }
648 
649     ret = AudioRenderPrepare(audioCard);
650     if (ret != HDF_SUCCESS) {
651         ADM_LOG_ERR("platform RenderPrepare failed ret=%d", ret);
652         return HDF_ERR_IO;
653     }
654 
655     ret = AudioDaiDeviceMuteStream(audioCard, false, AUDIO_RENDER_STREAM_OUT);
656     if (ret != HDF_SUCCESS) {
657         ADM_LOG_ERR("platform MuteStream failed ret=%d", ret);
658         return HDF_ERR_IO;
659     }
660 
661     ADM_LOG_DEBUG("success.");
662     return HDF_SUCCESS;
663 }
664 
StreamHostRenderOpen(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)665 static int32_t StreamHostRenderOpen(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
666     struct HdfSBuf *reply)
667 {
668     ADM_LOG_INFO("entry.");
669     struct AudioCard *audioCard = NULL;
670 
671     (void)reply;
672     (void)client;
673 
674     if (data == NULL) {
675         ADM_LOG_ERR("StreamHostRenderOpen input param is NULL.");
676         return HDF_FAILURE;
677     }
678 
679     audioCard = StreamHostGetCardInstance(data);
680     if (audioCard == NULL || audioCard->rtd == NULL) {
681         ADM_LOG_ERR("StreamHostRenderOpen get card instance or rtd failed.");
682         return HDF_FAILURE;
683     }
684 
685     if (AudioRenderOpen(audioCard) != HDF_SUCCESS) {
686         ADM_LOG_ERR("platform RenderOpen failed.");
687         return HDF_FAILURE;
688     }
689 
690     if (AudioDaiDeviceStartup(audioCard) != HDF_SUCCESS) {
691         ADM_LOG_ERR("Dai Device Startup failed.");
692         return HDF_FAILURE;
693     }
694 
695     ADM_LOG_DEBUG("success.");
696     return HDF_SUCCESS;
697 }
698 
StreamTransferWrite(const struct AudioCard * audioCard,struct AudioTxData * transfer)699 static int32_t StreamTransferWrite(const struct AudioCard *audioCard, struct AudioTxData *transfer)
700 {
701     int32_t ret;
702 
703     if (audioCard == NULL || transfer == NULL) {
704         ADM_LOG_ERR("input param is NULL.");
705         return HDF_FAILURE;
706     }
707 
708     ret = AudioPcmWrite(audioCard, transfer);
709     if (ret != HDF_SUCCESS) {
710         ADM_LOG_ERR("pcm write failed ret=%d", ret);
711         return HDF_FAILURE;
712     }
713 
714     return HDF_SUCCESS;
715 }
716 
StreamTransferMmapWrite(const struct AudioCard * audioCard,const struct AudioMmapData * txMmapData)717 static int32_t StreamTransferMmapWrite(const struct AudioCard *audioCard, const struct AudioMmapData *txMmapData)
718 {
719     int32_t ret;
720     ADM_LOG_DEBUG("entry.");
721 
722     if (audioCard == NULL || txMmapData == NULL) {
723         ADM_LOG_ERR("input param is NULL.");
724         return HDF_FAILURE;
725     }
726 
727     ret = AudioPcmMmapWrite(audioCard, txMmapData);
728     if (ret != HDF_SUCCESS) {
729         ADM_LOG_ERR("platform write failed ret=%d", ret);
730         return HDF_FAILURE;
731     }
732 
733     ADM_LOG_DEBUG("success.");
734     return HDF_SUCCESS;
735 }
736 
StreamTransferMmapRead(const struct AudioCard * audioCard,const struct AudioMmapData * rxMmapData)737 static int32_t StreamTransferMmapRead(const struct AudioCard *audioCard, const struct AudioMmapData *rxMmapData)
738 {
739     int32_t ret;
740     ADM_LOG_DEBUG("entry.");
741 
742     if (audioCard == NULL || rxMmapData == NULL) {
743         ADM_LOG_ERR("input param is NULL.");
744         return HDF_FAILURE;
745     }
746 
747     ret = AudioPcmMmapRead(audioCard, rxMmapData);
748     if (ret != HDF_SUCCESS) {
749         ADM_LOG_ERR("platform read failed ret=%d", ret);
750         return HDF_FAILURE;
751     }
752 
753     ADM_LOG_DEBUG("sucess.");
754     return HDF_SUCCESS;
755 }
756 
StreamHostWrite(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)757 static int32_t StreamHostWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
758 {
759     struct AudioTxData transfer;
760     struct AudioCard *audioCard = NULL;
761     int32_t ret;
762     uint32_t dataSize = 0;
763 
764     if (data == NULL || reply == NULL) {
765         ADM_LOG_ERR("input param is NULL.");
766         return HDF_FAILURE;
767     }
768 
769     audioCard = StreamHostGetCardInstance(data);
770     if (audioCard == NULL || audioCard->rtd == NULL) {
771         ADM_LOG_ERR("get card instance or rtd failed.");
772         return HDF_FAILURE;
773     }
774     (void)memset_s(&transfer, sizeof(struct AudioTxData), 0, sizeof(struct AudioTxData));
775 
776     if (!HdfSbufReadUint32(data, (uint32_t *)&(transfer.frames))) {
777         ADM_LOG_ERR("read request frames failed!");
778         return HDF_FAILURE;
779     }
780     if (!HdfSbufReadBuffer(data, (const void **)&(transfer.buf), &dataSize)) {
781         ADM_LOG_ERR("read request buf failed!");
782         return HDF_FAILURE;
783     }
784 
785     ret = StreamTransferWrite(audioCard, &transfer);
786     if (ret != HDF_SUCCESS) {
787         ADM_LOG_ERR("write reg value failed ret=%d", ret);
788         return HDF_FAILURE;
789     }
790 
791     if (!HdfSbufWriteInt32(reply, (int32_t)(transfer.status))) {
792         ADM_LOG_ERR("read response status failed!");
793         return HDF_FAILURE;
794     }
795     ADM_LOG_DEBUG("card name: %s success.", audioCard->configData.cardServiceName);
796     return HDF_SUCCESS;
797 }
798 
StreamHostRead(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)799 static int32_t StreamHostRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
800 {
801     struct AudioCard *audioCard = NULL;
802     struct AudioRxData rxData;
803     int32_t ret;
804 
805     if (data == NULL || reply == NULL) {
806         ADM_LOG_ERR("input param is NULL.");
807         return HDF_FAILURE;
808     }
809     (void)client;
810 
811     audioCard = StreamHostGetCardInstance(data);
812     if (audioCard == NULL) {
813         ADM_LOG_ERR("get card instance or rtd failed.");
814         return HDF_FAILURE;
815     }
816 
817     ret = AudioPcmRead(audioCard, &rxData);
818     if (ret != HDF_SUCCESS) {
819         ADM_LOG_ERR("pcm read failed ret=%d", ret);
820         return HDF_FAILURE;
821     }
822 
823     if (!HdfSbufWriteInt32(reply, (int32_t)(rxData.status))) {
824         ADM_LOG_ERR("write request data status failed!");
825         return HDF_FAILURE;
826     }
827 
828     if (rxData.bufSize != 0) {
829         if (!HdfSbufWriteBuffer(reply, rxData.buf, (uint32_t)(rxData.bufSize))) {
830             ADM_LOG_ERR("write request data buf failed!");
831             return HDF_FAILURE;
832         }
833 
834         if (!HdfSbufWriteUint32(reply, (uint32_t)(rxData.frames))) {
835             ADM_LOG_ERR("write frames failed!");
836             return HDF_FAILURE;
837         }
838     }
839 
840     ADM_LOG_DEBUG("success.");
841     return HDF_SUCCESS;
842 }
843 
StreamHostParseTxMmapData(struct HdfSBuf * data,struct AudioMmapData * txMmapData)844 static int32_t StreamHostParseTxMmapData(struct HdfSBuf *data, struct AudioMmapData *txMmapData)
845 {
846     if (!HdfSbufReadInt32(data, (uint32_t *)&(txMmapData->memoryFd))) {
847         ADM_LOG_ERR("render mmap read request memory fd failed!");
848         return HDF_FAILURE;
849     }
850     if (!HdfSbufReadInt32(data, (uint32_t *)&(txMmapData->totalBufferFrames))) {
851         ADM_LOG_ERR("render mmap read request total buffer frames failed!");
852         return HDF_FAILURE;
853     }
854     if (!HdfSbufReadInt32(data, (uint32_t *)&(txMmapData->transferFrameSize))) {
855         ADM_LOG_ERR("render mmap read request transfer frame size failed!");
856         return HDF_FAILURE;
857     }
858     if (!HdfSbufReadInt32(data, (uint32_t *)&(txMmapData->isShareable))) {
859         ADM_LOG_ERR("render mmap read request is share able failed!");
860         return HDF_FAILURE;
861     }
862     if (!HdfSbufReadUint32(data, (uint32_t *)&(txMmapData->offset))) {
863         ADM_LOG_ERR("render mmap read request offset failed!");
864         return HDF_FAILURE;
865     }
866     return HDF_SUCCESS;
867 }
868 
StreamHostMmapWrite(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)869 static int32_t StreamHostMmapWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
870 {
871     struct AudioMmapData txMmapData;
872     struct AudioCard *audioCard = NULL;
873     uint64_t mAddress = 0;
874 
875     if (data == NULL || reply == NULL) {
876         ADM_LOG_ERR("input param is NULL.");
877         return HDF_FAILURE;
878     }
879     (void)client;
880     audioCard = StreamHostGetCardInstance(data);
881 
882     if (!HdfSbufReadUint64(data, &mAddress)) {
883         ADM_LOG_ERR("render mmap read request memory address failed!");
884         return HDF_FAILURE;
885     }
886 
887     (void)memset_s(&txMmapData, sizeof(struct AudioMmapData), 0, sizeof(struct AudioMmapData));
888     txMmapData.memoryAddress = (void *)((uintptr_t)mAddress);
889     if (txMmapData.memoryAddress == NULL) {
890         ADM_LOG_ERR("txMmapData.memoryAddress is NULL.");
891         return HDF_FAILURE;
892     }
893     if (StreamHostParseTxMmapData(data, &txMmapData) != HDF_SUCCESS) {
894         return HDF_FAILURE;
895     }
896 
897     if (StreamTransferMmapWrite(audioCard, &txMmapData) != HDF_SUCCESS) {
898         ADM_LOG_ERR("render mmap write reg value failed!");
899         return HDF_FAILURE;
900     }
901     ADM_LOG_DEBUG("success.");
902     return HDF_SUCCESS;
903 }
904 
StreamHostMmapPositionWrite(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)905 static int32_t StreamHostMmapPositionWrite(const struct HdfDeviceIoClient *client,
906     struct HdfSBuf *data, struct HdfSBuf *reply)
907 {
908     struct AudioCard *audioCard = NULL;
909     struct PlatformData *platform = NULL;
910 
911     ADM_LOG_DEBUG("entry.");
912     (void)client;
913 
914     if (data == NULL || reply == NULL) {
915         ADM_LOG_ERR("input param is NULL.");
916         return HDF_FAILURE;
917     }
918 
919     audioCard = StreamHostGetCardInstance(data);
920     if (audioCard == NULL) {
921         ADM_LOG_ERR("audioCard instance is NULL.");
922         return HDF_FAILURE;
923     }
924     platform = PlatformDataFromCard(audioCard);
925     if (platform == NULL) {
926         ADM_LOG_ERR("platformHost instance is NULL.");
927         return HDF_FAILURE;
928     }
929     if (!HdfSbufWriteUint64(reply, platform->renderBufInfo.framesPosition)) {
930         ADM_LOG_ERR("render mmap write position failed!");
931         return HDF_FAILURE;
932     }
933     ADM_LOG_DEBUG("success.");
934     return HDF_SUCCESS;
935 }
936 
StreamHostParseRxMmapData(struct HdfSBuf * data,struct AudioMmapData * rxMmapData)937 static int32_t StreamHostParseRxMmapData(struct HdfSBuf *data, struct AudioMmapData *rxMmapData)
938 {
939     if (!HdfSbufReadInt32(data, (uint32_t *)&(rxMmapData->memoryFd))) {
940         ADM_LOG_ERR("capture mmap read request memory fd failed!");
941         return HDF_FAILURE;
942     }
943     if (!HdfSbufReadInt32(data, (uint32_t *)&(rxMmapData->totalBufferFrames))) {
944         ADM_LOG_ERR("capture mmap read request total buffer frames failed!");
945         return HDF_FAILURE;
946     }
947     if (!HdfSbufReadInt32(data, (uint32_t *)&(rxMmapData->transferFrameSize))) {
948         ADM_LOG_ERR("capture mmap read request transfer frame size failed!");
949         return HDF_FAILURE;
950     }
951     if (!HdfSbufReadInt32(data, (uint32_t *)&(rxMmapData->isShareable))) {
952         ADM_LOG_ERR("capture mmap read request is share able failed!");
953         return HDF_FAILURE;
954     }
955     if (!HdfSbufReadUint32(data, (uint32_t *)&(rxMmapData->offset))) {
956         ADM_LOG_ERR("capture mmap read request offset failed!");
957         return HDF_FAILURE;
958     }
959     return HDF_SUCCESS;
960 }
961 
StreamHostMmapRead(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)962 static int32_t StreamHostMmapRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
963 {
964     uint64_t mAddress = 0;
965     struct AudioCard *audioCard = NULL;
966     struct AudioMmapData rxMmapData;
967 
968     if (data == NULL || reply == NULL) {
969         ADM_LOG_ERR("input param is NULL.");
970         return HDF_FAILURE;
971     }
972     (void)client;
973     audioCard = StreamHostGetCardInstance(data);
974 
975     if (!HdfSbufReadUint64(data, &mAddress)) {
976         ADM_LOG_ERR("capture mmap read request memory address failed!");
977         return HDF_FAILURE;
978     }
979 
980     (void)memset_s(&rxMmapData, sizeof(struct AudioMmapData), 0, sizeof(struct AudioMmapData));
981     rxMmapData.memoryAddress = (void *)((uintptr_t)mAddress);
982     if (rxMmapData.memoryAddress == NULL) {
983         ADM_LOG_ERR("rxMmapData.memoryAddress is NULL.");
984         return HDF_FAILURE;
985     }
986 
987     if (StreamHostParseRxMmapData(data, &rxMmapData) != HDF_SUCCESS) {
988         return HDF_FAILURE;
989     }
990 
991     if (StreamTransferMmapRead(audioCard, &rxMmapData) != HDF_SUCCESS) {
992         ADM_LOG_ERR("capture mmap read reg value failed!");
993         return HDF_FAILURE;
994     }
995     ADM_LOG_DEBUG("success.");
996     return HDF_SUCCESS;
997 }
998 
StreamHostMmapPositionRead(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)999 static int32_t StreamHostMmapPositionRead(const struct HdfDeviceIoClient *client,
1000     struct HdfSBuf *data, struct HdfSBuf *reply)
1001 {
1002     struct AudioCard *audioCard = NULL;
1003     struct PlatformData *platformData = NULL;
1004 
1005     if (data == NULL || reply == NULL) {
1006         ADM_LOG_ERR("input param is NULL.");
1007         return HDF_FAILURE;
1008     }
1009     (void)client;
1010 
1011     audioCard = StreamHostGetCardInstance(data);
1012     if (audioCard == NULL) {
1013         ADM_LOG_ERR("audioCard is NULL.");
1014         return HDF_FAILURE;
1015     }
1016     platformData = PlatformDataFromCard(audioCard);
1017     if (platformData == NULL) {
1018         ADM_LOG_ERR("platformHost is NULL.");
1019         return HDF_FAILURE;
1020     }
1021     if (!HdfSbufWriteUint64(reply, platformData->captureBufInfo.framesPosition)) {
1022         ADM_LOG_ERR("render mmap write position failed!");
1023         return HDF_FAILURE;
1024     }
1025     ADM_LOG_DEBUG("success.");
1026     return HDF_SUCCESS;
1027 }
1028 
StreamTriggerRouteImpl(const struct AudioCard * audioCard,const struct AudioRuntimeDeivces * rtd,enum StreamDispMethodCmd methodCmd)1029 static int32_t StreamTriggerRouteImpl(const struct AudioCard *audioCard, const struct AudioRuntimeDeivces *rtd,
1030     enum StreamDispMethodCmd methodCmd)
1031 {
1032     int32_t ret;
1033     struct DaiDevice *cpuDai = NULL;
1034     struct DaiDevice *codecDai = NULL;
1035     struct DaiDevice *dspDai = NULL;
1036     if (audioCard == NULL || rtd == NULL) {
1037         ADM_LOG_ERR("input param is NULL.");
1038         return HDF_FAILURE;
1039     }
1040     cpuDai = rtd->cpuDai;
1041     if (cpuDai != NULL && cpuDai->devData != NULL && cpuDai->devData->ops != NULL &&
1042         cpuDai->devData->ops->Trigger != NULL) {
1043         ret = cpuDai->devData->ops->Trigger(audioCard, methodCmd, cpuDai);
1044         if (ret != HDF_SUCCESS) {
1045             ADM_LOG_ERR("cpuDai Trigger failed.");
1046             return HDF_FAILURE;
1047         }
1048     }
1049     codecDai = rtd->codecDai;
1050     if (codecDai != NULL && codecDai->devData != NULL && codecDai->devData->ops != NULL &&
1051         codecDai->devData->ops->Trigger != NULL) {
1052         ret = codecDai->devData->ops->Trigger(audioCard, methodCmd, codecDai);
1053         if (ret != HDF_SUCCESS) {
1054             ADM_LOG_ERR("codecDai Trigger failed.");
1055             return HDF_FAILURE;
1056         }
1057     }
1058 
1059     dspDai = rtd->dspDai;
1060     if (dspDai != NULL && dspDai->devData != NULL && dspDai->devData->ops != NULL &&
1061         dspDai->devData->ops->Trigger != NULL) {
1062         ret = dspDai->devData->ops->Trigger(audioCard, methodCmd, dspDai);
1063         if (ret != HDF_SUCCESS) {
1064             ADM_LOG_ERR("dspDai Trigger failed.");
1065             return HDF_FAILURE;
1066         }
1067     }
1068     return HDF_SUCCESS;
1069 }
1070 
StreamHostRenderStart(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1071 static int32_t StreamHostRenderStart(const struct HdfDeviceIoClient *client,
1072     struct HdfSBuf *data, struct HdfSBuf *reply)
1073 {
1074     struct AudioRuntimeDeivces *rtd = NULL;
1075     struct AudioCard *audioCard = NULL;
1076     int32_t ret;
1077 
1078     if (data == NULL) {
1079         ADM_LOG_ERR("RenderStart input param is NULL.");
1080         return HDF_FAILURE;
1081     }
1082 
1083     (void)reply;
1084     (void)client;
1085     audioCard = StreamHostGetCardInstance(data);
1086     if (audioCard == NULL || audioCard->rtd == NULL) {
1087         ADM_LOG_ERR("RenderStart get card instance or rtd failed.");
1088         return HDF_FAILURE;
1089     }
1090     rtd = audioCard->rtd;
1091     audioCard->standbyMode = AUDIO_SAPM_TURN_STANDBY_LATER;
1092     ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_RENDER_START);
1093     if (ret != HDF_SUCCESS) {
1094         ADM_LOG_ERR("StreamTriggerRouteImpl failed");
1095         return HDF_FAILURE;
1096     }
1097     ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_RENDER_START);
1098     if (ret != HDF_SUCCESS) {
1099         ADM_LOG_ERR("platform render start failed ret=%d", ret);
1100         return HDF_ERR_IO;
1101     }
1102     ADM_LOG_DEBUG("success.");
1103     return HDF_SUCCESS;
1104 }
1105 
StreamHostCaptureStart(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1106 static int32_t StreamHostCaptureStart(const struct HdfDeviceIoClient *client,
1107     struct HdfSBuf *data, struct HdfSBuf *reply)
1108 {
1109     struct AudioRuntimeDeivces *rtd = NULL;
1110     struct AudioCard *audioCard = NULL;
1111     int32_t ret;
1112 
1113     if (data == NULL) {
1114         ADM_LOG_ERR("CaptureStart input param is NULL.");
1115         return HDF_FAILURE;
1116     }
1117 
1118     (void)reply;
1119     (void)client;
1120     audioCard = StreamHostGetCardInstance(data);
1121     if (audioCard == NULL || audioCard->rtd == NULL) {
1122         ADM_LOG_ERR("CaptureStart get card instance or rtd failed.");
1123         return HDF_FAILURE;
1124     }
1125     audioCard->standbyMode = AUDIO_SAPM_TURN_STANDBY_LATER;
1126     rtd = audioCard->rtd;
1127     ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_CAPTURE_START);
1128     if (ret != HDF_SUCCESS) {
1129         ADM_LOG_ERR("StreamTriggerRouteImpl failed");
1130         return HDF_FAILURE;
1131     }
1132     ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_CAPTURE_START);
1133     if (ret != HDF_SUCCESS) {
1134         ADM_LOG_ERR("platform capture start failed ret=%d", ret);
1135         return HDF_ERR_IO;
1136     }
1137 
1138     ADM_LOG_DEBUG("success.");
1139     return HDF_SUCCESS;
1140 }
1141 
StreamHostRenderStop(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1142 static int32_t StreamHostRenderStop(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
1143     struct HdfSBuf *reply)
1144 {
1145     struct AudioRuntimeDeivces *rtd = NULL;
1146     struct AudioCard *audioCard = NULL;
1147     int32_t ret;
1148 
1149     if (data == NULL) {
1150         ADM_LOG_ERR("RenderStop input param is NULL.");
1151         return HDF_FAILURE;
1152     }
1153     (void)reply;
1154     (void)client;
1155 
1156     audioCard = StreamHostGetCardInstance(data);
1157     if (audioCard == NULL || audioCard->rtd == NULL) {
1158         ADM_LOG_ERR("RenderStop get card instance or rtd failed.");
1159         return HDF_FAILURE;
1160     }
1161     if (!HdfSbufReadUint32(data, &audioCard->standbyMode)) {
1162         ADM_LOG_ERR("read request streamType failed!");
1163         return HDF_FAILURE;
1164     }
1165     rtd = audioCard->rtd;
1166     ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_RENDER_STOP);
1167     if (ret != HDF_SUCCESS) {
1168         ADM_LOG_ERR("StreamTriggerRouteImpl failed");
1169         return HDF_FAILURE;
1170     }
1171     ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_RENDER_STOP);
1172     if (ret != HDF_SUCCESS) {
1173         ADM_LOG_ERR("platform render stop failed ret=%d", ret);
1174         return HDF_ERR_IO;
1175     }
1176 
1177     ADM_LOG_DEBUG("success.");
1178     return HDF_SUCCESS;
1179 }
1180 
StreamHostRenderClose(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1181 static int32_t StreamHostRenderClose(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
1182     struct HdfSBuf *reply)
1183 {
1184     ADM_LOG_INFO("entry.");
1185     struct AudioCard *audioCard = NULL;
1186     int32_t ret;
1187 
1188     if (data == NULL) {
1189         ADM_LOG_ERR("RenderClose input param is NULL.");
1190         return HDF_FAILURE;
1191     }
1192 
1193     (void)reply;
1194     (void)client;
1195 
1196     audioCard = StreamHostGetCardInstance(data);
1197     if (audioCard == NULL || audioCard->rtd == NULL) {
1198         ADM_LOG_ERR("RenderStop get card instance or rtd failed.");
1199         return HDF_FAILURE;
1200     }
1201 
1202     ret = AudioDaiDeviceMuteStream(audioCard, true, AUDIO_RENDER_STREAM_OUT);
1203     if (ret != HDF_SUCCESS) {
1204         ADM_LOG_ERR("RenderClose MuteStream failed ret=%d", ret);
1205         return HDF_ERR_IO;
1206     }
1207 
1208     if (AudioDaiDeviceShutdown(audioCard) != HDF_SUCCESS) {
1209         ADM_LOG_ERR("Dai Device Shutdown failed.");
1210         return HDF_FAILURE;
1211     }
1212 
1213     ret = AudioRenderClose(audioCard);
1214     if (ret != HDF_SUCCESS) {
1215         ADM_LOG_ERR("platform RenderClose failed ret=%d", ret);
1216         return HDF_ERR_IO;
1217     }
1218 
1219     ADM_LOG_DEBUG("success.");
1220     return HDF_SUCCESS;
1221 }
1222 
StreamHostCaptureStop(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1223 static int32_t StreamHostCaptureStop(const struct HdfDeviceIoClient *client,
1224     struct HdfSBuf *data, struct HdfSBuf *reply)
1225 {
1226     struct AudioRuntimeDeivces *rtd = NULL;
1227     struct AudioCard *audioCard = NULL;
1228     int32_t ret;
1229 
1230     if (data == NULL) {
1231         ADM_LOG_ERR("CaptureStop input param is NULL.");
1232         return HDF_FAILURE;
1233     }
1234 
1235     (void)reply;
1236     (void)client;
1237 
1238     audioCard = StreamHostGetCardInstance(data);
1239     if (audioCard == NULL || audioCard->rtd == NULL) {
1240         ADM_LOG_ERR("CaptureStop get card instance or rtd failed.");
1241         return HDF_FAILURE;
1242     }
1243 
1244     if (!HdfSbufReadUint32(data, &audioCard->standbyMode)) {
1245         ADM_LOG_ERR("read request streamType failed!");
1246         return HDF_FAILURE;
1247     }
1248     rtd = audioCard->rtd;
1249     ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP);
1250     if (ret != HDF_SUCCESS) {
1251         ADM_LOG_ERR("StreamTriggerRouteImpl failed");
1252         return HDF_FAILURE;
1253     }
1254     ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP);
1255     if (ret != HDF_SUCCESS) {
1256         ADM_LOG_ERR("platform capture stop failed ret=%d", ret);
1257         return HDF_ERR_IO;
1258     }
1259 
1260     ADM_LOG_DEBUG("success.");
1261     return HDF_SUCCESS;
1262 }
1263 
StreamHostCaptureClose(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1264 static int32_t StreamHostCaptureClose(const struct HdfDeviceIoClient *client,
1265     struct HdfSBuf *data, struct HdfSBuf *reply)
1266 {
1267     ADM_LOG_INFO("entry.");
1268     struct AudioCard *audioCard = NULL;
1269     int32_t ret;
1270 
1271     if (data == NULL) {
1272         ADM_LOG_ERR("CaptureClose input param is NULL.");
1273         return HDF_FAILURE;
1274     }
1275 
1276     (void)reply;
1277     (void)client;
1278 
1279     audioCard = StreamHostGetCardInstance(data);
1280     if (audioCard == NULL || audioCard->rtd == NULL) {
1281         ADM_LOG_ERR("CaptureStop get card instance or rtd failed.");
1282         return HDF_FAILURE;
1283     }
1284 
1285     ret = AudioDaiDeviceMuteStream(audioCard, true, AUDIO_CAPTURE_STREAM_IN);
1286     if (ret != HDF_SUCCESS) {
1287         ADM_LOG_ERR("CaptureClose MuteStream failed ret=%d", ret);
1288         return HDF_ERR_IO;
1289     }
1290 
1291     if (AudioDaiDeviceShutdown(audioCard) != HDF_SUCCESS) {
1292         ADM_LOG_ERR("Dai Device Shutdown failed.");
1293         return HDF_FAILURE;
1294     }
1295 
1296     ret = AudioCaptureClose(audioCard);
1297     if (ret != HDF_SUCCESS) {
1298         ADM_LOG_ERR("platform capture close failed ret=%d", ret);
1299         return HDF_ERR_IO;
1300     }
1301 
1302     ADM_LOG_DEBUG("success.");
1303     return HDF_SUCCESS;
1304 }
1305 
StreamHostRenderPause(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1306 static int32_t StreamHostRenderPause(const struct HdfDeviceIoClient *client,
1307     struct HdfSBuf *data, struct HdfSBuf *reply)
1308 {
1309     struct AudioRuntimeDeivces *rtd = NULL;
1310     struct AudioCard *audioCard = NULL;
1311     int32_t ret;
1312 
1313     if (data == NULL) {
1314         ADM_LOG_ERR("RenderPause input param is NULL.");
1315         return HDF_FAILURE;
1316     }
1317 
1318     (void)reply;
1319     (void)client;
1320     audioCard = StreamHostGetCardInstance(data);
1321     if (audioCard == NULL || audioCard->rtd == NULL) {
1322         ADM_LOG_ERR("RenderPause get card instance or rtd failed.");
1323         return HDF_FAILURE;
1324     }
1325     rtd = audioCard->rtd;
1326     ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE);
1327     if (ret != HDF_SUCCESS) {
1328         ADM_LOG_ERR("StreamTriggerRouteImpl failed");
1329         return HDF_FAILURE;
1330     }
1331     ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE);
1332     if (ret != HDF_SUCCESS) {
1333         ADM_LOG_ERR("platform render pause failed ret=%d", ret);
1334         return HDF_ERR_IO;
1335     }
1336 
1337     ADM_LOG_DEBUG("success.");
1338     return HDF_SUCCESS;
1339 }
1340 
StreamHostCapturePause(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1341 static int32_t StreamHostCapturePause(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
1342     struct HdfSBuf *reply)
1343 {
1344     struct AudioRuntimeDeivces *rtd = NULL;
1345     struct AudioCard *audioCard = NULL;
1346     int32_t ret;
1347 
1348     if (data == NULL) {
1349         ADM_LOG_ERR("CapturePause input param is NULL.");
1350         return HDF_FAILURE;
1351     }
1352 
1353     (void)reply;
1354     (void)client;
1355 
1356     audioCard = StreamHostGetCardInstance(data);
1357     if (audioCard == NULL || audioCard->rtd == NULL) {
1358         ADM_LOG_ERR("CapturePause get card instance or rtd failed.");
1359         return HDF_FAILURE;
1360     }
1361     rtd = audioCard->rtd;
1362     ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE);
1363     if (ret != HDF_SUCCESS) {
1364         ADM_LOG_ERR("StreamTriggerRouteImpl failed");
1365         return HDF_FAILURE;
1366     }
1367     ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE);
1368     if (ret != HDF_SUCCESS) {
1369         ADM_LOG_ERR("platform captur pause failed ret=%d", ret);
1370         return HDF_ERR_IO;
1371     }
1372 
1373     ADM_LOG_DEBUG("success.");
1374     return HDF_SUCCESS;
1375 }
1376 
StreamHostRenderResume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1377 static int32_t StreamHostRenderResume(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
1378     struct HdfSBuf *reply)
1379 {
1380     struct AudioRuntimeDeivces *rtd = NULL;
1381     struct AudioCard *audioCard = NULL;
1382     int32_t ret;
1383     ADM_LOG_DEBUG("entry.");
1384 
1385     if (data == NULL) {
1386         ADM_LOG_ERR("RenderResume input param is NULL.");
1387         return HDF_FAILURE;
1388     }
1389 
1390     (void)reply;
1391     (void)client;
1392     audioCard = StreamHostGetCardInstance(data);
1393     if (audioCard == NULL || audioCard->rtd == NULL) {
1394         ADM_LOG_ERR("RenderResume get card instance or rtd failed.");
1395         return HDF_FAILURE;
1396     }
1397     rtd = audioCard->rtd;
1398     ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_RENDER_RESUME);
1399     if (ret != HDF_SUCCESS) {
1400         ADM_LOG_ERR("StreamTriggerRouteImpl failed");
1401         return HDF_FAILURE;
1402     }
1403     ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_RENDER_RESUME);
1404     if (ret != HDF_SUCCESS) {
1405         ADM_LOG_ERR("platform RenderResume failed ret=%d", ret);
1406         return HDF_ERR_IO;
1407     }
1408 
1409     ADM_LOG_DEBUG("success.");
1410     return HDF_SUCCESS;
1411 }
1412 
StreamHostCaptureResume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1413 static int32_t StreamHostCaptureResume(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
1414     struct HdfSBuf *reply)
1415 {
1416     struct AudioRuntimeDeivces *rtd = NULL;
1417     struct AudioCard *audioCard = NULL;
1418     int32_t ret;
1419 
1420     ADM_LOG_DEBUG("entry.");
1421     if (data == NULL) {
1422         ADM_LOG_ERR("CaptureResume input param is NULL.");
1423         return HDF_FAILURE;
1424     }
1425 
1426     (void)reply;
1427     (void)client;
1428 
1429     audioCard = StreamHostGetCardInstance(data);
1430     if (audioCard == NULL || audioCard->rtd == NULL) {
1431         ADM_LOG_ERR("CaptureResume get card instance or rtd failed.");
1432         return HDF_FAILURE;
1433     }
1434     rtd = audioCard->rtd;
1435     ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME);
1436     if (ret != HDF_SUCCESS) {
1437         ADM_LOG_ERR("StreamTriggerRouteImpl failed");
1438         return HDF_FAILURE;
1439     }
1440     ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME);
1441     if (ret != HDF_SUCCESS) {
1442         ADM_LOG_ERR("platform CaptureResume failed ret=%d", ret);
1443         return HDF_ERR_IO;
1444     }
1445 
1446     ADM_LOG_DEBUG("success.");
1447     return HDF_SUCCESS;
1448 }
1449 
StreamHostDspDecode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1450 static int32_t StreamHostDspDecode(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
1451     struct HdfSBuf *reply)
1452 {
1453     struct AudioRuntimeDeivces *rtd = NULL;
1454     struct DspDevice *dspDev = NULL;
1455     struct AudioCard *audioCard = NULL;
1456     int32_t ret;
1457 
1458     ADM_LOG_DEBUG("Dsp Decode Entry.");
1459 
1460     if (data == NULL) {
1461         ADM_LOG_ERR("DspDecode input param is NULL.");
1462         return HDF_FAILURE;
1463     }
1464 
1465     (void)reply;
1466     (void)client;
1467     audioCard = StreamHostGetCardInstance(data);
1468     if (audioCard == NULL || audioCard->rtd == NULL) {
1469         ADM_LOG_ERR("DspDecode get card instance or rtd failed.");
1470         return HDF_FAILURE;
1471     }
1472     rtd = audioCard->rtd;
1473 
1474     dspDev = rtd->dsp;
1475     if (dspDev == NULL || dspDev->devData == NULL || dspDev->devData->Decode == NULL) {
1476         ADM_LOG_ERR("audioCard rtd dsp is NULL.");
1477         return HDF_FAILURE;
1478     }
1479 
1480     ret = dspDev->devData->Decode(audioCard, (void*)data, dspDev);
1481     if (ret != HDF_SUCCESS) {
1482         ADM_LOG_ERR("DeCode render pause failed ret=%d", ret);
1483         return HDF_ERR_IO;
1484     }
1485 
1486     ADM_LOG_DEBUG("Decode Success.");
1487     return HDF_SUCCESS;
1488 }
1489 
StreamHostDspEncode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1490 static int32_t StreamHostDspEncode(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
1491     struct HdfSBuf *reply)
1492 {
1493     struct AudioRuntimeDeivces *rtd = NULL;
1494     struct DspDevice *dspDev = NULL;
1495     struct AudioCard *audioCard = NULL;
1496     int32_t ret;
1497     ADM_LOG_DEBUG("Dsp Encode Entry.");
1498 
1499     if (data == NULL) {
1500         ADM_LOG_ERR("DspEncode input param is NULL.");
1501         return HDF_FAILURE;
1502     }
1503 
1504     (void)reply;
1505     (void)client;
1506     audioCard = StreamHostGetCardInstance(data);
1507     if (audioCard == NULL || audioCard->rtd == NULL) {
1508         ADM_LOG_ERR("DspEncode get card instance or rtd failed.");
1509         return HDF_FAILURE;
1510     }
1511     rtd = audioCard->rtd;
1512 
1513     dspDev = rtd->dsp;
1514     if (dspDev == NULL || dspDev->devData == NULL || dspDev->devData->Encode == NULL) {
1515         ADM_LOG_ERR("audioCard rtd dsp is NULL.");
1516         return HDF_FAILURE;
1517     }
1518 
1519     ret = dspDev->devData->Encode(audioCard, (void*)data, dspDev);
1520     if (ret != HDF_SUCCESS) {
1521         ADM_LOG_ERR("EnCode render pause failed ret=%d", ret);
1522         return HDF_ERR_IO;
1523     }
1524 
1525     ADM_LOG_DEBUG("Encode Success.");
1526     return HDF_SUCCESS;
1527 }
1528 
StreamHostDspEqualizer(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1529 static int32_t StreamHostDspEqualizer(const struct HdfDeviceIoClient *client, struct HdfSBuf *data,
1530     struct HdfSBuf *reply)
1531 {
1532     struct AudioRuntimeDeivces *rtd = NULL;
1533     struct DspDevice *dspDev = NULL;
1534     struct AudioCard *audioCard = NULL;
1535     int32_t ret ;
1536     ADM_LOG_DEBUG("Dsp Equalizer Entry.");
1537 
1538     if (data == NULL) {
1539         ADM_LOG_ERR("DspEqualizer input param is NULL.");
1540         return HDF_FAILURE;
1541     }
1542 
1543     (void)reply;
1544     (void)client;
1545 
1546     audioCard = StreamHostGetCardInstance(data);
1547     if (audioCard == NULL || audioCard->rtd == NULL) {
1548         ADM_LOG_ERR("DspEqualizer get card instance or rtd failed.");
1549         return HDF_FAILURE;
1550     }
1551     rtd = audioCard->rtd;
1552 
1553     dspDev = rtd->dsp;
1554     if (dspDev == NULL || dspDev->devData == NULL || dspDev->devData->Equalizer == NULL) {
1555         ADM_LOG_ERR("audioCard rtd dsp is NULL.");
1556         return HDF_FAILURE;
1557     }
1558 
1559     ret = dspDev->devData->Equalizer(audioCard, (void*)data, dspDev);
1560     if (ret != HDF_SUCCESS) {
1561         ADM_LOG_ERR("Equalizer render pause failed ret=%d", ret);
1562         return HDF_ERR_IO;
1563     }
1564 
1565     ADM_LOG_DEBUG("Equalizer Success.");
1566     return HDF_SUCCESS;
1567 }
1568 
1569 static struct StreamDispCmdHandleList g_streamDispCmdHandle[] = {
1570     {AUDIO_DRV_PCM_IOCTL_WRITE, StreamHostWrite},
1571     {AUDIO_DRV_PCM_IOCTL_READ, StreamHostRead},
1572     {AUDIO_DRV_PCM_IOCTL_HW_PARAMS, StreamHostHwParams},
1573     {AUDIO_DRV_PCM_IOCTL_RENDER_PREPARE, StreamHostRenderPrepare},
1574     {AUDIO_DRV_PCM_IOCTL_CAPTURE_PREPARE, StreamHostCapturePrepare},
1575     {AUDIO_DRV_PCM_IOCTL_RENDER_OPEN, StreamHostRenderOpen},
1576     {AUDIO_DRV_PCM_IOCTL_RENDER_CLOSE, StreamHostRenderClose},
1577     {AUDIO_DRV_PCM_IOCTL_RENDER_START, StreamHostRenderStart},
1578     {AUDIO_DRV_PCM_IOCTL_RENDER_STOP, StreamHostRenderStop},
1579     {AUDIO_DRV_PCM_IOCTL_CAPTURE_OPEN, StreamHostCaptureOpen},
1580     {AUDIO_DRV_PCM_IOCTL_CAPTURE_CLOSE, StreamHostCaptureClose},
1581     {AUDIO_DRV_PCM_IOCTL_CAPTURE_START, StreamHostCaptureStart},
1582     {AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP, StreamHostCaptureStop},
1583     {AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE, StreamHostRenderPause},
1584     {AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE, StreamHostCapturePause},
1585     {AUDIO_DRV_PCM_IOCTL_RENDER_RESUME, StreamHostRenderResume},
1586     {AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME, StreamHostCaptureResume},
1587     {AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER, StreamHostMmapWrite},
1588     {AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE, StreamHostMmapRead},
1589     {AUDIO_DRV_PCM_IOCTL_MMAP_POSITION, StreamHostMmapPositionWrite},
1590     {AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE, StreamHostMmapPositionRead},
1591     {AUDIO_DRV_PCM_IOCTL_DSPDECODE, StreamHostDspDecode},
1592     {AUDIO_DRV_PCM_IOCTL_DSPENCODE, StreamHostDspEncode},
1593     {AUDIO_DRV_PCM_IOCTL_DSPEQUALIZER, StreamHostDspEqualizer},
1594 };
1595 
StreamDispatch(struct HdfDeviceIoClient * client,int32_t cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)1596 static int32_t StreamDispatch(struct HdfDeviceIoClient *client, int32_t cmdId,
1597     struct HdfSBuf *data, struct HdfSBuf *reply)
1598 {
1599     uint32_t count = sizeof(g_streamDispCmdHandle) / sizeof(g_streamDispCmdHandle[0]);
1600     uint32_t i = 0;
1601     for (i = 0; i < count; ++i) {
1602         if ((cmdId == (int32_t)(g_streamDispCmdHandle[i].cmd)) && (g_streamDispCmdHandle[i].func != NULL)) {
1603             return g_streamDispCmdHandle[i].func(client, data, reply);
1604         }
1605     }
1606     ADM_LOG_ERR("invalid [cmdId=%d]", cmdId);
1607     return HDF_FAILURE;
1608 }
1609 
StreamHostCreateAndBind(struct HdfDeviceObject * device)1610 static struct StreamHost *StreamHostCreateAndBind(struct HdfDeviceObject *device)
1611 {
1612     struct StreamHost *streamHost = NULL;
1613     if (device == NULL) {
1614         ADM_LOG_ERR("device is null!");
1615         return NULL;
1616     }
1617 
1618     streamHost = (struct StreamHost *)OsalMemCalloc(sizeof(*streamHost));
1619     if (streamHost == NULL) {
1620         ADM_LOG_ERR("malloc host failed!");
1621         return NULL;
1622     }
1623     streamHost->device = device;
1624     device->service = &streamHost->service;
1625     return streamHost;
1626 }
1627 
AudioStreamBind(struct HdfDeviceObject * device)1628 static int32_t AudioStreamBind(struct HdfDeviceObject *device)
1629 {
1630     struct StreamHost *streamHost = NULL;
1631     ADM_LOG_DEBUG("entry!");
1632     if (device == NULL) {
1633         ADM_LOG_ERR("device is null!");
1634         return HDF_ERR_INVALID_PARAM;
1635     }
1636 
1637     streamHost = StreamHostCreateAndBind(device);
1638     if (streamHost == NULL || streamHost->device == NULL) {
1639         ADM_LOG_ERR("StreamHostCreateAndBind failed");
1640         return HDF_FAILURE;
1641     }
1642 
1643     streamHost->service.Dispatch = StreamDispatch;
1644 
1645     ADM_LOG_INFO("success!");
1646     return HDF_SUCCESS;
1647 }
1648 
AudioStreamInit(struct HdfDeviceObject * device)1649 static int32_t AudioStreamInit(struct HdfDeviceObject *device)
1650 {
1651     struct StreamHost *streamHost = NULL;
1652 
1653     if (device == NULL) {
1654         ADM_LOG_ERR("device is NULL");
1655         return HDF_FAILURE;
1656     }
1657     ADM_LOG_DEBUG("entry.");
1658 
1659     streamHost = StreamHostFromDevice(device);
1660     if (streamHost == NULL) {
1661         ADM_LOG_ERR("renderHost is NULL");
1662         return HDF_FAILURE;
1663     }
1664 
1665     ADM_LOG_INFO("Success!");
1666     return HDF_SUCCESS;
1667 }
1668 
AudioStreamRelease(struct HdfDeviceObject * device)1669 static void AudioStreamRelease(struct HdfDeviceObject *device)
1670 {
1671     struct StreamHost *streamHost = NULL;
1672     if (device == NULL) {
1673         ADM_LOG_ERR("device is NULL");
1674         return;
1675     }
1676 
1677     streamHost = StreamHostFromDevice(device);
1678     if (streamHost == NULL) {
1679         ADM_LOG_ERR("renderHost is NULL");
1680         return;
1681     }
1682 
1683     if (streamHost->priv != NULL) {
1684         OsalMemFree(streamHost->priv);
1685     }
1686     OsalMemFree(streamHost);
1687 }
1688 
1689 /* HdfDriverEntry definitions */
1690 struct HdfDriverEntry g_audioStreamEntry = {
1691     .moduleVersion = 1,
1692     .moduleName = "HDF_AUDIO_STREAM",
1693     .Bind = AudioStreamBind,
1694     .Init = AudioStreamInit,
1695     .Release = AudioStreamRelease,
1696 };
1697 HDF_INIT(g_audioStreamEntry);
1698