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