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 ret = AudioMmapWriteTransfer(card);
574 if (ret != HDF_SUCCESS) {
575 AUDIO_DRIVER_LOG_ERR("AudioMmapTransfer fail.");
576 return HDF_FAILURE;
577 }
578
579 AUDIO_DRIVER_LOG_DEBUG("render mmap write success.");
580 return HDF_SUCCESS;
581 }
582
MmapReadData(struct PlatformData * data,const struct AudioMmapData * rxMmapData,uint32_t offset)583 static int32_t MmapReadData(struct PlatformData *data, const struct AudioMmapData *rxMmapData, uint32_t offset)
584 {
585 uint32_t wPtr;
586 uint32_t rPtr;
587 uint32_t validDataSize;
588
589 if (data == NULL || rxMmapData == NULL) {
590 AUDIO_DRIVER_LOG_ERR("data is null.");
591 return HDF_FAILURE;
592 }
593
594 rPtr = data->captureBufInfo.rptrOffSet;
595 wPtr = data->captureBufInfo.pointer * data->capturePcmInfo.frameSize;
596 if (rPtr > wPtr) {
597 validDataSize = data->captureBufInfo.cirBufSize - rPtr;
598 if (validDataSize < data->captureBufInfo.trafBufSize) {
599 data->captureBufInfo.curTrafSize = validDataSize;
600 }
601 }
602 if (data->capturePcmInfo.isBigEndian) {
603 if (AudioDataBigEndianChange((char *)(data->captureBufInfo.virtAddr) + rPtr,
604 data->captureBufInfo.curTrafSize, data->capturePcmInfo.bitWidth) != HDF_SUCCESS) {
605 AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed.");
606 return HDF_FAILURE;
607 }
608 }
609
610 if (CopyToUser((char *)rxMmapData->memoryAddress + offset,
611 (char *)(data->captureBufInfo.virtAddr) + rPtr, data->captureBufInfo.curTrafSize) != 0) {
612 AUDIO_DRIVER_LOG_ERR("CopyToUser failed.");
613 return HDF_FAILURE;
614 }
615
616 // 4. update rptr
617 data->captureBufInfo.rptrOffSet += data->captureBufInfo.curTrafSize;
618 if (data->captureBufInfo.rptrOffSet >= data->captureBufInfo.cirBufSize) {
619 data->captureBufInfo.rptrOffSet = 0;
620 }
621 data->captureBufInfo.framesPosition += data->captureBufInfo.curTrafSize / data->capturePcmInfo.frameSize;
622 data->captureBufInfo.rbufOffSet += data->captureBufInfo.curTrafSize;
623 return HDF_SUCCESS;
624 }
625
AudioCapturePlatformDataInit(struct PlatformData * data,const struct AudioMmapData * rxMmapData,uint32_t * totalSize)626 static int32_t AudioCapturePlatformDataInit(struct PlatformData *data, const struct AudioMmapData *rxMmapData,
627 uint32_t *totalSize)
628 {
629 data->captureBufInfo.pointer = 0;
630 data->captureBufInfo.curTrafSize = data->captureBufInfo.trafBufSize;
631 if (data->captureBufInfo.virtAddr == NULL) {
632 AUDIO_DRIVER_LOG_ERR("capture buffer is null.");
633 return HDF_FAILURE;
634 }
635
636 if (data->captureBufInfo.runStatus != PCM_START) {
637 AUDIO_DRIVER_LOG_INFO("capture did not start.");
638 return HDF_FAILURE;
639 }
640
641 *totalSize = (uint32_t)rxMmapData->totalBufferFrames * data->capturePcmInfo.frameSize;
642 return HDF_SUCCESS;
643 }
644
AudioMmapReadTransfer(const struct AudioCard * card,const struct AudioMmapData * rxMmapData)645 int32_t AudioMmapReadTransfer(const struct AudioCard *card, const struct AudioMmapData *rxMmapData)
646 {
647 uint32_t offset = 0;
648 int32_t status;
649 uint32_t timeout = 0;
650 struct PlatformData *data = NULL;
651 uint32_t totalSize;
652
653 if (card == NULL || rxMmapData == NULL || rxMmapData->memoryAddress == NULL ||
654 rxMmapData->totalBufferFrames <= 0) {
655 AUDIO_DRIVER_LOG_ERR("param is invalid.");
656 return HDF_ERR_INVALID_PARAM;
657 }
658
659 data = PlatformDataFromCard(card);
660 if (data == NULL) {
661 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
662 return HDF_FAILURE;
663 }
664 if (AudioCapturePlatformDataInit(data, rxMmapData, &totalSize) != HDF_SUCCESS) {
665 AUDIO_DRIVER_LOG_ERR("AudioCapturePlatformDataInit failed.");
666 return HDF_FAILURE;
667 }
668 do {
669 if (data->captureBufInfo.runStatus == PCM_PAUSE) {
670 OsalMSleep(SLEEP_TIME);
671 continue;
672 }
673
674 // 1. get buffer status
675 status = AudioDmaBuffStatus(card, AUDIO_CAPTURE_STREAM);
676 if (status != ENUM_CIR_BUFF_NORMAL) {
677 OsalMSleep(SLEEP_TIME);
678 AUDIO_DRIVER_LOG_DEBUG("dma buff status ENUM_CIR_BUFF_FULL.");
679 timeout++;
680 if (timeout >= TIME_OUT_CONST) {
681 AUDIO_DRIVER_LOG_ERR("timeout failed.");
682 return HDF_FAILURE;
683 }
684 continue;
685 }
686 timeout = 0;
687
688 // 2. read data
689 if (MmapReadData(data, rxMmapData, offset) != HDF_SUCCESS) {
690 AUDIO_DRIVER_LOG_ERR("MmapReadData fail.");
691 return HDF_FAILURE;
692 }
693 offset += data->captureBufInfo.curTrafSize;
694 } while (offset < totalSize && data->captureBufInfo.runStatus != 0);
695 return HDF_SUCCESS;
696 }
697
AudioPcmMmapRead(const struct AudioCard * card,const struct AudioMmapData * rxMmapData)698 int32_t AudioPcmMmapRead(const struct AudioCard *card, const struct AudioMmapData *rxMmapData)
699 {
700 int32_t ret;
701 struct PlatformData *data = NULL;
702 AUDIO_DRIVER_LOG_DEBUG("entry.");
703
704 ret = (card == NULL || rxMmapData == NULL || rxMmapData->memoryAddress == NULL
705 || rxMmapData->totalBufferFrames <= 0);
706 if (ret) {
707 AUDIO_DRIVER_LOG_ERR("param is invalid.");
708 return HDF_ERR_INVALID_PARAM;
709 }
710
711 data = PlatformDataFromCard(card);
712 if (data == NULL) {
713 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
714 return HDF_FAILURE;
715 }
716
717 ret = AudioMmapReadTransfer(card, rxMmapData);
718 if (ret) {
719 AUDIO_DRIVER_LOG_ERR("AudioMmapReadTransfer fail.");
720 return HDF_ERR_INVALID_PARAM;
721 }
722
723 AUDIO_DRIVER_LOG_DEBUG("success.");
724 return HDF_SUCCESS;
725 }
726
AudioRenderBuffInit(struct PlatformData * platformData)727 static int32_t AudioRenderBuffInit(struct PlatformData *platformData)
728 {
729 int32_t ret;
730
731 if (platformData == NULL) {
732 AUDIO_DRIVER_LOG_ERR("input para is NULL.");
733 return HDF_FAILURE;
734 }
735
736 if (platformData->renderBufInfo.virtAddr != NULL) {
737 return HDF_SUCCESS;
738 }
739
740 platformData->renderBufInfo.cirBufMax = MAX_BUFF_SIZE;
741 platformData->renderBufInfo.phyAddr = 0;
742
743 ret = AudioDmaBufAlloc(platformData, AUDIO_RENDER_STREAM);
744 if (ret != HDF_SUCCESS) {
745 AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
746 return HDF_FAILURE;
747 }
748
749 if (platformData->renderBufInfo.virtAddr == NULL) {
750 AUDIO_DRIVER_LOG_ERR("mem alloc failed.");
751 return HDF_FAILURE;
752 }
753
754 (void)memset_s(platformData->renderBufInfo.virtAddr, platformData->renderBufInfo.cirBufMax,
755 0, platformData->renderBufInfo.cirBufMax);
756
757 return HDF_SUCCESS;
758 }
759
AudioRenderBuffFree(struct PlatformData * platformData)760 static int32_t AudioRenderBuffFree(struct PlatformData *platformData)
761 {
762 int32_t ret;
763
764 if (platformData == NULL) {
765 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
766 return HDF_FAILURE;
767 }
768
769 ret = AudioDmaBufFree(platformData, AUDIO_RENDER_STREAM);
770 if (ret) {
771 AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
772 return HDF_FAILURE;
773 }
774
775 platformData->renderBufInfo.virtAddr = NULL;
776 platformData->renderBufInfo.phyAddr = 0;
777 return HDF_SUCCESS;
778 }
779
AudioCaptureBuffInit(struct PlatformData * platformData)780 static int32_t AudioCaptureBuffInit(struct PlatformData *platformData)
781 {
782 int32_t ret;
783
784 if (platformData == NULL) {
785 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
786 return HDF_FAILURE;
787 }
788 if (platformData->captureBufInfo.virtAddr != NULL) {
789 return HDF_SUCCESS;
790 }
791
792 platformData->captureBufInfo.cirBufMax = MAX_BUFF_SIZE;
793 platformData->captureBufInfo.phyAddr = 0;
794
795 ret = AudioDmaBufAlloc(platformData, AUDIO_CAPTURE_STREAM);
796 if (ret) {
797 AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
798 return HDF_FAILURE;
799 }
800
801 if (platformData->captureBufInfo.virtAddr == NULL) {
802 AUDIO_DRIVER_LOG_ERR("mem alloc failed.");
803 return HDF_FAILURE;
804 }
805
806 (void)memset_s(platformData->captureBufInfo.virtAddr, platformData->captureBufInfo.cirBufMax, 0,
807 platformData->captureBufInfo.cirBufMax);
808
809 return HDF_SUCCESS;
810 }
811
AudioCaptureBuffFree(struct PlatformData * platformData)812 static int32_t AudioCaptureBuffFree(struct PlatformData *platformData)
813 {
814 int32_t ret;
815
816 if (platformData == NULL) {
817 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
818 return HDF_FAILURE;
819 }
820
821 ret = AudioDmaBufFree(platformData, AUDIO_CAPTURE_STREAM);
822 if (ret != HDF_SUCCESS) {
823 AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
824 return HDF_FAILURE;
825 }
826
827 platformData->captureBufInfo.virtAddr = NULL;
828 platformData->captureBufInfo.phyAddr = 0;
829 return HDF_SUCCESS;
830 }
831
AudioRenderOpen(const struct AudioCard * card)832 int32_t AudioRenderOpen(const struct AudioCard *card)
833 {
834 struct PlatformData *data = PlatformDataFromCard(card);
835 if (data == NULL) {
836 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
837 return HDF_FAILURE;
838 }
839
840 if (data->renderBufInfo.virtAddr == NULL) {
841 if (AudioRenderBuffInit(data) != HDF_SUCCESS) {
842 return HDF_FAILURE;
843 }
844 }
845 return HDF_SUCCESS;
846 }
847
AudioRenderClose(const struct AudioCard * card)848 int32_t AudioRenderClose(const struct AudioCard *card)
849 {
850 struct PlatformData *data = PlatformDataFromCard(card);
851 if (data == NULL) {
852 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
853 return HDF_FAILURE;
854 }
855
856 return AudioRenderBuffFree(data);
857 }
858
AudioCaptureOpen(const struct AudioCard * card)859 int32_t AudioCaptureOpen(const struct AudioCard *card)
860 {
861 struct PlatformData *platformData = NULL;
862 if (card == NULL) {
863 AUDIO_DRIVER_LOG_ERR("capture open param card is NULL.");
864 return HDF_FAILURE;
865 }
866
867 platformData = PlatformDataFromCard(card);
868 if (platformData == NULL) {
869 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
870 return HDF_FAILURE;
871 }
872
873 if (platformData->captureBufInfo.virtAddr == NULL) {
874 if (AudioCaptureBuffInit(platformData) != HDF_SUCCESS) {
875 AUDIO_DRIVER_LOG_ERR("AudioCaptureBuffInit: fail.");
876 return HDF_FAILURE;
877 }
878 }
879 return HDF_SUCCESS;
880 }
881
AudioCaptureClose(const struct AudioCard * card)882 int32_t AudioCaptureClose(const struct AudioCard *card)
883 {
884 struct PlatformData *platformData = NULL;
885 if (card == NULL) {
886 AUDIO_DRIVER_LOG_ERR("capture close param card is NULL.");
887 return HDF_FAILURE;
888 }
889
890 platformData = PlatformDataFromCard(card);
891 if (platformData == NULL) {
892 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
893 return HDF_FAILURE;
894 }
895 return AudioCaptureBuffFree(platformData);
896 }
897
AudioPcmPending(struct AudioCard * card,enum AudioStreamType streamType)898 static int32_t AudioPcmPending(struct AudioCard *card, enum AudioStreamType streamType)
899 {
900 struct PlatformData *data = PlatformDataFromCard(card);
901 if (data == NULL) {
902 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
903 return HDF_FAILURE;
904 }
905
906 if (AudioDmaSubmit(data, streamType) != HDF_SUCCESS) {
907 AUDIO_DRIVER_LOG_ERR("DmaPending fail.");
908 return HDF_FAILURE;
909 }
910
911 if (AudioDmaPending(data, streamType) != HDF_SUCCESS) {
912 AUDIO_DRIVER_LOG_ERR("DmaPending fail.");
913 return HDF_FAILURE;
914 }
915
916 if (AudioSampPowerUp(card) != HDF_SUCCESS) {
917 AUDIO_DRIVER_LOG_ERR("PowerUp fail.");
918 return HDF_FAILURE;
919 }
920
921 if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) {
922 return HDF_FAILURE;
923 }
924 return HDF_SUCCESS;
925 }
926
AudioPcmPause(struct AudioCard * card,enum AudioStreamType streamType)927 static int32_t AudioPcmPause(struct AudioCard *card, enum AudioStreamType streamType)
928 {
929 struct PlatformData *data = PlatformDataFromCard(card);
930 if (data == NULL) {
931 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
932 return HDF_FAILURE;
933 }
934
935 if (AudioDmaPause(data, streamType) != HDF_SUCCESS) {
936 AUDIO_DRIVER_LOG_ERR("DmaPause fail.");
937 return HDF_FAILURE;
938 }
939
940 if (AudioSampSetPowerMonitor(card, true) != HDF_SUCCESS) {
941 return HDF_FAILURE;
942 }
943
944 return HDF_SUCCESS;
945 }
946
AudioPcmResume(struct AudioCard * card,enum AudioStreamType streamType)947 static int32_t AudioPcmResume(struct AudioCard *card, enum AudioStreamType streamType)
948 {
949 struct PlatformData *data = PlatformDataFromCard(card);
950 if (data == NULL) {
951 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
952 return HDF_FAILURE;
953 }
954
955 if (AudioDmaResume(data, streamType) != HDF_SUCCESS) {
956 AUDIO_DRIVER_LOG_ERR("DmaPause fail.");
957 return HDF_FAILURE;
958 }
959
960 if (AudioSampPowerUp(card) != HDF_SUCCESS) {
961 return HDF_FAILURE;
962 }
963 if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) {
964 return HDF_FAILURE;
965 }
966
967 return HDF_SUCCESS;
968 }
969
AudioRenderTrigger(struct AudioCard * card,int32_t cmd)970 int32_t AudioRenderTrigger(struct AudioCard *card, int32_t cmd)
971 {
972 struct PlatformData *data = PlatformDataFromCard(card);
973 if (data == NULL) {
974 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
975 return HDF_FAILURE;
976 }
977 switch (cmd) {
978 case AUDIO_DRV_PCM_IOCTL_RENDER_START:
979 if (AudioPcmPending(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
980 AUDIO_DRIVER_LOG_ERR("AudioPcmPending fail.");
981 return HDF_FAILURE;
982 }
983
984 data->renderBufInfo.runStatus = PCM_START;
985 break;
986 case AUDIO_DRV_PCM_IOCTL_RENDER_STOP:
987 if (AudioPcmPause(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
988 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
989 return HDF_FAILURE;
990 }
991
992 data->renderBufInfo.runStatus = PCM_STOP;
993 break;
994 case AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE:
995 if (AudioPcmPause(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
996 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
997 return HDF_FAILURE;
998 }
999
1000 data->renderBufInfo.runStatus = PCM_PAUSE;
1001 break;
1002 case AUDIO_DRV_PCM_IOCTL_RENDER_RESUME:
1003 if (AudioPcmResume(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1004 AUDIO_DRIVER_LOG_ERR("AudioPcmResume fail.");
1005 return HDF_FAILURE;
1006 }
1007
1008 data->renderBufInfo.runStatus = PCM_START;
1009 break;
1010 default:
1011 AUDIO_DRIVER_LOG_ERR("invalude cmd id: %d.", cmd);
1012 return HDF_FAILURE;
1013 }
1014 return HDF_SUCCESS;
1015 }
1016
AudioCaptureTrigger(struct AudioCard * card,int32_t cmd)1017 int32_t AudioCaptureTrigger(struct AudioCard *card, int32_t cmd)
1018 {
1019 struct PlatformData *data = PlatformDataFromCard(card);
1020 if (data == NULL) {
1021 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
1022 return HDF_FAILURE;
1023 }
1024
1025 switch (cmd) {
1026 case AUDIO_DRV_PCM_IOCTL_CAPTURE_START:
1027 if (AudioPcmPending(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1028 AUDIO_DRIVER_LOG_ERR("AudioPcmPending fail.");
1029 return HDF_FAILURE;
1030 }
1031
1032 data->captureBufInfo.runStatus = PCM_START;
1033 break;
1034 case AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP:
1035 if (AudioPcmPause(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1036 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
1037 return HDF_FAILURE;
1038 }
1039
1040 data->captureBufInfo.runStatus = PCM_STOP;
1041 break;
1042 case AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE:
1043 if (AudioPcmPause(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1044 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
1045 return HDF_FAILURE;
1046 }
1047
1048 data->captureBufInfo.runStatus = PCM_PAUSE;
1049 break;
1050 case AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME:
1051 if (AudioPcmResume(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1052 AUDIO_DRIVER_LOG_ERR("AudioPcmResume fail.");
1053 return HDF_FAILURE;
1054 }
1055
1056 data->captureBufInfo.runStatus = PCM_START;
1057 break;
1058 default:
1059 AUDIO_DRIVER_LOG_ERR("invalude cmd id: %d.", cmd);
1060 return HDF_FAILURE;
1061 }
1062 return HDF_SUCCESS;
1063 }
1064
AudioDmaConfig(struct PlatformData * data,enum AudioStreamType streamType)1065 static int32_t AudioDmaConfig(struct PlatformData *data, enum AudioStreamType streamType)
1066 {
1067 int32_t ret;
1068 if (data == NULL) {
1069 AUDIO_DRIVER_LOG_ERR("platform is invalid.");
1070 return HDF_ERR_INVALID_PARAM;
1071 }
1072
1073 if (streamType == AUDIO_RENDER_STREAM) {
1074 ret = AudioDmaConfigChannel(data, AUDIO_RENDER_STREAM);
1075 if (ret) {
1076 AUDIO_DRIVER_LOG_ERR("Dma Config Channel fail.");
1077 return HDF_FAILURE;
1078 }
1079 } else if (streamType == AUDIO_CAPTURE_STREAM) {
1080 ret = AudioDmaConfigChannel(data, AUDIO_CAPTURE_STREAM);
1081 if (ret) {
1082 AUDIO_DRIVER_LOG_ERR("Dma Config Channel fail.");
1083 return HDF_FAILURE;
1084 }
1085 } else {
1086 AUDIO_DRIVER_LOG_ERR("streamType(%d) is invalid.", streamType);
1087 return HDF_FAILURE;
1088 }
1089 return HDF_SUCCESS;
1090 }
1091
AudioPcmTransferBytes(struct PlatformData * data,enum AudioStreamType streamType)1092 static int32_t AudioPcmTransferBytes(struct PlatformData *data, enum AudioStreamType streamType)
1093 {
1094 if (data == NULL) {
1095 AUDIO_DRIVER_LOG_ERR("param is NULL.");
1096 return HDF_ERR_INVALID_PARAM;
1097 }
1098
1099 if (streamType == AUDIO_RENDER_STREAM) {
1100 data->renderBufInfo.oneMsBytes =
1101 data->renderPcmInfo.rate * data->renderPcmInfo.frameSize / SECOND_TO_MILLISECOND;
1102 if (data->renderBufInfo.oneMsBytes == 0) {
1103 AUDIO_DRIVER_LOG_ERR("render pcm info is error.");
1104 return HDF_FAILURE;
1105 }
1106 AUDIO_DRIVER_LOG_DEBUG("render pcm one ms transfer bytes is %d .", data->renderBufInfo.oneMsBytes);
1107 } else if (streamType == AUDIO_CAPTURE_STREAM) {
1108 data->captureBufInfo.oneMsBytes =
1109 data->capturePcmInfo.rate * data->capturePcmInfo.frameSize / SECOND_TO_MILLISECOND;
1110 if (data->captureBufInfo.oneMsBytes == 0) {
1111 AUDIO_DRIVER_LOG_ERR("capture pcm info is error.");
1112 return HDF_FAILURE;
1113 }
1114 AUDIO_DRIVER_LOG_DEBUG("capture pcm one ms transfer bytes is %d .", data->captureBufInfo.oneMsBytes);
1115 } else {
1116 AUDIO_DRIVER_LOG_ERR("streamType(%d) is invalid.", streamType);
1117 return HDF_FAILURE;
1118 }
1119
1120 return HDF_SUCCESS;
1121 }
1122
AudioSetRenderHwParams(const struct AudioPcmHwParams * param,struct PlatformData * data)1123 static int32_t AudioSetRenderHwParams(const struct AudioPcmHwParams *param, struct PlatformData *data)
1124 {
1125 if (param == NULL || data == NULL) {
1126 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
1127 return HDF_ERR_INVALID_PARAM;
1128 }
1129
1130 if (AudioDmaRequestChannel(data, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1131 AUDIO_DRIVER_LOG_ERR("Dma Request Channel fail.");
1132 return HDF_FAILURE;
1133 }
1134
1135 if (AudioSetRenderBufInfo(data, param) != HDF_SUCCESS) {
1136 return HDF_FAILURE;
1137 }
1138
1139 if (AudioDmaConfig(data, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1140 return HDF_FAILURE;
1141 }
1142
1143 if (AudioPcmTransferBytes(data, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1144 return HDF_FAILURE;
1145 }
1146
1147 return HDF_SUCCESS;
1148 }
1149
AudioSetCaptureHwParams(const struct AudioPcmHwParams * param,struct PlatformData * data)1150 static int32_t AudioSetCaptureHwParams(const struct AudioPcmHwParams *param, struct PlatformData *data)
1151 {
1152 if (param == NULL || data == NULL) {
1153 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
1154 return HDF_ERR_INVALID_PARAM;
1155 }
1156
1157 if (AudioDmaRequestChannel(data, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1158 AUDIO_DRIVER_LOG_ERR("Dma Request Channel fail.");
1159 return HDF_FAILURE;
1160 }
1161
1162 if (AudioSetCaptureBufInfo(data, param) != HDF_SUCCESS) {
1163 return HDF_FAILURE;
1164 }
1165
1166 if (AudioDmaConfig(data, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1167 return HDF_FAILURE;
1168 }
1169
1170 if (AudioPcmTransferBytes(data, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1171 return HDF_FAILURE;
1172 }
1173
1174 return HDF_SUCCESS;
1175 }
1176
1177
AudioHwParams(const struct AudioCard * card,const struct AudioPcmHwParams * param)1178 int32_t AudioHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param)
1179 {
1180 const int32_t chnlCntMin = 1;
1181 const int32_t chnlCntMax = 2;
1182 struct PlatformData *platformData = NULL;
1183 if (card == NULL || param == NULL || param->cardServiceName == NULL) {
1184 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
1185 return HDF_ERR_INVALID_PARAM;
1186 }
1187
1188 if (param->channels < chnlCntMin || param->channels > chnlCntMax) {
1189 AUDIO_DRIVER_LOG_ERR("channels param is invalid.");
1190 return HDF_FAILURE;
1191 }
1192
1193 platformData = PlatformDataFromCard(card);
1194 if (platformData == NULL) {
1195 AUDIO_DRIVER_LOG_ERR("platformData is null.");
1196 return HDF_FAILURE;
1197 }
1198
1199 if (AudioSetPcmInfo(platformData, param) != HDF_SUCCESS) {
1200 return HDF_FAILURE;
1201 }
1202
1203 if (param->streamType == AUDIO_RENDER_STREAM) {
1204 if (AudioSetRenderHwParams(param, platformData) != HDF_SUCCESS) {
1205 AUDIO_DRIVER_LOG_ERR("set render hardware params is failed.");
1206 return HDF_FAILURE;
1207 }
1208 } else if (param->streamType == AUDIO_CAPTURE_STREAM) {
1209 if (AudioSetCaptureHwParams(param, platformData) != HDF_SUCCESS) {
1210 AUDIO_DRIVER_LOG_ERR("set capture hardware params is failed.");
1211 return HDF_FAILURE;
1212 }
1213 } else {
1214 AUDIO_DRIVER_LOG_ERR("param streamType is invalid.");
1215 return HDF_FAILURE;
1216 }
1217
1218 return HDF_SUCCESS;
1219 }
1220
AudioRenderPrepare(const struct AudioCard * card)1221 int32_t AudioRenderPrepare(const struct AudioCard *card)
1222 {
1223 int32_t ret;
1224 struct PlatformData *platformData = NULL;
1225 if (card == NULL) {
1226 AUDIO_DRIVER_LOG_ERR("audio render param card is NULL.");
1227 return HDF_ERR_INVALID_PARAM;
1228 }
1229
1230 platformData = PlatformDataFromCard(card);
1231 if (platformData == NULL) {
1232 AUDIO_DRIVER_LOG_ERR("audio render PlatformDataFromCard failed.");
1233 return HDF_FAILURE;
1234 }
1235
1236 if (platformData->renderBufInfo.virtAddr == NULL) {
1237 AUDIO_DRIVER_LOG_ERR("render buff is NULL.");
1238 return HDF_FAILURE;
1239 }
1240 (void)memset_s(platformData->renderBufInfo.virtAddr, platformData->renderBufInfo.cirBufSize, 0,
1241 platformData->renderBufInfo.cirBufSize);
1242 platformData->renderBufInfo.wbufOffSet = 0;
1243 platformData->renderBufInfo.wptrOffSet = 0;
1244 platformData->renderBufInfo.framesPosition = 0;
1245 platformData->renderBufInfo.pointer = 0;
1246 platformData->renderPcmInfo.totalStreamSize = 0;
1247 platformData->renderBufInfo.rbufOffSet = 0;
1248 platformData->renderBufInfo.trafCompCount = 0;
1249
1250 ret = AudioDmaPrep(platformData, AUDIO_RENDER_STREAM);
1251 if (ret) {
1252 AUDIO_DRIVER_LOG_ERR("Dma prepare fail.");
1253 return HDF_FAILURE;
1254 }
1255
1256 return HDF_SUCCESS;
1257 }
1258
AudioCapturePrepare(const struct AudioCard * card)1259 int32_t AudioCapturePrepare(const struct AudioCard *card)
1260 {
1261 int32_t ret;
1262 struct PlatformData *platformData = NULL;
1263 if (card == NULL) {
1264 AUDIO_DRIVER_LOG_ERR("audio capture param card is NULL.");
1265 return HDF_ERR_INVALID_PARAM;
1266 }
1267
1268 platformData = PlatformDataFromCard(card);
1269 if (platformData == NULL) {
1270 AUDIO_DRIVER_LOG_ERR("audio capture PlatformDataFromCard failed.");
1271 return HDF_ERR_INVALID_PARAM;
1272 }
1273
1274 if (platformData->captureBufInfo.virtAddr == NULL) {
1275 AUDIO_DRIVER_LOG_ERR("capture buff is NULL.");
1276 return HDF_ERR_INVALID_PARAM;
1277 }
1278 (void)memset_s(platformData->captureBufInfo.virtAddr, platformData->captureBufInfo.cirBufSize, 0,
1279 platformData->captureBufInfo.cirBufSize);
1280 platformData->captureBufInfo.rbufOffSet = 0;
1281 platformData->captureBufInfo.rptrOffSet = 0;
1282 platformData->captureBufInfo.chnId = 0;
1283 platformData->captureBufInfo.framesPosition = 0;
1284 platformData->captureBufInfo.pointer = 0;
1285 platformData->capturePcmInfo.totalStreamSize = 0;
1286 platformData->captureBufInfo.wbufOffSet = 0;
1287 platformData->captureBufInfo.trafCompCount = 0;
1288
1289 ret = AudioDmaPrep(platformData, AUDIO_CAPTURE_STREAM);
1290 if (ret) {
1291 AUDIO_DRIVER_LOG_ERR("Dma prepare fail.");
1292 return HDF_FAILURE;
1293 }
1294
1295 return HDF_SUCCESS;
1296 }
1297
AudioPcmPointer(const struct AudioCard * card,uint32_t * pointer,enum AudioStreamType streamType)1298 int32_t AudioPcmPointer(const struct AudioCard *card, uint32_t *pointer, enum AudioStreamType streamType)
1299 {
1300 int32_t ret;
1301 struct PlatformData *data = NULL;
1302 if (card == NULL || pointer == NULL) {
1303 AUDIO_DRIVER_LOG_ERR("param card is NULL.");
1304 return HDF_ERR_INVALID_PARAM;
1305 }
1306
1307 data = PlatformDataFromCard(card);
1308 if (data == NULL) {
1309 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
1310 return HDF_FAILURE;
1311 }
1312
1313 ret = AudioDmaPointer(data, streamType, pointer);
1314 if (ret != HDF_SUCCESS) {
1315 AUDIO_DRIVER_LOG_ERR("Dma Pointer fail.");
1316 return HDF_FAILURE;
1317 }
1318
1319 return HDF_SUCCESS;
1320 }
1321
AudioCapSilenceThresholdEvent(struct HdfDeviceObject * device,const struct AudioEvent * reportMsg)1322 int32_t AudioCapSilenceThresholdEvent(struct HdfDeviceObject *device, const struct AudioEvent *reportMsg)
1323 {
1324 int32_t ret;
1325 char msgBuf[AUDIO_PNP_MSG_LEN] = {0};
1326
1327 if (device == NULL || reportMsg == NULL) {
1328 ADM_LOG_ERR("device is NULL!");
1329 return HDF_ERR_INVALID_PARAM;
1330 }
1331
1332 ret = snprintf_s(msgBuf, AUDIO_PNP_MSG_LEN, AUDIO_PNP_MSG_LEN - 1,
1333 "EVENT_TYPE=0x%x;DEVICE_TYPE=0x%x", reportMsg->eventType, reportMsg->deviceType);
1334 if (ret < 0) {
1335 ADM_LOG_ERR("snprintf_s fail");
1336 return HDF_FAILURE;
1337 }
1338 if (HdfDeviceObjectSetServInfo(device, msgBuf) != HDF_SUCCESS) {
1339 ADM_LOG_ERR("HdfDeviceObjectSetServInfo fail!");
1340 return HDF_FAILURE;
1341 }
1342
1343 ret = HdfDeviceObjectUpdate(device);
1344 if (ret != HDF_SUCCESS) {
1345 ADM_LOG_ERR("HdfDeviceObjectUpdate fail\n");
1346 return HDF_FAILURE;
1347 }
1348
1349 return HDF_SUCCESS;
1350 }
1351
1352