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_platform_base.h"
10 #include "audio_driver_log.h"
11 #include "audio_dma_base.h"
12 #include "audio_sapm.h"
13 #include "audio_stream_dispatch.h"
14 #include "osal_time.h"
15 #include "osal_uaccess.h"
16 #include "hdf_device_object.h"
17 
18 #define HDF_LOG_TAG HDF_AUDIO_KADM
19 #define MAX_PERIOD_SIZE (8 * 1024)
20 #define MIN_PERIOD_SIZE (2 * 1024)
21 #define SECOND_TO_MILLISECOND  1000
22 
23 const int32_t PERIOD_COUNT = 4;
24 const int32_t RENDER_TRAF_BUF_SIZE = 1024;
25 const int32_t TIME_OUT_CONST = 50;
26 const int32_t SLEEP_TIME = 5;
27 #define AUDIO_PNP_MSG_LEN 256
28 #define INTERLEAVED 1
29 const int32_t MIN_PERIOD_SILENCE_THRESHOLD = (4 * 1024);
30 const int32_t MAX_PERIOD_SILENCE_THRESHOLD = (16 * 1024);
31 
SysReadl(unsigned long addr)32 uint32_t SysReadl(unsigned long addr)
33 {
34     return *(volatile uint32_t *)(uintptr_t)(addr);
35 }
36 
SysWritel(unsigned long addr,uint32_t value)37 void SysWritel(unsigned long addr, uint32_t value)
38 {
39     *(volatile uint32_t *)(uintptr_t)(addr) = value;
40 }
41 
PlatformDataFromCard(const struct AudioCard * card)42 struct PlatformData *PlatformDataFromCard(const struct AudioCard *card)
43 {
44     if (card == NULL || card->rtd == NULL || card->rtd->platform == NULL) {
45         AUDIO_DRIVER_LOG_ERR("param is null.");
46         return NULL;
47     }
48     return card->rtd->platform->devData;
49 }
50 
AudioBytesToFrames(uint32_t frameBits,uint32_t size)51 uint32_t AudioBytesToFrames(uint32_t frameBits, uint32_t size)
52 {
53     if (size == 0) {
54         AUDIO_DRIVER_LOG_ERR("size is null.");
55         return 0;
56     } else {
57         return (frameBits / size);
58     }
59 }
60 
61 
AudioDataBigEndianChange(char * srcData,uint32_t audioLen,enum DataBitWidth bitWidth)62 int32_t AudioDataBigEndianChange(char *srcData, uint32_t audioLen, enum DataBitWidth bitWidth)
63 {
64     uint64_t i;
65     uint16_t framesize;
66     char *changeData = NULL;
67     uint32_t *pData = NULL;
68     if (srcData == NULL) {
69         AUDIO_DRIVER_LOG_ERR("srcData is NULL.");
70         return HDF_ERR_INVALID_PARAM;
71     }
72     changeData = srcData;
73     pData = (uint32_t *)changeData;
74 
75     switch (bitWidth) {
76         case DATA_BIT_WIDTH8:
77             return HDF_SUCCESS;
78         case DATA_BIT_WIDTH24:
79             framesize = 3; /* 3 byte , convert step is 3 byte */
80             for (i = 0; i < audioLen; i += framesize) {
81                 // swap the first and the third byte, second and fourth unchanged
82                 *pData = ((((*pData) >> 0x10) & 0x000000FF) |
83                           ((*pData) & 0xFF00FF00) |
84                           (((*pData) << 0x10) & 0x00FF0000));
85                 changeData += framesize;
86                 pData = (uint32_t *)changeData;
87             }
88             break;
89         case DATA_BIT_WIDTH16:
90         default:
91             framesize = 4; /* 2 byte, convert step is 4 byte */
92             for (i = 0; i < audioLen; i += framesize) {
93                 // swap the first and second byte, swap the third and fourth byte
94                 *pData = ((((*pData) << 0x08) & 0xFF00FF00) |
95                           (((*pData) >> 0x08) & 0x00FF00FF));
96                 pData++;
97             }
98             break;
99     }
100     return HDF_SUCCESS;
101 }
102 
AudioFormatToBitWidth(enum AudioFormat format,uint32_t * bitWidth)103 int32_t AudioFormatToBitWidth(enum AudioFormat format, uint32_t *bitWidth)
104 {
105     if (bitWidth == NULL) {
106         AUDIO_DRIVER_LOG_ERR("bitWidth is null.");
107         return HDF_ERR_INVALID_PARAM;
108     }
109     switch (format) {
110         case AUDIO_FORMAT_TYPE_PCM_8_BIT:
111             *bitWidth = DATA_BIT_WIDTH8;
112             break;
113 
114         case AUDIO_FORMAT_TYPE_PCM_16_BIT:
115             *bitWidth = DATA_BIT_WIDTH16;
116             break;
117 
118         case AUDIO_FORMAT_TYPE_PCM_24_BIT:
119             *bitWidth = DATA_BIT_WIDTH24;
120             break;
121 
122         case AUDIO_FORMAT_TYPE_PCM_32_BIT:
123             *bitWidth = DATA_BIT_WIDTH32;
124             break;
125 
126         default:
127             AUDIO_DRIVER_LOG_ERR("format: %d is not define.", format);
128             return HDF_FAILURE;
129     }
130     return HDF_SUCCESS;
131 }
132 
AudioSetPcmInfo(struct PlatformData * platformData,const struct AudioPcmHwParams * param)133 int32_t AudioSetPcmInfo(struct PlatformData *platformData, const struct AudioPcmHwParams *param)
134 {
135     if (platformData == NULL || param == NULL) {
136         AUDIO_DRIVER_LOG_ERR("platform is NULL.");
137         return HDF_ERR_INVALID_PARAM;
138     }
139     platformData->renderBufInfo.chnId = 0;
140     platformData->captureBufInfo.chnId = 0;
141 
142     if (param->streamType == AUDIO_RENDER_STREAM) {
143         if (AudioFormatToBitWidth(param->format, &platformData->renderPcmInfo.bitWidth) != HDF_SUCCESS) {
144             AUDIO_DRIVER_LOG_ERR("renderPcmInfo is failure");
145             return HDF_FAILURE;
146         }
147         platformData->renderPcmInfo.rate = param->rate;
148         platformData->renderPcmInfo.frameSize = param->channels * platformData->renderPcmInfo.bitWidth / BITSTOBYTE;
149         platformData->renderPcmInfo.channels = param->channels;
150 
151         platformData->renderPcmInfo.isBigEndian = param->isBigEndian;
152         platformData->renderPcmInfo.isSignedData = param->isSignedData;
153 
154         platformData->renderPcmInfo.startThreshold = param->startThreshold;
155         platformData->renderPcmInfo.stopThreshold = param->stopThreshold;
156         platformData->renderPcmInfo.silenceThreshold = param->silenceThreshold;
157 
158         platformData->renderPcmInfo.interleaved = INTERLEAVED;
159         platformData->renderPcmInfo.streamType = param->streamType;
160     } else if (param->streamType == AUDIO_CAPTURE_STREAM) {
161         if (AudioFormatToBitWidth(param->format, &platformData->capturePcmInfo.bitWidth) != HDF_SUCCESS) {
162             AUDIO_DRIVER_LOG_ERR("capturePcmInfo is failure");
163             return HDF_FAILURE;
164         }
165         platformData->capturePcmInfo.rate = param->rate;
166         platformData->capturePcmInfo.frameSize = param->channels * platformData->capturePcmInfo.bitWidth / BITSTOBYTE;
167         platformData->capturePcmInfo.channels = param->channels;
168 
169         platformData->capturePcmInfo.isBigEndian = param->isBigEndian;
170         platformData->capturePcmInfo.isSignedData = param->isSignedData;
171 
172         platformData->capturePcmInfo.startThreshold = param->startThreshold;
173         platformData->capturePcmInfo.stopThreshold = param->stopThreshold;
174         platformData->capturePcmInfo.silenceThreshold = param->silenceThreshold;
175 
176         platformData->capturePcmInfo.interleaved = INTERLEAVED;
177         platformData->capturePcmInfo.streamType = param->streamType;
178     } else {
179         AUDIO_DRIVER_LOG_ERR("streamType is invalid.");
180         return HDF_FAILURE;
181     }
182 
183     return HDF_SUCCESS;
184 }
185 
AudioSetRenderBufInfo(struct PlatformData * data,const struct AudioPcmHwParams * param)186 int32_t AudioSetRenderBufInfo(struct PlatformData *data, const struct AudioPcmHwParams *param)
187 {
188     uint32_t size;
189 
190     if (data == NULL || param == NULL) {
191         AUDIO_DRIVER_LOG_ERR("platform is NULL.");
192         return HDF_ERR_INVALID_PARAM;
193     }
194 
195     if (param->period < MIN_PERIOD_SIZE || param->period > MAX_PERIOD_SIZE) {
196         AUDIO_DRIVER_LOG_ERR("periodSize is invalid %d.", param->period);
197         return HDF_FAILURE;
198     }
199     data->renderBufInfo.periodSize = param->period * data->renderPcmInfo.bitWidth *
200         data->renderPcmInfo.channels / BITSTOBYTE;
201     data->renderBufInfo.periodCount = PERIOD_COUNT;
202     data->renderBufInfo.trafBufSize = RENDER_TRAF_BUF_SIZE;
203 
204     size = data->renderBufInfo.periodCount * data->renderBufInfo.periodSize;
205     if (size < MIN_BUFF_SIZE || size > MAX_BUFF_SIZE) {
206         AUDIO_DRIVER_LOG_ERR("buffSize is invalid.");
207         return HDF_FAILURE;
208     }
209 
210     data->renderBufInfo.cirBufSize = size;
211     return HDF_SUCCESS;
212 }
213 
AudioSetCaptureBufInfo(struct PlatformData * data,const struct AudioPcmHwParams * param)214 int32_t AudioSetCaptureBufInfo(struct PlatformData *data, const struct AudioPcmHwParams *param)
215 {
216     if (data == NULL || param == NULL) {
217         AUDIO_DRIVER_LOG_ERR("platform is NULL.");
218         return HDF_ERR_INVALID_PARAM;
219     }
220 
221     if (param->period < MIN_PERIOD_SIZE || param->period > MAX_PERIOD_SIZE) {
222         AUDIO_DRIVER_LOG_ERR("periodSize is invalid %d.", param->period);
223         return HDF_FAILURE;
224     }
225     data->captureBufInfo.periodSize = param->period * data->capturePcmInfo.bitWidth *
226         data->capturePcmInfo.channels / BITSTOBYTE;
227     data->captureBufInfo.periodCount = PERIOD_COUNT;
228 
229     if (param->silenceThreshold < MIN_PERIOD_SILENCE_THRESHOLD ||
230         param->silenceThreshold > MAX_PERIOD_SILENCE_THRESHOLD) {
231         AUDIO_DRIVER_LOG_ERR("silenceThreshold is invalid %d.", param->silenceThreshold);
232         return HDF_FAILURE;
233     }
234     data->captureBufInfo.trafBufSize = param->silenceThreshold;
235     data->captureBufInfo.cirBufSize = data->captureBufInfo.periodSize * data->captureBufInfo.periodCount;
236     if (data->captureBufInfo.cirBufSize > data->captureBufInfo.cirBufMax) {
237         AUDIO_DRIVER_LOG_ERR("cirBufSize is invalid %d.", data->captureBufInfo.cirBufSize);
238         return HDF_FAILURE;
239     }
240     return HDF_SUCCESS;
241 }
242 
AudioDmaBuffStatus(const struct AudioCard * card,enum AudioStreamType streamType)243 static int32_t AudioDmaBuffStatus(const struct AudioCard *card, enum AudioStreamType streamType)
244 {
245     uint32_t dataAvailable;
246     uint32_t residual;
247     uint32_t pointer = 0;
248     uint32_t wptr;
249     uint32_t rptr;
250 
251     struct PlatformData *data = PlatformDataFromCard(card);
252     if (data == NULL || data->ops == NULL) {
253         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
254         return HDF_FAILURE;
255     }
256 
257     if (AudioPcmPointer(card, &pointer, streamType) != HDF_SUCCESS) {
258         AUDIO_DRIVER_LOG_ERR("get Pointer failed.");
259         return ENUM_CIR_BUFF_FULL;
260     }
261     if (streamType == AUDIO_RENDER_STREAM) {
262         data->renderBufInfo.pointer = pointer;
263         rptr = data->renderBufInfo.pointer * data->renderPcmInfo.frameSize;
264         dataAvailable = (data->renderBufInfo.wbufOffSet - rptr) % data->renderBufInfo.cirBufSize;
265         residual = data->renderBufInfo.cirBufSize - dataAvailable;
266         if ((residual > data->renderBufInfo.trafBufSize)) {
267             AUDIO_DRIVER_LOG_DEBUG("card name: %s rptr: %d wptr: %d trafBufSize: %d ",
268                 card->configData.cardServiceName, rptr, dataAvailable, data->renderBufInfo.trafBufSize);
269             return ENUM_CIR_BUFF_NORMAL;
270         } else {
271             AUDIO_DRIVER_LOG_DEBUG("card name: %s full rptr: %d wptr: %d trafBufSize: %d ",
272                 card->configData.cardServiceName, rptr, dataAvailable, data->renderBufInfo.trafBufSize);
273             return ((data->renderBufInfo.trafBufSize - residual) / data->renderBufInfo.oneMsBytes);
274         }
275     } else if (streamType == AUDIO_CAPTURE_STREAM) {
276         rptr = data->captureBufInfo.rptrOffSet;
277         wptr = pointer * data->capturePcmInfo.frameSize;
278         data->captureBufInfo.pointer = pointer;
279         if (wptr >= rptr) {
280             // [S ... R ... W ... E]
281             dataAvailable = wptr - rptr;
282             if (dataAvailable < data->captureBufInfo.trafBufSize) {
283                 AUDIO_DRIVER_LOG_DEBUG("card name: %s empty rptr: %d wptr: %d trafBufSize: %d ",
284                     card->configData.cardServiceName, rptr, wptr, data->captureBufInfo.trafBufSize);
285                 return ((data->captureBufInfo.trafBufSize - dataAvailable) / data->captureBufInfo.oneMsBytes);
286             }
287         }
288         AUDIO_DRIVER_LOG_DEBUG("card name: %s rptr: %d wptr: %d trafBufSize: %d ", card->configData.cardServiceName,
289             rptr, wptr, data->captureBufInfo.trafBufSize);
290         return ENUM_CIR_BUFF_NORMAL;
291     } else {
292         AUDIO_DRIVER_LOG_ERR("streamType is invalid.");
293         return HDF_FAILURE;
294     }
295 }
296 
AudioPcmWrite(const struct AudioCard * card,struct AudioTxData * txData)297 int32_t AudioPcmWrite(const struct AudioCard *card, struct AudioTxData *txData)
298 {
299     struct PlatformData *data = NULL;
300     int32_t status;
301     uint32_t wPtr;
302     int32_t ret;
303 
304     if (card == NULL || txData == NULL || txData->buf == NULL) {
305         AUDIO_DRIVER_LOG_ERR("input param is null.");
306         return HDF_FAILURE;
307     }
308 
309     data = PlatformDataFromCard(card);
310     if (data == NULL) {
311         AUDIO_DRIVER_LOG_ERR("from PlatformDataFromCard get platformData is NULL.");
312         return HDF_FAILURE;
313     }
314 
315     // 1. Computed buffer size
316     data->renderBufInfo.trafBufSize = txData->frames * data->renderPcmInfo.frameSize;
317 
318     // 2. Big Small Exchange
319     if (data->renderPcmInfo.isBigEndian) {
320         if (AudioDataBigEndianChange(txData->buf, data->renderBufInfo.trafBufSize,
321             data->renderPcmInfo.bitWidth) != HDF_SUCCESS) {
322             AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed.");
323             return HDF_FAILURE;
324         }
325     }
326     // 3. Buffer state checking
327     status = AudioDmaBuffStatus(card, AUDIO_RENDER_STREAM);
328     if (status != ENUM_CIR_BUFF_NORMAL) {
329         txData->status = status;
330         return HDF_SUCCESS;
331     }
332 
333     // 4. write buffer
334     if (data->renderBufInfo.trafBufSize > data->renderBufInfo.cirBufSize) {
335         AUDIO_DRIVER_LOG_ERR("transferFrameSize is tool big.");
336         return HDF_FAILURE;
337     }
338     wPtr = data->renderBufInfo.wbufOffSet % data->renderBufInfo.cirBufSize;
339 
340     if (data->renderBufInfo.virtAddr == NULL) {
341         AUDIO_DRIVER_LOG_ERR("render buffer is null.");
342         return HDF_FAILURE;
343     }
344     ret = memcpy_s((char *)(data->renderBufInfo.virtAddr) + wPtr,
345         data->renderBufInfo.trafBufSize, txData->buf, data->renderBufInfo.trafBufSize);
346     if (ret != 0) {
347         AUDIO_DRIVER_LOG_ERR("memcpy_s failed.");
348         return HDF_FAILURE;
349     }
350     txData->status = ENUM_CIR_BUFF_NORMAL;
351     data->renderBufInfo.wptrOffSet = wPtr + data->renderBufInfo.trafBufSize;
352     data->renderBufInfo.wbufOffSet += data->renderBufInfo.trafBufSize;
353 
354     return HDF_SUCCESS;
355 }
356 
PcmReadData(struct PlatformData * data,struct AudioRxData * rxData)357 static int32_t PcmReadData(struct PlatformData *data, struct AudioRxData *rxData)
358 {
359     uint32_t wptr;
360     uint32_t rptr;
361     uint32_t validDataSize;
362 
363     if (data == NULL || rxData == NULL) {
364         AUDIO_DRIVER_LOG_ERR("input param is null.");
365         return HDF_FAILURE;
366     }
367 
368     rxData->buf = (char *)(data->captureBufInfo.virtAddr) + data->captureBufInfo.rptrOffSet;
369     wptr = data->captureBufInfo.pointer * data->capturePcmInfo.frameSize;
370     rptr = data->captureBufInfo.rptrOffSet;
371     data->captureBufInfo.curTrafSize = data->captureBufInfo.trafBufSize;
372     if (rptr > wptr) {
373         validDataSize = data->captureBufInfo.cirBufSize - rptr;
374         if (validDataSize < data->captureBufInfo.trafBufSize) {
375             data->captureBufInfo.curTrafSize = validDataSize;
376         }
377     }
378 
379     // 3. Big Small Exchange
380     if (data->capturePcmInfo.isBigEndian) {
381         if (rxData->buf == NULL || AudioDataBigEndianChange(rxData->buf,
382             data->captureBufInfo.curTrafSize, data->capturePcmInfo.bitWidth) != HDF_SUCCESS) {
383             AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed.");
384             return HDF_FAILURE;
385         }
386     }
387 
388     rxData->frames = data->captureBufInfo.curTrafSize / data->capturePcmInfo.frameSize;
389     rxData->bufSize = data->captureBufInfo.curTrafSize;
390     rxData->status = ENUM_CIR_BUFF_NORMAL;
391 
392     return HDF_SUCCESS;
393 }
394 
AudioPcmRead(const struct AudioCard * card,struct AudioRxData * rxData)395 int32_t AudioPcmRead(const struct AudioCard *card, struct AudioRxData *rxData)
396 {
397     struct PlatformData *data = NULL;
398     int32_t status;
399 
400     if (card == NULL || rxData == NULL) {
401         AUDIO_DRIVER_LOG_ERR("input param is null.");
402         return HDF_FAILURE;
403     }
404 
405     data = PlatformDataFromCard(card);
406     if (data == NULL) {
407         AUDIO_DRIVER_LOG_ERR("from PlatformDataFromCard get platformData is NULL.");
408         return HDF_FAILURE;
409     }
410     if (data->captureBufInfo.virtAddr == NULL) {
411         AUDIO_DRIVER_LOG_ERR("capture buffer is null.");
412         return HDF_FAILURE;
413     }
414 
415     // 1. Buffer state checking
416     status = AudioDmaBuffStatus(card, AUDIO_CAPTURE_STREAM);
417     if (status != ENUM_CIR_BUFF_NORMAL) {
418         rxData->status = status;
419         rxData->buf = (char *)(data->captureBufInfo.virtAddr) + data->captureBufInfo.rptrOffSet;
420         rxData->frames = 0;
421         rxData->bufSize = 0;
422         AUDIO_DRIVER_LOG_DEBUG("buff is empty.");
423         return HDF_SUCCESS;
424     }
425 
426     // 2. read buffer
427     if (PcmReadData(data, rxData) != HDF_SUCCESS) {
428         AUDIO_DRIVER_LOG_ERR("Pcm Read Data fail.");
429         return HDF_FAILURE;
430     }
431 
432     // 4. update rptr
433     data->captureBufInfo.rptrOffSet += data->captureBufInfo.curTrafSize;
434     if (data->captureBufInfo.rptrOffSet >= data->captureBufInfo.cirBufSize) {
435         data->captureBufInfo.rptrOffSet = 0;
436     }
437     data->captureBufInfo.rbufOffSet += data->captureBufInfo.curTrafSize;
438     return HDF_SUCCESS;
439 }
440 
MmapWriteData(struct PlatformData * data,char * tmpBuf)441 static int32_t MmapWriteData(struct PlatformData *data, char *tmpBuf)
442 {
443     uint32_t wPtr;
444     int32_t ret;
445 
446     if (data->renderBufInfo.trafBufSize > data->renderBufInfo.cirBufSize) {
447         AUDIO_DRIVER_LOG_ERR("transferFrameSize is tool big.");
448         return HDF_FAILURE;
449     }
450 
451     wPtr = data->renderBufInfo.wbufOffSet % data->renderBufInfo.cirBufSize;
452     ret = CopyFromUser(tmpBuf, (char *)data->mmapData.memoryAddress + data->mmapData.offset,
453         data->renderBufInfo.trafBufSize);
454     if (ret != EOK) {
455         AUDIO_DRIVER_LOG_ERR("CopyFromUser failed.");
456         return HDF_FAILURE;
457     }
458 
459     ret = memcpy_s((char *)(data->renderBufInfo.virtAddr) + wPtr, data->renderBufInfo.trafBufSize,
460         tmpBuf, data->renderBufInfo.trafBufSize);
461     if (ret != 0) {
462         AUDIO_DRIVER_LOG_ERR("memcpy_s failed.");
463         return HDF_FAILURE;
464     }
465 
466     data->renderBufInfo.wptrOffSet = wPtr + data->renderBufInfo.trafBufSize;
467     data->renderBufInfo.wbufOffSet += data->renderBufInfo.trafBufSize;
468     data->renderBufInfo.framesPosition += data->renderBufInfo.trafBufSize / data->renderPcmInfo.frameSize;
469     data->mmapData.offset += data->renderBufInfo.trafBufSize;
470     data->mmapLoopCount++;
471     return HDF_SUCCESS;
472 }
473 
AudioRenderPlatformDataInit(struct PlatformData * data,uint32_t * totalSize,uint32_t * lastBuffSize,uint32_t * loopTimes)474 static int32_t AudioRenderPlatformDataInit(struct PlatformData *data, uint32_t *totalSize, uint32_t *lastBuffSize,
475     uint32_t *loopTimes)
476 {
477     if (data == NULL) {
478         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
479         return HDF_FAILURE;
480     }
481     if (data->renderBufInfo.virtAddr == NULL) {
482         AUDIO_DRIVER_LOG_ERR("render buffer is null.");
483         return HDF_FAILURE;
484     }
485     if (data->renderBufInfo.runStatus != PCM_START) {
486         AUDIO_DRIVER_LOG_INFO("render did not start.");
487         return HDF_FAILURE;
488     }
489 
490     *totalSize = (uint32_t)data->mmapData.totalBufferFrames * data->renderPcmInfo.frameSize;
491     *lastBuffSize = ((*totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (*totalSize % MIN_PERIOD_SIZE);
492     *loopTimes = (*lastBuffSize == MIN_PERIOD_SIZE) ?
493         (*totalSize / MIN_PERIOD_SIZE) : (*totalSize / MIN_PERIOD_SIZE + 1);
494     data->mmapLoopCount = 0;
495     return HDF_SUCCESS;
496 }
497 
AudioMmapWriteTransfer(const struct AudioCard * card)498 static int32_t AudioMmapWriteTransfer(const struct AudioCard *card)
499 {
500     uint32_t timeout = 0;
501     uint32_t totalSize;
502     uint32_t lastBuffSize;
503     uint32_t loopTimes;
504     char *tmpBuf = NULL;
505 
506     struct PlatformData *data = PlatformDataFromCard(card);
507     if (AudioRenderPlatformDataInit(data, &totalSize, &lastBuffSize, &loopTimes) == HDF_FAILURE) {
508         return HDF_FAILURE;
509     }
510     tmpBuf = OsalMemCalloc(MIN_PERIOD_SIZE);
511     if (tmpBuf == NULL) {
512         AUDIO_DRIVER_LOG_ERR("tmpBuf is null.");
513         return HDF_FAILURE;
514     }
515     while (data->mmapLoopCount < loopTimes && data->renderBufInfo.runStatus != PCM_STOP) {
516         if (data->renderBufInfo.runStatus == PCM_PAUSE) {
517             OsalMSleep(SLEEP_TIME);
518             continue;
519         }
520 
521         if (AudioDmaBuffStatus(card, AUDIO_RENDER_STREAM) != ENUM_CIR_BUFF_NORMAL) {
522             OsalMSleep(SLEEP_TIME);
523             AUDIO_DRIVER_LOG_DEBUG("dma buff status ENUM_CIR_BUFF_FULL.");
524             timeout++;
525             if (timeout >= TIME_OUT_CONST) {
526                 OsalMemFree(tmpBuf);
527                 AUDIO_DRIVER_LOG_ERR("timeout failed.");
528                 return HDF_FAILURE;
529             }
530             continue;
531         }
532         timeout = 0;
533         data->renderBufInfo.trafBufSize = (data->mmapLoopCount < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize;
534 
535         if (MmapWriteData(data, tmpBuf) != HDF_SUCCESS) {
536             OsalMemFree(tmpBuf);
537             return HDF_FAILURE;
538         }
539     }
540 
541     if (data->mmapLoopCount > loopTimes) {
542         data->renderBufInfo.runStatus = PCM_STOP;
543     }
544 
545     OsalMemFree(tmpBuf);
546     return HDF_SUCCESS;
547 }
548 
AudioPcmMmapWrite(const struct AudioCard * card,const struct AudioMmapData * txMmapData)549 int32_t AudioPcmMmapWrite(const struct AudioCard *card, const struct AudioMmapData *txMmapData)
550 {
551     int32_t ret;
552     struct PlatformData *data = NULL;
553     AUDIO_DRIVER_LOG_DEBUG("entry.");
554 
555     data = PlatformDataFromCard(card);
556     if (data == NULL) {
557         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
558         return HDF_FAILURE;
559     }
560 
561     if (txMmapData == NULL || txMmapData->memoryAddress == NULL || txMmapData->transferFrameSize <= 0 ||
562         txMmapData->totalBufferFrames <= 0) {
563         AUDIO_DRIVER_LOG_ERR("param is invalid.");
564         return HDF_ERR_INVALID_PARAM;
565     }
566 
567     data->mmapData.offset = txMmapData->offset;
568     data->mmapData.memoryAddress = txMmapData->memoryAddress;
569     data->mmapData.totalBufferFrames = txMmapData->totalBufferFrames;
570     data->mmapData.transferFrameSize = txMmapData->transferFrameSize;
571     data->mmapLoopCount = 0;
572 
573     AUDIO_DRIVER_LOG_DEBUG("*******offset=0x%x memoryAddress=0x%x totalBufferFrames=0x%x transferFrameSize=0x%x ",
574         data->mmapData.offset, data->mmapData.memoryAddress, data->mmapData.totalBufferFrames,
575         data->mmapData.transferFrameSize);
576 
577     ret = AudioMmapWriteTransfer(card);
578     if (ret != HDF_SUCCESS) {
579         AUDIO_DRIVER_LOG_ERR("AudioMmapTransfer fail.");
580         return HDF_FAILURE;
581     }
582 
583     AUDIO_DRIVER_LOG_DEBUG("render mmap write success.");
584     return HDF_SUCCESS;
585 }
586 
MmapReadData(struct PlatformData * data,const struct AudioMmapData * rxMmapData,uint32_t offset)587 static int32_t MmapReadData(struct PlatformData *data, const struct AudioMmapData *rxMmapData, uint32_t offset)
588 {
589     uint32_t wPtr;
590     uint32_t rPtr;
591     uint32_t validDataSize;
592 
593     if (data == NULL || rxMmapData == NULL) {
594         AUDIO_DRIVER_LOG_ERR("data is null.");
595         return HDF_FAILURE;
596     }
597 
598     rPtr = data->captureBufInfo.rptrOffSet;
599     wPtr = data->captureBufInfo.pointer * data->capturePcmInfo.frameSize;
600     if (rPtr > wPtr) {
601         validDataSize = data->captureBufInfo.cirBufSize - rPtr;
602         if (validDataSize < data->captureBufInfo.trafBufSize) {
603             data->captureBufInfo.curTrafSize = validDataSize;
604         }
605     }
606     if (data->capturePcmInfo.isBigEndian) {
607         if (AudioDataBigEndianChange((char *)(data->captureBufInfo.virtAddr) + rPtr,
608             data->captureBufInfo.curTrafSize, data->capturePcmInfo.bitWidth) != HDF_SUCCESS) {
609                 AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed.");
610                 return HDF_FAILURE;
611         }
612     }
613 
614     if (CopyToUser((char *)rxMmapData->memoryAddress + offset,
615         (char *)(data->captureBufInfo.virtAddr) + rPtr, data->captureBufInfo.curTrafSize) != 0) {
616         AUDIO_DRIVER_LOG_ERR("CopyToUser failed.");
617         return HDF_FAILURE;
618     }
619 
620     // 4. update rptr
621     data->captureBufInfo.rptrOffSet += data->captureBufInfo.curTrafSize;
622     if (data->captureBufInfo.rptrOffSet >= data->captureBufInfo.cirBufSize) {
623         data->captureBufInfo.rptrOffSet = 0;
624     }
625     data->captureBufInfo.framesPosition += data->captureBufInfo.curTrafSize / data->capturePcmInfo.frameSize;
626     data->captureBufInfo.rbufOffSet += data->captureBufInfo.curTrafSize;
627     return HDF_SUCCESS;
628 }
629 
AudioCapturePlatformDataInit(struct PlatformData * data,const struct AudioMmapData * rxMmapData,uint32_t * totalSize)630 static int32_t AudioCapturePlatformDataInit(struct PlatformData *data, const struct AudioMmapData *rxMmapData,
631     uint32_t *totalSize)
632 {
633     data->captureBufInfo.pointer = 0;
634     data->captureBufInfo.curTrafSize = data->captureBufInfo.trafBufSize;
635     if (data->captureBufInfo.virtAddr == NULL) {
636         AUDIO_DRIVER_LOG_ERR("capture buffer is null.");
637         return HDF_FAILURE;
638     }
639 
640     if (data->captureBufInfo.runStatus != PCM_START) {
641         AUDIO_DRIVER_LOG_INFO("capture did not start.");
642         return HDF_FAILURE;
643     }
644 
645     *totalSize = (uint32_t)rxMmapData->totalBufferFrames * data->capturePcmInfo.frameSize;
646     return HDF_SUCCESS;
647 }
648 
AudioMmapReadTransfer(const struct AudioCard * card,const struct AudioMmapData * rxMmapData)649 int32_t AudioMmapReadTransfer(const struct AudioCard *card, const struct AudioMmapData *rxMmapData)
650 {
651     uint32_t offset = 0;
652     int32_t status;
653     uint32_t timeout = 0;
654     struct PlatformData *data = NULL;
655     uint32_t totalSize;
656 
657     if (card == NULL || rxMmapData == NULL || rxMmapData->memoryAddress == NULL ||
658         rxMmapData->totalBufferFrames <= 0) {
659         AUDIO_DRIVER_LOG_ERR("param is invalid.");
660         return HDF_ERR_INVALID_PARAM;
661     }
662 
663     data = PlatformDataFromCard(card);
664     if (data == NULL) {
665         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
666         return HDF_FAILURE;
667     }
668     if (AudioCapturePlatformDataInit(data, rxMmapData, &totalSize) != HDF_SUCCESS) {
669         AUDIO_DRIVER_LOG_ERR("AudioCapturePlatformDataInit failed.");
670         return HDF_FAILURE;
671     }
672     do {
673         if (data->captureBufInfo.runStatus == PCM_PAUSE) {
674             OsalMSleep(SLEEP_TIME);
675             continue;
676         }
677 
678         // 1. get buffer status
679         status = AudioDmaBuffStatus(card, AUDIO_CAPTURE_STREAM);
680         if (status != ENUM_CIR_BUFF_NORMAL) {
681             OsalMSleep(SLEEP_TIME);
682             AUDIO_DRIVER_LOG_DEBUG("dma buff status ENUM_CIR_BUFF_FULL.");
683             timeout++;
684             if (timeout >= TIME_OUT_CONST) {
685                 AUDIO_DRIVER_LOG_ERR("timeout failed.");
686                 return HDF_FAILURE;
687             }
688             continue;
689         }
690         timeout = 0;
691 
692         // 2. read data
693         if (MmapReadData(data, rxMmapData, offset) != HDF_SUCCESS) {
694             AUDIO_DRIVER_LOG_ERR("MmapReadData fail.");
695             return HDF_FAILURE;
696         }
697         offset += data->captureBufInfo.curTrafSize;
698     } while (offset < totalSize && data->captureBufInfo.runStatus != 0);
699     return HDF_SUCCESS;
700 }
701 
AudioPcmMmapRead(const struct AudioCard * card,const struct AudioMmapData * rxMmapData)702 int32_t AudioPcmMmapRead(const struct AudioCard *card, const struct AudioMmapData *rxMmapData)
703 {
704     int32_t ret;
705     struct PlatformData *data = NULL;
706     AUDIO_DRIVER_LOG_DEBUG("entry.");
707 
708     ret = (card == NULL || rxMmapData == NULL || rxMmapData->memoryAddress == NULL
709         || rxMmapData->totalBufferFrames <= 0);
710     if (ret) {
711         AUDIO_DRIVER_LOG_ERR("param is invalid.");
712         return HDF_ERR_INVALID_PARAM;
713     }
714 
715     data = PlatformDataFromCard(card);
716     if (data == NULL) {
717         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
718         return HDF_FAILURE;
719     }
720 
721     ret = AudioMmapReadTransfer(card, rxMmapData);
722     if (ret) {
723         AUDIO_DRIVER_LOG_ERR("AudioMmapReadTransfer fail.");
724         return HDF_ERR_INVALID_PARAM;
725     }
726 
727     AUDIO_DRIVER_LOG_DEBUG("success.");
728     return HDF_SUCCESS;
729 }
730 
AudioRenderBuffInit(struct PlatformData * platformData)731 static int32_t AudioRenderBuffInit(struct PlatformData *platformData)
732 {
733     int32_t ret;
734 
735     if (platformData == NULL) {
736         AUDIO_DRIVER_LOG_ERR("input para is NULL.");
737         return HDF_FAILURE;
738     }
739 
740     if (platformData->renderBufInfo.virtAddr != NULL) {
741         return HDF_SUCCESS;
742     }
743 
744     platformData->renderBufInfo.cirBufMax = MAX_BUFF_SIZE;
745     platformData->renderBufInfo.phyAddr = 0;
746 
747     ret = AudioDmaBufAlloc(platformData, AUDIO_RENDER_STREAM);
748     if (ret != HDF_SUCCESS) {
749         AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
750         return HDF_FAILURE;
751     }
752 
753     if (platformData->renderBufInfo.virtAddr == NULL) {
754         AUDIO_DRIVER_LOG_ERR("mem alloc failed.");
755         return HDF_FAILURE;
756     }
757 
758     (void)memset_s(platformData->renderBufInfo.virtAddr, platformData->renderBufInfo.cirBufMax,
759         0, platformData->renderBufInfo.cirBufMax);
760 
761     return HDF_SUCCESS;
762 }
763 
AudioRenderBuffFree(struct PlatformData * platformData)764 static int32_t AudioRenderBuffFree(struct PlatformData *platformData)
765 {
766     int32_t ret;
767 
768     if (platformData == NULL) {
769         AUDIO_DRIVER_LOG_ERR("input param is NULL.");
770         return HDF_FAILURE;
771     }
772 
773     ret = AudioDmaBufFree(platformData, AUDIO_RENDER_STREAM);
774     if (ret) {
775         AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
776         return HDF_FAILURE;
777     }
778 
779     platformData->renderBufInfo.virtAddr = NULL;
780     platformData->renderBufInfo.phyAddr = 0;
781     return HDF_SUCCESS;
782 }
783 
AudioCaptureBuffInit(struct PlatformData * platformData)784 static int32_t AudioCaptureBuffInit(struct PlatformData *platformData)
785 {
786     int32_t ret;
787 
788     if (platformData == NULL) {
789         AUDIO_DRIVER_LOG_ERR("input param is NULL.");
790         return HDF_FAILURE;
791     }
792     if (platformData->captureBufInfo.virtAddr != NULL) {
793         return HDF_SUCCESS;
794     }
795 
796     platformData->captureBufInfo.cirBufMax = MAX_BUFF_SIZE;
797     platformData->captureBufInfo.phyAddr = 0;
798 
799     ret = AudioDmaBufAlloc(platformData, AUDIO_CAPTURE_STREAM);
800     if (ret) {
801         AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
802         return HDF_FAILURE;
803     }
804 
805     if (platformData->captureBufInfo.virtAddr == NULL) {
806         AUDIO_DRIVER_LOG_ERR("mem alloc failed.");
807         return HDF_FAILURE;
808     }
809 
810     (void)memset_s(platformData->captureBufInfo.virtAddr, platformData->captureBufInfo.cirBufMax, 0,
811                    platformData->captureBufInfo.cirBufMax);
812 
813     return HDF_SUCCESS;
814 }
815 
AudioCaptureBuffFree(struct PlatformData * platformData)816 static int32_t AudioCaptureBuffFree(struct PlatformData *platformData)
817 {
818     int32_t ret;
819 
820     if (platformData == NULL) {
821         AUDIO_DRIVER_LOG_ERR("input param is NULL.");
822         return HDF_FAILURE;
823     }
824 
825     ret = AudioDmaBufFree(platformData, AUDIO_CAPTURE_STREAM);
826     if (ret != HDF_SUCCESS) {
827         AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
828         return HDF_FAILURE;
829     }
830 
831     platformData->captureBufInfo.virtAddr = NULL;
832     platformData->captureBufInfo.phyAddr = 0;
833     return HDF_SUCCESS;
834 }
835 
AudioRenderOpen(const struct AudioCard * card)836 int32_t AudioRenderOpen(const struct AudioCard *card)
837 {
838     struct PlatformData *data = PlatformDataFromCard(card);
839     if (data == NULL) {
840         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
841         return HDF_FAILURE;
842     }
843 
844     if (data->renderBufInfo.virtAddr == NULL) {
845         if (AudioRenderBuffInit(data) != HDF_SUCCESS) {
846             return HDF_FAILURE;
847         }
848     }
849     return HDF_SUCCESS;
850 }
851 
AudioRenderClose(const struct AudioCard * card)852 int32_t AudioRenderClose(const struct AudioCard *card)
853 {
854     struct PlatformData *data = PlatformDataFromCard(card);
855     if (data == NULL) {
856         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
857         return HDF_FAILURE;
858     }
859 
860     return AudioRenderBuffFree(data);
861 }
862 
AudioCaptureOpen(const struct AudioCard * card)863 int32_t AudioCaptureOpen(const struct AudioCard *card)
864 {
865     struct PlatformData *platformData = NULL;
866     if (card == NULL) {
867         AUDIO_DRIVER_LOG_ERR("capture open param card is NULL.");
868         return HDF_FAILURE;
869     }
870 
871     platformData = PlatformDataFromCard(card);
872     if (platformData == NULL) {
873         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
874         return HDF_FAILURE;
875     }
876 
877     if (platformData->captureBufInfo.virtAddr == NULL) {
878         if (AudioCaptureBuffInit(platformData) != HDF_SUCCESS) {
879             AUDIO_DRIVER_LOG_ERR("AudioCaptureBuffInit: fail.");
880             return HDF_FAILURE;
881         }
882     }
883     return HDF_SUCCESS;
884 }
885 
AudioCaptureClose(const struct AudioCard * card)886 int32_t AudioCaptureClose(const struct AudioCard *card)
887 {
888     struct PlatformData *platformData = NULL;
889     if (card == NULL) {
890         AUDIO_DRIVER_LOG_ERR("capture close param card is NULL.");
891         return HDF_FAILURE;
892     }
893 
894     platformData = PlatformDataFromCard(card);
895     if (platformData == NULL) {
896         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
897         return HDF_FAILURE;
898     }
899     return AudioCaptureBuffFree(platformData);
900 }
901 
AudioPcmPending(struct AudioCard * card,enum AudioStreamType streamType)902 static int32_t AudioPcmPending(struct AudioCard *card, enum AudioStreamType streamType)
903 {
904     struct PlatformData *data = PlatformDataFromCard(card);
905     if (data == NULL) {
906         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
907         return HDF_FAILURE;
908     }
909 
910     if (AudioDmaSubmit(data, streamType) != HDF_SUCCESS) {
911         AUDIO_DRIVER_LOG_ERR("DmaPending fail.");
912         return HDF_FAILURE;
913     }
914 
915     if (AudioDmaPending(data, streamType) != HDF_SUCCESS) {
916         AUDIO_DRIVER_LOG_ERR("DmaPending fail.");
917         return HDF_FAILURE;
918     }
919 
920     if (AudioSampPowerUp(card) != HDF_SUCCESS) {
921         AUDIO_DRIVER_LOG_ERR("PowerUp fail.");
922         return HDF_FAILURE;
923     }
924 
925     if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) {
926         return HDF_FAILURE;
927     }
928     return HDF_SUCCESS;
929 }
930 
AudioPcmPause(struct AudioCard * card,enum AudioStreamType streamType)931 static int32_t AudioPcmPause(struct AudioCard *card, enum AudioStreamType streamType)
932 {
933     struct PlatformData *data = PlatformDataFromCard(card);
934     if (data == NULL) {
935         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
936         return HDF_FAILURE;
937     }
938 
939     if (AudioDmaPause(data, streamType) != HDF_SUCCESS) {
940         AUDIO_DRIVER_LOG_ERR("DmaPause fail.");
941         return HDF_FAILURE;
942     }
943 
944     if (AudioSampSetPowerMonitor(card, true) != HDF_SUCCESS) {
945         return HDF_FAILURE;
946     }
947 
948     return HDF_SUCCESS;
949 }
950 
AudioPcmResume(struct AudioCard * card,enum AudioStreamType streamType)951 static int32_t AudioPcmResume(struct AudioCard *card, enum AudioStreamType streamType)
952 {
953     struct PlatformData *data = PlatformDataFromCard(card);
954     if (data == NULL) {
955         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
956         return HDF_FAILURE;
957     }
958 
959     if (AudioDmaResume(data, streamType) != HDF_SUCCESS) {
960         AUDIO_DRIVER_LOG_ERR("DmaPause fail.");
961         return HDF_FAILURE;
962     }
963 
964     if (AudioSampPowerUp(card) != HDF_SUCCESS) {
965         return HDF_FAILURE;
966     }
967     if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) {
968         return HDF_FAILURE;
969     }
970 
971     return HDF_SUCCESS;
972 }
973 
AudioRenderTrigger(struct AudioCard * card,int32_t cmd)974 int32_t AudioRenderTrigger(struct AudioCard *card, int32_t cmd)
975 {
976     struct PlatformData *data = PlatformDataFromCard(card);
977     if (data == NULL) {
978         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
979         return HDF_FAILURE;
980     }
981     switch (cmd) {
982         case AUDIO_DRV_PCM_IOCTL_RENDER_START:
983             if (AudioPcmPending(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
984                 AUDIO_DRIVER_LOG_ERR("AudioPcmPending fail.");
985                 return HDF_FAILURE;
986             }
987 
988             data->renderBufInfo.runStatus = PCM_START;
989             break;
990         case AUDIO_DRV_PCM_IOCTL_RENDER_STOP:
991             if (AudioPcmPause(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
992                 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
993                 return HDF_FAILURE;
994             }
995 
996             data->renderBufInfo.runStatus = PCM_STOP;
997             break;
998         case AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE:
999             if (AudioPcmPause(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1000                 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
1001                 return HDF_FAILURE;
1002             }
1003 
1004             data->renderBufInfo.runStatus = PCM_PAUSE;
1005             break;
1006         case AUDIO_DRV_PCM_IOCTL_RENDER_RESUME:
1007             if (AudioPcmResume(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1008                 AUDIO_DRIVER_LOG_ERR("AudioPcmResume fail.");
1009                 return HDF_FAILURE;
1010             }
1011 
1012             data->renderBufInfo.runStatus = PCM_START;
1013             break;
1014         default:
1015             AUDIO_DRIVER_LOG_ERR("invalude cmd id: %d.", cmd);
1016             return HDF_FAILURE;
1017     }
1018     return HDF_SUCCESS;
1019 }
1020 
AudioCaptureTrigger(struct AudioCard * card,int32_t cmd)1021 int32_t AudioCaptureTrigger(struct AudioCard *card, int32_t cmd)
1022 {
1023     struct PlatformData *data = PlatformDataFromCard(card);
1024     if (data == NULL) {
1025         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
1026         return HDF_FAILURE;
1027     }
1028 
1029     switch (cmd) {
1030         case AUDIO_DRV_PCM_IOCTL_CAPTURE_START:
1031             if (AudioPcmPending(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1032                 AUDIO_DRIVER_LOG_ERR("AudioPcmPending fail.");
1033                 return HDF_FAILURE;
1034             }
1035 
1036             data->captureBufInfo.runStatus = PCM_START;
1037             break;
1038         case AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP:
1039             if (AudioPcmPause(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1040                 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
1041                 return HDF_FAILURE;
1042             }
1043 
1044             data->captureBufInfo.runStatus = PCM_STOP;
1045             break;
1046         case AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE:
1047             if (AudioPcmPause(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1048                 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
1049                 return HDF_FAILURE;
1050             }
1051 
1052             data->captureBufInfo.runStatus = PCM_PAUSE;
1053             break;
1054         case AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME:
1055             if (AudioPcmResume(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1056                 AUDIO_DRIVER_LOG_ERR("AudioPcmResume fail.");
1057                 return HDF_FAILURE;
1058             }
1059 
1060             data->captureBufInfo.runStatus = PCM_START;
1061             break;
1062         default:
1063             AUDIO_DRIVER_LOG_ERR("invalude cmd id: %d.", cmd);
1064             return HDF_FAILURE;
1065     }
1066     return HDF_SUCCESS;
1067 }
1068 
AudioDmaConfig(struct PlatformData * data,enum AudioStreamType streamType)1069 static int32_t AudioDmaConfig(struct PlatformData *data, enum AudioStreamType streamType)
1070 {
1071     int32_t ret;
1072     if (data == NULL) {
1073         AUDIO_DRIVER_LOG_ERR("platform is invalid.");
1074         return HDF_ERR_INVALID_PARAM;
1075     }
1076 
1077     if (streamType == AUDIO_RENDER_STREAM) {
1078         ret = AudioDmaConfigChannel(data, AUDIO_RENDER_STREAM);
1079         if (ret) {
1080             AUDIO_DRIVER_LOG_ERR("Dma Config Channel fail.");
1081             return HDF_FAILURE;
1082         }
1083     } else if (streamType == AUDIO_CAPTURE_STREAM) {
1084         ret = AudioDmaConfigChannel(data, AUDIO_CAPTURE_STREAM);
1085         if (ret) {
1086             AUDIO_DRIVER_LOG_ERR("Dma Config Channel fail.");
1087             return HDF_FAILURE;
1088         }
1089     } else {
1090         AUDIO_DRIVER_LOG_ERR("streamType(%d) is invalid.", streamType);
1091         return HDF_FAILURE;
1092     }
1093     return HDF_SUCCESS;
1094 }
1095 
AudioPcmTransferBytes(struct PlatformData * data,enum AudioStreamType streamType)1096 static int32_t AudioPcmTransferBytes(struct PlatformData *data, enum AudioStreamType streamType)
1097 {
1098     if (data == NULL) {
1099         AUDIO_DRIVER_LOG_ERR("param is NULL.");
1100         return HDF_ERR_INVALID_PARAM;
1101     }
1102 
1103     if (streamType == AUDIO_RENDER_STREAM) {
1104         data->renderBufInfo.oneMsBytes =
1105             data->renderPcmInfo.rate * data->renderPcmInfo.frameSize / SECOND_TO_MILLISECOND;
1106         if (data->renderBufInfo.oneMsBytes == 0) {
1107             AUDIO_DRIVER_LOG_ERR("render pcm info is error.");
1108             return HDF_FAILURE;
1109         }
1110         AUDIO_DRIVER_LOG_DEBUG("render pcm one ms transfer bytes is %d .", data->renderBufInfo.oneMsBytes);
1111     } else if (streamType == AUDIO_CAPTURE_STREAM) {
1112         data->captureBufInfo.oneMsBytes =
1113             data->capturePcmInfo.rate * data->capturePcmInfo.frameSize / SECOND_TO_MILLISECOND;
1114         if (data->captureBufInfo.oneMsBytes == 0) {
1115             AUDIO_DRIVER_LOG_ERR("capture pcm info is error.");
1116             return HDF_FAILURE;
1117         }
1118         AUDIO_DRIVER_LOG_DEBUG("capture pcm one ms transfer bytes is %d .", data->captureBufInfo.oneMsBytes);
1119     } else {
1120         AUDIO_DRIVER_LOG_ERR("streamType(%d) is invalid.", streamType);
1121         return HDF_FAILURE;
1122     }
1123 
1124     return HDF_SUCCESS;
1125 }
1126 
AudioSetRenderHwParams(const struct AudioPcmHwParams * param,struct PlatformData * data)1127 static int32_t AudioSetRenderHwParams(const struct AudioPcmHwParams *param, struct PlatformData *data)
1128 {
1129     if (param == NULL || data == NULL) {
1130         AUDIO_DRIVER_LOG_ERR("input param is NULL.");
1131         return HDF_ERR_INVALID_PARAM;
1132     }
1133 
1134     if (AudioDmaRequestChannel(data, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1135         AUDIO_DRIVER_LOG_ERR("Dma Request Channel fail.");
1136         return HDF_FAILURE;
1137     }
1138 
1139     if (AudioSetRenderBufInfo(data, param) != HDF_SUCCESS) {
1140         return HDF_FAILURE;
1141     }
1142 
1143     if (AudioDmaConfig(data, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1144         return HDF_FAILURE;
1145     }
1146 
1147     if (AudioPcmTransferBytes(data, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1148         return HDF_FAILURE;
1149     }
1150 
1151     return HDF_SUCCESS;
1152 }
1153 
AudioSetCaptureHwParams(const struct AudioPcmHwParams * param,struct PlatformData * data)1154 static int32_t AudioSetCaptureHwParams(const struct AudioPcmHwParams *param, struct PlatformData *data)
1155 {
1156     if (param == NULL || data == NULL) {
1157         AUDIO_DRIVER_LOG_ERR("input param is NULL.");
1158         return HDF_ERR_INVALID_PARAM;
1159     }
1160 
1161     if (AudioDmaRequestChannel(data, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1162         AUDIO_DRIVER_LOG_ERR("Dma Request Channel fail.");
1163         return HDF_FAILURE;
1164     }
1165 
1166     if (AudioSetCaptureBufInfo(data, param) != HDF_SUCCESS) {
1167         return HDF_FAILURE;
1168     }
1169 
1170     if (AudioDmaConfig(data, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1171         return HDF_FAILURE;
1172     }
1173 
1174     if (AudioPcmTransferBytes(data, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1175         return HDF_FAILURE;
1176     }
1177 
1178     return HDF_SUCCESS;
1179 }
1180 
1181 
AudioHwParams(const struct AudioCard * card,const struct AudioPcmHwParams * param)1182 int32_t AudioHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param)
1183 {
1184     const int32_t chnlCntMin = 1;
1185     const int32_t chnlCntMax = 2;
1186     struct PlatformData *platformData = NULL;
1187     if (card == NULL || param == NULL || param->cardServiceName == NULL) {
1188         AUDIO_DRIVER_LOG_ERR("input param is NULL.");
1189         return HDF_ERR_INVALID_PARAM;
1190     }
1191 
1192     if (param->channels < chnlCntMin || param->channels > chnlCntMax) {
1193         AUDIO_DRIVER_LOG_ERR("channels param is invalid.");
1194         return HDF_FAILURE;
1195     }
1196 
1197     platformData = PlatformDataFromCard(card);
1198     if (platformData == NULL) {
1199         AUDIO_DRIVER_LOG_ERR("platformData is null.");
1200         return HDF_FAILURE;
1201     }
1202 
1203     if (AudioSetPcmInfo(platformData, param) != HDF_SUCCESS) {
1204         return HDF_FAILURE;
1205     }
1206 
1207     if (param->streamType == AUDIO_RENDER_STREAM) {
1208         if (AudioSetRenderHwParams(param, platformData) != HDF_SUCCESS) {
1209             AUDIO_DRIVER_LOG_ERR("set render hardware params is failed.");
1210             return HDF_FAILURE;
1211         }
1212     } else if (param->streamType == AUDIO_CAPTURE_STREAM) {
1213         if (AudioSetCaptureHwParams(param, platformData) != HDF_SUCCESS) {
1214             AUDIO_DRIVER_LOG_ERR("set capture hardware params is failed.");
1215             return HDF_FAILURE;
1216         }
1217     } else {
1218         AUDIO_DRIVER_LOG_ERR("param streamType is invalid.");
1219         return HDF_FAILURE;
1220     }
1221 
1222     return HDF_SUCCESS;
1223 }
1224 
AudioRenderPrepare(const struct AudioCard * card)1225 int32_t AudioRenderPrepare(const struct AudioCard *card)
1226 {
1227     int32_t ret;
1228     struct PlatformData *platformData = NULL;
1229     if (card == NULL) {
1230         AUDIO_DRIVER_LOG_ERR("audio render param card is NULL.");
1231         return HDF_ERR_INVALID_PARAM;
1232     }
1233 
1234     platformData = PlatformDataFromCard(card);
1235     if (platformData == NULL) {
1236         AUDIO_DRIVER_LOG_ERR("audio render PlatformDataFromCard failed.");
1237         return HDF_FAILURE;
1238     }
1239 
1240     if (platformData->renderBufInfo.virtAddr == NULL) {
1241         AUDIO_DRIVER_LOG_ERR("render buff is NULL.");
1242         return HDF_FAILURE;
1243     }
1244     (void)memset_s(platformData->renderBufInfo.virtAddr, platformData->renderBufInfo.cirBufSize, 0,
1245         platformData->renderBufInfo.cirBufSize);
1246     platformData->renderBufInfo.wbufOffSet = 0;
1247     platformData->renderBufInfo.wptrOffSet = 0;
1248     platformData->renderBufInfo.framesPosition = 0;
1249     platformData->renderBufInfo.pointer = 0;
1250     platformData->renderPcmInfo.totalStreamSize = 0;
1251     platformData->renderBufInfo.rbufOffSet = 0;
1252     platformData->renderBufInfo.trafCompCount = 0;
1253 
1254     ret = AudioDmaPrep(platformData, AUDIO_RENDER_STREAM);
1255     if (ret) {
1256         AUDIO_DRIVER_LOG_ERR("Dma prepare fail.");
1257         return HDF_FAILURE;
1258     }
1259 
1260     return HDF_SUCCESS;
1261 }
1262 
AudioCapturePrepare(const struct AudioCard * card)1263 int32_t AudioCapturePrepare(const struct AudioCard *card)
1264 {
1265     int32_t ret;
1266     struct PlatformData *platformData = NULL;
1267     if (card == NULL) {
1268         AUDIO_DRIVER_LOG_ERR("audio capture param card is NULL.");
1269         return HDF_ERR_INVALID_PARAM;
1270     }
1271 
1272     platformData = PlatformDataFromCard(card);
1273     if (platformData == NULL) {
1274         AUDIO_DRIVER_LOG_ERR("audio capture PlatformDataFromCard failed.");
1275         return HDF_ERR_INVALID_PARAM;
1276     }
1277 
1278     if (platformData->captureBufInfo.virtAddr == NULL) {
1279         AUDIO_DRIVER_LOG_ERR("capture buff is NULL.");
1280         return HDF_ERR_INVALID_PARAM;
1281     }
1282     (void)memset_s(platformData->captureBufInfo.virtAddr, platformData->captureBufInfo.cirBufSize, 0,
1283         platformData->captureBufInfo.cirBufSize);
1284     platformData->captureBufInfo.rbufOffSet = 0;
1285     platformData->captureBufInfo.rptrOffSet = 0;
1286     platformData->captureBufInfo.chnId = 0;
1287     platformData->captureBufInfo.framesPosition = 0;
1288     platformData->captureBufInfo.pointer = 0;
1289     platformData->capturePcmInfo.totalStreamSize = 0;
1290     platformData->captureBufInfo.wbufOffSet = 0;
1291     platformData->captureBufInfo.trafCompCount = 0;
1292 
1293     ret = AudioDmaPrep(platformData, AUDIO_CAPTURE_STREAM);
1294     if (ret) {
1295         AUDIO_DRIVER_LOG_ERR("Dma prepare fail.");
1296         return HDF_FAILURE;
1297     }
1298 
1299     return HDF_SUCCESS;
1300 }
1301 
AudioPcmPointer(const struct AudioCard * card,uint32_t * pointer,enum AudioStreamType streamType)1302 int32_t AudioPcmPointer(const struct AudioCard *card, uint32_t *pointer, enum AudioStreamType streamType)
1303 {
1304     int32_t ret;
1305     struct PlatformData *data = NULL;
1306     if (card == NULL || pointer == NULL) {
1307         AUDIO_DRIVER_LOG_ERR("param card is NULL.");
1308         return HDF_ERR_INVALID_PARAM;
1309     }
1310 
1311     data = PlatformDataFromCard(card);
1312     if (data == NULL) {
1313         AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
1314         return HDF_FAILURE;
1315     }
1316 
1317     ret = AudioDmaPointer(data, streamType, pointer);
1318     if (ret != HDF_SUCCESS) {
1319         AUDIO_DRIVER_LOG_ERR("Dma Pointer fail.");
1320         return HDF_FAILURE;
1321     }
1322 
1323     return HDF_SUCCESS;
1324 }
1325 
AudioCapSilenceThresholdEvent(struct HdfDeviceObject * device,const struct AudioEvent * reportMsg)1326 int32_t AudioCapSilenceThresholdEvent(struct HdfDeviceObject *device, const struct AudioEvent *reportMsg)
1327 {
1328     int32_t ret;
1329     char msgBuf[AUDIO_PNP_MSG_LEN] = {0};
1330 
1331     if (device == NULL || reportMsg == NULL) {
1332         ADM_LOG_ERR("device is NULL!");
1333         return HDF_ERR_INVALID_PARAM;
1334     }
1335 
1336     ret = snprintf_s(msgBuf, AUDIO_PNP_MSG_LEN, AUDIO_PNP_MSG_LEN - 1,
1337                      "EVENT_TYPE=0x%x;DEVICE_TYPE=0x%x", reportMsg->eventType, reportMsg->deviceType);
1338     if (ret < 0) {
1339         ADM_LOG_ERR("snprintf_s fail");
1340         return HDF_FAILURE;
1341     }
1342     if (HdfDeviceObjectSetServInfo(device, msgBuf) != HDF_SUCCESS) {
1343         ADM_LOG_ERR("HdfDeviceObjectSetServInfo fail!");
1344         return HDF_FAILURE;
1345     }
1346 
1347     ret = HdfDeviceObjectUpdate(device);
1348     if (ret != HDF_SUCCESS) {
1349         ADM_LOG_ERR("HdfDeviceObjectUpdate fail\n");
1350         return HDF_FAILURE;
1351     }
1352 
1353     return HDF_SUCCESS;
1354 }
1355 
1356