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