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;
67 uint32_t *pData;
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_PCM_8_BIT:
111 *bitWidth = DATA_BIT_WIDTH8;
112 break;
113
114 case AUDIO_FORMAT_PCM_16_BIT:
115 *bitWidth = DATA_BIT_WIDTH16;
116 break;
117
118 case AUDIO_FORMAT_PCM_24_BIT:
119 *bitWidth = DATA_BIT_WIDTH24;
120 break;
121
122 case AUDIO_FORMAT_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("rptr: %d wptr: %d trafBufSize: %d ",
268 rptr, dataAvailable, data->renderBufInfo.trafBufSize);
269 return ENUM_CIR_BUFF_NORMAL;
270 } else {
271 AUDIO_DRIVER_LOG_DEBUG("full rptr: %d wptr: %d trafBufSize: %d ", rptr,
272 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("empty rptr: %d wptr: %d trafBufSize: %d ", rptr,
284 wptr, data->captureBufInfo.trafBufSize);
285 return ((data->captureBufInfo.trafBufSize - dataAvailable) / data->captureBufInfo.oneMsBytes);
286 }
287 }
288 AUDIO_DRIVER_LOG_DEBUG("rptr: %d wptr: %d trafBufSize: %d ", rptr, wptr, data->captureBufInfo.trafBufSize);
289 return ENUM_CIR_BUFF_NORMAL;
290 } else {
291 AUDIO_DRIVER_LOG_ERR("streamType is invalid.");
292 return HDF_FAILURE;
293 }
294 }
295
AudioPcmWrite(const struct AudioCard * card,struct AudioTxData * txData)296 int32_t AudioPcmWrite(const struct AudioCard *card, struct AudioTxData *txData)
297 {
298 struct PlatformData *data = NULL;
299 int32_t status;
300 uint32_t wPtr;
301 int32_t ret;
302
303 if (card == NULL || txData == NULL || txData->buf == NULL) {
304 AUDIO_DRIVER_LOG_ERR("input param is null.");
305 return HDF_FAILURE;
306 }
307
308 data = PlatformDataFromCard(card);
309 if (data == NULL) {
310 AUDIO_DRIVER_LOG_ERR("from PlatformDataFromCard get platformData is NULL.");
311 return HDF_FAILURE;
312 }
313
314 // 1. Computed buffer size
315 data->renderBufInfo.trafBufSize = txData->frames * data->renderPcmInfo.frameSize;
316
317 // 2. Big Small Exchange
318 if (data->renderPcmInfo.isBigEndian) {
319 if (AudioDataBigEndianChange(txData->buf, data->renderBufInfo.trafBufSize,
320 data->renderPcmInfo.bitWidth) != HDF_SUCCESS) {
321 AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed.");
322 return HDF_FAILURE;
323 }
324 }
325 // 3. Buffer state checking
326 status = AudioDmaBuffStatus(card, AUDIO_RENDER_STREAM);
327 if (status != ENUM_CIR_BUFF_NORMAL) {
328 txData->status = status;
329 return HDF_SUCCESS;
330 }
331
332 // 4. write buffer
333 if (data->renderBufInfo.trafBufSize > data->renderBufInfo.cirBufSize) {
334 AUDIO_DRIVER_LOG_ERR("transferFrameSize is tool big.");
335 return HDF_FAILURE;
336 }
337 wPtr = data->renderBufInfo.wbufOffSet % data->renderBufInfo.cirBufSize;
338
339 if (data->renderBufInfo.virtAddr == NULL) {
340 AUDIO_DRIVER_LOG_ERR("render buffer is null.");
341 return HDF_FAILURE;
342 }
343 ret = memcpy_s((char *)(data->renderBufInfo.virtAddr) + wPtr,
344 data->renderBufInfo.trafBufSize, txData->buf, data->renderBufInfo.trafBufSize);
345 if (ret != 0) {
346 AUDIO_DRIVER_LOG_ERR("memcpy_s failed.");
347 return HDF_FAILURE;
348 }
349 txData->status = ENUM_CIR_BUFF_NORMAL;
350 data->renderBufInfo.wptrOffSet = wPtr + data->renderBufInfo.trafBufSize;
351 data->renderBufInfo.wbufOffSet += data->renderBufInfo.trafBufSize;
352
353 return HDF_SUCCESS;
354 }
355
PcmReadData(struct PlatformData * data,struct AudioRxData * rxData)356 static int32_t PcmReadData(struct PlatformData *data, struct AudioRxData *rxData)
357 {
358 uint32_t wptr;
359 uint32_t rptr;
360 uint32_t validDataSize;
361
362 if (data == NULL || rxData == NULL) {
363 AUDIO_DRIVER_LOG_ERR("input param is null.");
364 return HDF_FAILURE;
365 }
366
367 rxData->buf = (char *)(data->captureBufInfo.virtAddr) + data->captureBufInfo.rptrOffSet;
368 wptr = data->captureBufInfo.pointer * data->capturePcmInfo.frameSize;
369 rptr = data->captureBufInfo.rptrOffSet;
370 data->captureBufInfo.curTrafSize = data->captureBufInfo.trafBufSize;
371 if (rptr > wptr) {
372 validDataSize = data->captureBufInfo.cirBufSize - rptr;
373 if (validDataSize < data->captureBufInfo.trafBufSize) {
374 data->captureBufInfo.curTrafSize = validDataSize;
375 }
376 }
377
378 // 3. Big Small Exchange
379 if (data->capturePcmInfo.isBigEndian) {
380 if (rxData->buf == NULL || AudioDataBigEndianChange(rxData->buf,
381 data->captureBufInfo.curTrafSize, data->capturePcmInfo.bitWidth) != HDF_SUCCESS) {
382 AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed.");
383 return HDF_FAILURE;
384 }
385 }
386
387 rxData->frames = data->captureBufInfo.curTrafSize / data->capturePcmInfo.frameSize;
388 rxData->bufSize = data->captureBufInfo.curTrafSize;
389 rxData->status = ENUM_CIR_BUFF_NORMAL;
390
391 return HDF_SUCCESS;
392 }
393
AudioPcmRead(const struct AudioCard * card,struct AudioRxData * rxData)394 int32_t AudioPcmRead(const struct AudioCard *card, struct AudioRxData *rxData)
395 {
396 struct PlatformData *data = NULL;
397 int32_t status;
398
399 if (card == NULL || rxData == NULL) {
400 AUDIO_DRIVER_LOG_ERR("input param is null.");
401 return HDF_FAILURE;
402 }
403
404 data = PlatformDataFromCard(card);
405 if (data == NULL) {
406 AUDIO_DRIVER_LOG_ERR("from PlatformDataFromCard get platformData is NULL.");
407 return HDF_FAILURE;
408 }
409 if (data->captureBufInfo.virtAddr == NULL) {
410 AUDIO_DRIVER_LOG_ERR("capture buffer is null.");
411 return HDF_FAILURE;
412 }
413
414 // 1. Buffer state checking
415 status = AudioDmaBuffStatus(card, AUDIO_CAPTURE_STREAM);
416 if (status != ENUM_CIR_BUFF_NORMAL) {
417 rxData->status = status;
418 rxData->buf = (char *)(data->captureBufInfo.virtAddr) + data->captureBufInfo.rptrOffSet;
419 rxData->frames = 0;
420 rxData->bufSize = 0;
421 AUDIO_DRIVER_LOG_DEBUG("buff is empty.");
422 return HDF_SUCCESS;
423 }
424
425 // 2. read buffer
426 if (PcmReadData(data, rxData) != HDF_SUCCESS) {
427 AUDIO_DRIVER_LOG_ERR("Pcm Read Data fail.");
428 return HDF_FAILURE;
429 }
430
431 // 4. update rptr
432 data->captureBufInfo.rptrOffSet += data->captureBufInfo.curTrafSize;
433 if (data->captureBufInfo.rptrOffSet >= data->captureBufInfo.cirBufSize) {
434 data->captureBufInfo.rptrOffSet = 0;
435 }
436 return HDF_SUCCESS;
437 }
438
MmapWriteData(struct PlatformData * data,char * tmpBuf)439 static int32_t MmapWriteData(struct PlatformData *data, char *tmpBuf)
440 {
441 uint32_t wPtr;
442 int32_t ret;
443
444 if (data->renderBufInfo.trafBufSize > data->renderBufInfo.cirBufSize) {
445 AUDIO_DRIVER_LOG_ERR("transferFrameSize is tool big.");
446 return HDF_FAILURE;
447 }
448
449 wPtr = data->renderBufInfo.wbufOffSet % data->renderBufInfo.cirBufSize;
450 ret = CopyFromUser(tmpBuf, (char *)data->mmapData.memoryAddress + data->mmapData.offset,
451 data->renderBufInfo.trafBufSize);
452 if (ret != EOK) {
453 AUDIO_DRIVER_LOG_ERR("CopyFromUser failed.");
454 return HDF_FAILURE;
455 }
456
457 ret = memcpy_s((char *)(data->renderBufInfo.virtAddr) + wPtr, data->renderBufInfo.trafBufSize,
458 tmpBuf, data->renderBufInfo.trafBufSize);
459 if (ret != 0) {
460 AUDIO_DRIVER_LOG_ERR("memcpy_s failed.");
461 return HDF_FAILURE;
462 }
463
464 data->renderBufInfo.wptrOffSet = wPtr + data->renderBufInfo.trafBufSize;
465 data->renderBufInfo.wbufOffSet += data->renderBufInfo.trafBufSize;
466 data->renderBufInfo.framesPosition += data->renderBufInfo.trafBufSize / data->renderPcmInfo.frameSize;
467 data->mmapData.offset += data->renderBufInfo.trafBufSize;
468 data->mmapLoopCount++;
469 return HDF_SUCCESS;
470 }
471
AudioPlatformDataInit(struct PlatformData * data,uint32_t * totalSize,uint32_t * lastBuffSize,uint32_t * loopTimes)472 static int32_t AudioPlatformDataInit(struct PlatformData *data, uint32_t *totalSize, uint32_t *lastBuffSize,
473 uint32_t *loopTimes)
474 {
475 if (data == NULL) {
476 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
477 return HDF_FAILURE;
478 }
479 if (data->renderBufInfo.virtAddr == NULL) {
480 AUDIO_DRIVER_LOG_ERR("render buffer is null.");
481 return HDF_FAILURE;
482 }
483
484 *totalSize = (uint32_t)data->mmapData.totalBufferFrames * data->renderPcmInfo.frameSize;
485 *lastBuffSize = ((*totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (*totalSize % MIN_PERIOD_SIZE);
486 *loopTimes = (*lastBuffSize == MIN_PERIOD_SIZE) ?
487 (*totalSize / MIN_PERIOD_SIZE) : (*totalSize / MIN_PERIOD_SIZE + 1);
488 data->mmapLoopCount = 0;
489 return HDF_SUCCESS;
490 }
491
AudioMmapWriteTransfer(const struct AudioCard * card)492 static int32_t AudioMmapWriteTransfer(const struct AudioCard *card)
493 {
494 uint32_t timeout = 0;
495 uint32_t totalSize;
496 uint32_t lastBuffSize;
497 uint32_t loopTimes;
498 char *tmpBuf;
499
500 struct PlatformData *data = PlatformDataFromCard(card);
501 if (AudioPlatformDataInit(data, &totalSize, &lastBuffSize, &loopTimes) == HDF_FAILURE) {
502 return HDF_FAILURE;
503 }
504 tmpBuf = OsalMemCalloc(MIN_PERIOD_SIZE);
505 if (tmpBuf == NULL) {
506 AUDIO_DRIVER_LOG_ERR("tmpBuf is null.");
507 return HDF_FAILURE;
508 }
509 while (data->mmapLoopCount < loopTimes && data->renderBufInfo.runStatus != PCM_STOP) {
510 if (data->renderBufInfo.runStatus == PCM_PAUSE) {
511 OsalMSleep(SLEEP_TIME);
512 continue;
513 }
514
515 if (AudioDmaBuffStatus(card, AUDIO_RENDER_STREAM) != ENUM_CIR_BUFF_NORMAL) {
516 OsalMSleep(SLEEP_TIME);
517 AUDIO_DRIVER_LOG_DEBUG("dma buff status ENUM_CIR_BUFF_FULL.");
518 timeout++;
519 if (timeout >= TIME_OUT_CONST) {
520 OsalMemFree(tmpBuf);
521 AUDIO_DRIVER_LOG_ERR("timeout failed.");
522 return HDF_FAILURE;
523 }
524 continue;
525 }
526 timeout = 0;
527 data->renderBufInfo.trafBufSize = (data->mmapLoopCount < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize;
528
529 if (MmapWriteData(data, tmpBuf) != HDF_SUCCESS) {
530 OsalMemFree(tmpBuf);
531 return HDF_FAILURE;
532 }
533 }
534
535 if (data->mmapLoopCount > loopTimes) {
536 data->renderBufInfo.runStatus = PCM_STOP;
537 }
538
539 OsalMemFree(tmpBuf);
540 return HDF_SUCCESS;
541 }
542
AudioPcmMmapWrite(const struct AudioCard * card,const struct AudioMmapData * txMmapData)543 int32_t AudioPcmMmapWrite(const struct AudioCard *card, const struct AudioMmapData *txMmapData)
544 {
545 int32_t ret;
546 struct PlatformData *data = NULL;
547 AUDIO_DRIVER_LOG_DEBUG("entry.");
548
549 data = PlatformDataFromCard(card);
550 if (data == NULL) {
551 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
552 return HDF_FAILURE;
553 }
554
555 if (txMmapData == NULL || txMmapData->memoryAddress == NULL || txMmapData->transferFrameSize <= 0 ||
556 txMmapData->totalBufferFrames <= 0) {
557 AUDIO_DRIVER_LOG_ERR("param is invalid.");
558 return HDF_ERR_INVALID_PARAM;
559 }
560
561 data->mmapData.offset = txMmapData->offset;
562 data->mmapData.memoryAddress = txMmapData->memoryAddress;
563 data->mmapData.totalBufferFrames = txMmapData->totalBufferFrames;
564 data->mmapData.transferFrameSize = txMmapData->transferFrameSize;
565 data->mmapLoopCount = 0;
566
567 AUDIO_DRIVER_LOG_DEBUG("*******offset=0x%x memoryAddress=0x%x totalBufferFrames=0x%x transferFrameSize=0x%x ",
568 data->mmapData.offset, data->mmapData.memoryAddress, data->mmapData.totalBufferFrames,
569 data->mmapData.transferFrameSize);
570
571 ret = AudioMmapWriteTransfer(card);
572 if (ret != HDF_SUCCESS) {
573 AUDIO_DRIVER_LOG_ERR("AudioMmapTransfer fail.");
574 return HDF_FAILURE;
575 }
576
577 AUDIO_DRIVER_LOG_DEBUG("render mmap write success.");
578 return HDF_SUCCESS;
579 }
580
MmapReadData(struct PlatformData * data,const struct AudioMmapData * rxMmapData,uint32_t offset)581 static int32_t MmapReadData(struct PlatformData *data, const struct AudioMmapData *rxMmapData, uint32_t offset)
582 {
583 uint32_t wPtr;
584 uint32_t rPtr;
585 uint32_t validDataSize;
586
587 if (data == NULL || rxMmapData == NULL) {
588 AUDIO_DRIVER_LOG_ERR("data is null.");
589 return HDF_FAILURE;
590 }
591
592 rPtr = data->captureBufInfo.rptrOffSet;
593 wPtr = data->captureBufInfo.pointer * data->capturePcmInfo.frameSize;
594 if (rPtr > wPtr) {
595 validDataSize = data->captureBufInfo.cirBufSize - rPtr;
596 if (validDataSize < data->captureBufInfo.trafBufSize) {
597 data->captureBufInfo.curTrafSize = validDataSize;
598 }
599 }
600 if (data->capturePcmInfo.isBigEndian) {
601 if (AudioDataBigEndianChange((char *)(data->captureBufInfo.virtAddr) + rPtr,
602 data->captureBufInfo.curTrafSize, data->capturePcmInfo.bitWidth) != HDF_SUCCESS) {
603 AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed.");
604 return HDF_FAILURE;
605 }
606 }
607
608 if (CopyToUser((char *)rxMmapData->memoryAddress + offset,
609 (char *)(data->captureBufInfo.virtAddr) + rPtr, data->captureBufInfo.curTrafSize) != 0) {
610 AUDIO_DRIVER_LOG_ERR("CopyToUser failed.");
611 return HDF_FAILURE;
612 }
613
614 // 4. update rptr
615 data->captureBufInfo.rptrOffSet += data->captureBufInfo.curTrafSize;
616 if (data->captureBufInfo.rptrOffSet >= data->captureBufInfo.cirBufSize) {
617 data->captureBufInfo.rptrOffSet = 0;
618 }
619 data->captureBufInfo.framesPosition += data->captureBufInfo.curTrafSize / data->capturePcmInfo.frameSize;
620
621 return HDF_SUCCESS;
622 }
623
AudioMmapReadTransfer(const struct AudioCard * card,const struct AudioMmapData * rxMmapData)624 static int32_t AudioMmapReadTransfer(const struct AudioCard *card, const struct AudioMmapData *rxMmapData)
625 {
626 uint32_t offset = 0;
627 int32_t status;
628 uint32_t timeout = 0;
629 struct PlatformData *data;
630 uint32_t frameSize;
631 uint32_t totalSize;
632
633 if (card == NULL || rxMmapData == NULL || rxMmapData->memoryAddress == NULL ||
634 rxMmapData->totalBufferFrames <= 0) {
635 AUDIO_DRIVER_LOG_ERR("param is invalid.");
636 return HDF_ERR_INVALID_PARAM;
637 }
638
639 data = PlatformDataFromCard(card);
640 if (data == NULL) {
641 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
642 return HDF_FAILURE;
643 }
644
645 frameSize = data->capturePcmInfo.frameSize;
646 totalSize = (uint32_t)rxMmapData->totalBufferFrames * frameSize;
647 data->captureBufInfo.pointer = 0;
648 data->captureBufInfo.curTrafSize = data->captureBufInfo.trafBufSize;
649 if (data->captureBufInfo.virtAddr == NULL) {
650 AUDIO_DRIVER_LOG_ERR("capture buffer is null.");
651 return HDF_FAILURE;
652 }
653
654 do {
655 if (data->captureBufInfo.runStatus == PCM_PAUSE) {
656 OsalMSleep(SLEEP_TIME);
657 continue;
658 }
659
660 // 1. get buffer status
661 status = AudioDmaBuffStatus(card, AUDIO_CAPTURE_STREAM);
662 if (status != ENUM_CIR_BUFF_NORMAL) {
663 OsalMSleep(SLEEP_TIME);
664 AUDIO_DRIVER_LOG_DEBUG("dma buff status ENUM_CIR_BUFF_FULL.");
665 timeout++;
666 if (timeout >= TIME_OUT_CONST) {
667 AUDIO_DRIVER_LOG_ERR("timeout failed.");
668 return HDF_FAILURE;
669 }
670 continue;
671 }
672 timeout = 0;
673
674 // 2. read data
675 if (MmapReadData(data, rxMmapData, offset) != HDF_SUCCESS) {
676 AUDIO_DRIVER_LOG_ERR("MmapReadData fail.");
677 return HDF_FAILURE;
678 }
679 offset += data->captureBufInfo.curTrafSize;
680 } while (offset < totalSize && data->captureBufInfo.runStatus != 0);
681 return HDF_SUCCESS;
682 }
683
AudioPcmMmapRead(const struct AudioCard * card,const struct AudioMmapData * rxMmapData)684 int32_t AudioPcmMmapRead(const struct AudioCard *card, const struct AudioMmapData *rxMmapData)
685 {
686 int32_t ret;
687 struct PlatformData *data = NULL;
688 AUDIO_DRIVER_LOG_DEBUG("entry.");
689
690 ret = (card == NULL || rxMmapData == NULL || rxMmapData->memoryAddress == NULL
691 || rxMmapData->totalBufferFrames <= 0);
692 if (ret) {
693 AUDIO_DRIVER_LOG_ERR("param is invalid.");
694 return HDF_ERR_INVALID_PARAM;
695 }
696
697 data = PlatformDataFromCard(card);
698 if (data == NULL) {
699 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
700 return HDF_FAILURE;
701 }
702
703 ret = AudioMmapReadTransfer(card, rxMmapData);
704 if (ret) {
705 AUDIO_DRIVER_LOG_ERR("AudioMmapReadTransfer fail.");
706 return HDF_ERR_INVALID_PARAM;
707 }
708
709 AUDIO_DRIVER_LOG_DEBUG("success.");
710 return HDF_SUCCESS;
711 }
712
AudioRenderBuffInit(struct PlatformData * platformData)713 static int32_t AudioRenderBuffInit(struct PlatformData *platformData)
714 {
715 int32_t ret;
716
717 if (platformData == NULL) {
718 AUDIO_DRIVER_LOG_ERR("input para is NULL.");
719 return HDF_FAILURE;
720 }
721
722 if (platformData->renderBufInfo.virtAddr != NULL) {
723 return HDF_SUCCESS;
724 }
725
726 platformData->renderBufInfo.cirBufMax = MAX_BUFF_SIZE;
727 platformData->renderBufInfo.phyAddr = 0;
728
729 ret = AudioDmaBufAlloc(platformData, AUDIO_RENDER_STREAM);
730 if (ret != HDF_SUCCESS) {
731 AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
732 return HDF_FAILURE;
733 }
734
735 if (platformData->renderBufInfo.virtAddr == NULL) {
736 AUDIO_DRIVER_LOG_ERR("mem alloc failed.");
737 return HDF_FAILURE;
738 }
739
740 (void)memset_s(platformData->renderBufInfo.virtAddr, platformData->renderBufInfo.cirBufMax,
741 0, platformData->renderBufInfo.cirBufMax);
742
743 return HDF_SUCCESS;
744 }
745
AudioRenderBuffFree(struct PlatformData * platformData)746 static int32_t AudioRenderBuffFree(struct PlatformData *platformData)
747 {
748 int32_t ret;
749
750 if (platformData == NULL) {
751 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
752 return HDF_FAILURE;
753 }
754
755 ret = AudioDmaBufFree(platformData, AUDIO_RENDER_STREAM);
756 if (ret) {
757 AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
758 return HDF_FAILURE;
759 }
760
761 platformData->renderBufInfo.virtAddr = NULL;
762 platformData->renderBufInfo.phyAddr = 0;
763 return HDF_SUCCESS;
764 }
765
AudioCaptureBuffInit(struct PlatformData * platformData)766 static int32_t AudioCaptureBuffInit(struct PlatformData *platformData)
767 {
768 int32_t ret;
769
770 if (platformData == NULL) {
771 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
772 return HDF_FAILURE;
773 }
774 if (platformData->captureBufInfo.virtAddr != NULL) {
775 return HDF_SUCCESS;
776 }
777
778 platformData->captureBufInfo.cirBufMax = MAX_BUFF_SIZE;
779 platformData->captureBufInfo.phyAddr = 0;
780
781 ret = AudioDmaBufAlloc(platformData, AUDIO_CAPTURE_STREAM);
782 if (ret) {
783 AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
784 return HDF_FAILURE;
785 }
786
787 if (platformData->captureBufInfo.virtAddr == NULL) {
788 AUDIO_DRIVER_LOG_ERR("mem alloc failed.");
789 return HDF_FAILURE;
790 }
791
792 (void)memset_s(platformData->captureBufInfo.virtAddr, platformData->captureBufInfo.cirBufMax, 0,
793 platformData->captureBufInfo.cirBufMax);
794
795 return HDF_SUCCESS;
796 }
797
AudioCaptureBuffFree(struct PlatformData * platformData)798 static int32_t AudioCaptureBuffFree(struct PlatformData *platformData)
799 {
800 int32_t ret;
801
802 if (platformData == NULL) {
803 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
804 return HDF_FAILURE;
805 }
806
807 ret = AudioDmaBufFree(platformData, AUDIO_CAPTURE_STREAM);
808 if (ret != HDF_SUCCESS) {
809 AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail.");
810 return HDF_FAILURE;
811 }
812
813 platformData->captureBufInfo.virtAddr = NULL;
814 platformData->captureBufInfo.phyAddr = 0;
815 return HDF_SUCCESS;
816 }
817
AudioRenderOpen(const struct AudioCard * card)818 int32_t AudioRenderOpen(const struct AudioCard *card)
819 {
820 struct PlatformData *data = PlatformDataFromCard(card);
821 if (data == NULL) {
822 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
823 return HDF_FAILURE;
824 }
825
826 if (data->renderBufInfo.virtAddr == NULL) {
827 if (AudioRenderBuffInit(data) != HDF_SUCCESS) {
828 return HDF_FAILURE;
829 }
830 }
831 return HDF_SUCCESS;
832 }
833
AudioRenderClose(const struct AudioCard * card)834 int32_t AudioRenderClose(const struct AudioCard *card)
835 {
836 struct PlatformData *data = PlatformDataFromCard(card);
837 if (data == NULL) {
838 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
839 return HDF_FAILURE;
840 }
841
842 return AudioRenderBuffFree(data);
843 }
844
AudioCaptureOpen(const struct AudioCard * card)845 int32_t AudioCaptureOpen(const struct AudioCard *card)
846 {
847 struct PlatformData *platformData;
848 if (card == NULL) {
849 AUDIO_DRIVER_LOG_ERR("capture open param card is NULL.");
850 return HDF_FAILURE;
851 }
852
853 platformData = PlatformDataFromCard(card);
854 if (platformData == NULL) {
855 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
856 return HDF_FAILURE;
857 }
858
859 if (platformData->captureBufInfo.virtAddr == NULL) {
860 if (AudioCaptureBuffInit(platformData) != HDF_SUCCESS) {
861 AUDIO_DRIVER_LOG_ERR("AudioCaptureBuffInit: fail.");
862 return HDF_FAILURE;
863 }
864 }
865 return HDF_SUCCESS;
866 }
867
AudioCaptureClose(const struct AudioCard * card)868 int32_t AudioCaptureClose(const struct AudioCard *card)
869 {
870 struct PlatformData *platformData;
871 if (card == NULL) {
872 AUDIO_DRIVER_LOG_ERR("capture close param card is NULL.");
873 return HDF_FAILURE;
874 }
875
876 platformData = PlatformDataFromCard(card);
877 if (platformData == NULL) {
878 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
879 return HDF_FAILURE;
880 }
881 return AudioCaptureBuffFree(platformData);
882 }
883
AudioPcmPending(struct AudioCard * card,enum AudioStreamType streamType)884 static int32_t AudioPcmPending(struct AudioCard *card, enum AudioStreamType streamType)
885 {
886 struct PlatformData *data = PlatformDataFromCard(card);
887 if (data == NULL) {
888 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
889 return HDF_FAILURE;
890 }
891
892 if (AudioDmaSubmit(data, streamType) != HDF_SUCCESS) {
893 AUDIO_DRIVER_LOG_ERR("DmaPending fail.");
894 return HDF_FAILURE;
895 }
896
897 if (AudioDmaPending(data, streamType) != HDF_SUCCESS) {
898 AUDIO_DRIVER_LOG_ERR("DmaPending fail.");
899 return HDF_FAILURE;
900 }
901
902 if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) {
903 return HDF_FAILURE;
904 }
905 return HDF_SUCCESS;
906 }
907
AudioPcmPause(struct AudioCard * card,enum AudioStreamType streamType)908 static int32_t AudioPcmPause(struct AudioCard *card, enum AudioStreamType streamType)
909 {
910 struct PlatformData *data = PlatformDataFromCard(card);
911 if (data == NULL) {
912 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
913 return HDF_FAILURE;
914 }
915
916 if (AudioDmaPause(data, streamType) != HDF_SUCCESS) {
917 AUDIO_DRIVER_LOG_ERR("DmaPause fail.");
918 return HDF_FAILURE;
919 }
920
921 if (AudioSampSetPowerMonitor(card, true) != HDF_SUCCESS) {
922 return HDF_FAILURE;
923 }
924
925 return HDF_SUCCESS;
926 }
927
AudioPcmResume(struct AudioCard * card,enum AudioStreamType streamType)928 static int32_t AudioPcmResume(struct AudioCard *card, enum AudioStreamType streamType)
929 {
930 struct PlatformData *data = PlatformDataFromCard(card);
931 if (data == NULL) {
932 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
933 return HDF_FAILURE;
934 }
935
936 if (AudioDmaResume(data, streamType) != HDF_SUCCESS) {
937 AUDIO_DRIVER_LOG_ERR("DmaPause fail.");
938 return HDF_FAILURE;
939 }
940
941 if (AudioSampPowerUp(card) != HDF_SUCCESS) {
942 return HDF_FAILURE;
943 }
944 if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) {
945 return HDF_FAILURE;
946 }
947
948 return HDF_SUCCESS;
949 }
950
AudioRenderTrigger(struct AudioCard * card,int32_t cmd)951 int32_t AudioRenderTrigger(struct AudioCard *card, int32_t cmd)
952 {
953 struct PlatformData *data = PlatformDataFromCard(card);
954 if (data == NULL) {
955 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
956 return HDF_FAILURE;
957 }
958 switch (cmd) {
959 case AUDIO_DRV_PCM_IOCTL_RENDER_START:
960 if (AudioPcmPending(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
961 AUDIO_DRIVER_LOG_ERR("AudioPcmPending fail.");
962 return HDF_FAILURE;
963 }
964
965 data->renderBufInfo.runStatus = PCM_START;
966 break;
967 case AUDIO_DRV_PCM_IOCTL_RENDER_STOP:
968 if (AudioPcmPause(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
969 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
970 return HDF_FAILURE;
971 }
972
973 data->renderBufInfo.runStatus = PCM_STOP;
974 break;
975 case AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE:
976 if (AudioPcmPause(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
977 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
978 return HDF_FAILURE;
979 }
980
981 data->renderBufInfo.runStatus = PCM_PAUSE;
982 break;
983 case AUDIO_DRV_PCM_IOCTL_RENDER_RESUME:
984 if (AudioPcmResume(card, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
985 AUDIO_DRIVER_LOG_ERR("AudioPcmResume fail.");
986 return HDF_FAILURE;
987 }
988
989 data->renderBufInfo.runStatus = PCM_START;
990 break;
991 default:
992 AUDIO_DRIVER_LOG_ERR("invalude cmd id: %d.", cmd);
993 return HDF_FAILURE;
994 }
995 return HDF_SUCCESS;
996 }
997
AudioCaptureTrigger(struct AudioCard * card,int32_t cmd)998 int32_t AudioCaptureTrigger(struct AudioCard *card, int32_t cmd)
999 {
1000 struct PlatformData *data = PlatformDataFromCard(card);
1001 if (data == NULL) {
1002 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
1003 return HDF_FAILURE;
1004 }
1005
1006 switch (cmd) {
1007 case AUDIO_DRV_PCM_IOCTL_CAPTURE_START:
1008 if (AudioPcmPending(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1009 AUDIO_DRIVER_LOG_ERR("AudioPcmPending fail.");
1010 return HDF_FAILURE;
1011 }
1012
1013 data->captureBufInfo.runStatus = PCM_START;
1014 break;
1015 case AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP:
1016 if (AudioPcmPause(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1017 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
1018 return HDF_FAILURE;
1019 }
1020
1021 data->captureBufInfo.runStatus = PCM_STOP;
1022 break;
1023 case AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE:
1024 if (AudioPcmPause(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1025 AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail.");
1026 return HDF_FAILURE;
1027 }
1028
1029 data->captureBufInfo.runStatus = PCM_PAUSE;
1030 break;
1031 case AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME:
1032 if (AudioPcmResume(card, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1033 AUDIO_DRIVER_LOG_ERR("AudioPcmResume fail.");
1034 return HDF_FAILURE;
1035 }
1036
1037 data->captureBufInfo.runStatus = PCM_START;
1038 break;
1039 default:
1040 AUDIO_DRIVER_LOG_ERR("invalude cmd id: %d.", cmd);
1041 return HDF_FAILURE;
1042 }
1043 return HDF_SUCCESS;
1044 }
1045
AudioDmaConfig(struct PlatformData * data,enum AudioStreamType streamType)1046 static int32_t AudioDmaConfig(struct PlatformData *data, enum AudioStreamType streamType)
1047 {
1048 int32_t ret;
1049 if (data == NULL) {
1050 AUDIO_DRIVER_LOG_ERR("platform is invalid.");
1051 return HDF_ERR_INVALID_PARAM;
1052 }
1053
1054 if (streamType == AUDIO_RENDER_STREAM) {
1055 if (data->renderBufInfo.virtAddr == NULL) {
1056 AUDIO_DRIVER_LOG_ERR("render buff is NULL.");
1057 return HDF_FAILURE;
1058 }
1059 (void)memset_s(data->renderBufInfo.virtAddr, data->renderBufInfo.cirBufSize, 0,
1060 data->renderBufInfo.cirBufSize);
1061 data->renderBufInfo.wbufOffSet = 0;
1062 data->renderBufInfo.wptrOffSet = 0;
1063 data->renderBufInfo.framesPosition = 0;
1064 data->renderBufInfo.pointer = 0;
1065 data->renderPcmInfo.totalStreamSize = 0;
1066
1067 ret = AudioDmaConfigChannel(data, AUDIO_RENDER_STREAM);
1068 if (ret) {
1069 AUDIO_DRIVER_LOG_ERR("Dma Config Channel fail.");
1070 return HDF_FAILURE;
1071 }
1072 } else if (streamType == AUDIO_CAPTURE_STREAM) {
1073 if (data->captureBufInfo.virtAddr == NULL) {
1074 AUDIO_DRIVER_LOG_ERR("capture buff is NULL.");
1075 return HDF_FAILURE;
1076 }
1077 (void)memset_s(data->captureBufInfo.virtAddr, data->captureBufInfo.cirBufSize, 0,
1078 data->captureBufInfo.cirBufSize);
1079 data->captureBufInfo.rbufOffSet = 0;
1080 data->captureBufInfo.rptrOffSet = 0;
1081 data->captureBufInfo.chnId = 0;
1082 data->captureBufInfo.framesPosition = 0;
1083 data->captureBufInfo.pointer = 0;
1084 data->capturePcmInfo.totalStreamSize = 0;
1085
1086 ret = AudioDmaConfigChannel(data, AUDIO_CAPTURE_STREAM);
1087 if (ret) {
1088 AUDIO_DRIVER_LOG_ERR("Dma Config Channel fail.");
1089 return HDF_FAILURE;
1090 }
1091 } else {
1092 AUDIO_DRIVER_LOG_ERR("streamType(%d) is invalid.", streamType);
1093 return HDF_FAILURE;
1094 }
1095 return HDF_SUCCESS;
1096 }
1097
AudioPcmTransferBytes(struct PlatformData * data,enum AudioStreamType streamType)1098 static int32_t AudioPcmTransferBytes(struct PlatformData *data, enum AudioStreamType streamType)
1099 {
1100 if (data == NULL) {
1101 AUDIO_DRIVER_LOG_ERR("param is NULL.");
1102 return HDF_ERR_INVALID_PARAM;
1103 }
1104
1105 if (streamType == AUDIO_RENDER_STREAM) {
1106 data->renderBufInfo.oneMsBytes = data->renderPcmInfo.rate * data->renderPcmInfo.frameSize
1107 / SECOND_TO_MILLISECOND;
1108 if (data->renderBufInfo.oneMsBytes == 0) {
1109 AUDIO_DRIVER_LOG_ERR("render pcm info is error.");
1110 return HDF_FAILURE;
1111 }
1112 AUDIO_DRIVER_LOG_DEBUG("render pcm one ms transfer bytes is %d .", data->renderBufInfo.oneMsBytes);
1113 } else if (streamType == AUDIO_CAPTURE_STREAM) {
1114 data->captureBufInfo.oneMsBytes = data->capturePcmInfo.rate * data->capturePcmInfo.frameSize
1115 / SECOND_TO_MILLISECOND;
1116 if (data->captureBufInfo.oneMsBytes == 0) {
1117 AUDIO_DRIVER_LOG_ERR("capture pcm info is error.");
1118 return HDF_FAILURE;
1119 }
1120 AUDIO_DRIVER_LOG_DEBUG("capture pcm one ms transfer bytes is %d .", data->captureBufInfo.oneMsBytes);
1121 } else {
1122 AUDIO_DRIVER_LOG_ERR("streamType(%d) is invalid.", streamType);
1123 return HDF_FAILURE;
1124 }
1125
1126 return HDF_SUCCESS;
1127 }
1128
AudioSetRenderHwParams(const struct AudioPcmHwParams * param,struct PlatformData * data)1129 static int32_t AudioSetRenderHwParams(const struct AudioPcmHwParams *param, struct PlatformData *data)
1130 {
1131 if (param == NULL || data == NULL) {
1132 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
1133 return HDF_ERR_INVALID_PARAM;
1134 }
1135
1136 if (AudioDmaRequestChannel(data, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1137 AUDIO_DRIVER_LOG_ERR("Dma Request Channel fail.");
1138 return HDF_FAILURE;
1139 }
1140
1141 if (AudioSetRenderBufInfo(data, param) != HDF_SUCCESS) {
1142 return HDF_FAILURE;
1143 }
1144
1145 if (AudioDmaConfig(data, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1146 return HDF_FAILURE;
1147 }
1148
1149 if (AudioPcmTransferBytes(data, AUDIO_RENDER_STREAM) != HDF_SUCCESS) {
1150 return HDF_FAILURE;
1151 }
1152
1153 return HDF_SUCCESS;
1154 }
1155
AudioSetCaptureHwParams(const struct AudioPcmHwParams * param,struct PlatformData * data)1156 static int32_t AudioSetCaptureHwParams(const struct AudioPcmHwParams *param, struct PlatformData *data)
1157 {
1158 if (param == NULL || data == NULL) {
1159 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
1160 return HDF_ERR_INVALID_PARAM;
1161 }
1162
1163 if (AudioDmaRequestChannel(data, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1164 AUDIO_DRIVER_LOG_ERR("Dma Request Channel fail.");
1165 return HDF_FAILURE;
1166 }
1167
1168 if (AudioSetCaptureBufInfo(data, param) != HDF_SUCCESS) {
1169 return HDF_FAILURE;
1170 }
1171
1172 if (AudioDmaConfig(data, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1173 return HDF_FAILURE;
1174 }
1175
1176 if (AudioPcmTransferBytes(data, AUDIO_CAPTURE_STREAM) != HDF_SUCCESS) {
1177 return HDF_FAILURE;
1178 }
1179
1180 return HDF_SUCCESS;
1181 }
1182
1183
AudioHwParams(const struct AudioCard * card,const struct AudioPcmHwParams * param)1184 int32_t AudioHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param)
1185 {
1186 const int32_t chnlCntMin = 1;
1187 const int32_t chnlCntMax = 2;
1188 struct PlatformData *platformData;
1189 if (card == NULL || param == NULL || param->cardServiceName == NULL) {
1190 AUDIO_DRIVER_LOG_ERR("input param is NULL.");
1191 return HDF_ERR_INVALID_PARAM;
1192 }
1193
1194 if (param->channels < chnlCntMin || param->channels > chnlCntMax) {
1195 AUDIO_DRIVER_LOG_ERR("channels param is invalid.");
1196 return HDF_FAILURE;
1197 }
1198
1199 platformData = PlatformDataFromCard(card);
1200 if (platformData == NULL) {
1201 AUDIO_DRIVER_LOG_ERR("platformData is null.");
1202 return HDF_FAILURE;
1203 }
1204
1205 if (AudioSetPcmInfo(platformData, param) != HDF_SUCCESS) {
1206 return HDF_FAILURE;
1207 }
1208
1209 if (param->streamType == AUDIO_RENDER_STREAM) {
1210 if (AudioSetRenderHwParams(param, platformData) != HDF_SUCCESS) {
1211 AUDIO_DRIVER_LOG_ERR("set render hardware params is failed.");
1212 return HDF_FAILURE;
1213 }
1214 } else if (param->streamType == AUDIO_CAPTURE_STREAM) {
1215 if (AudioSetCaptureHwParams(param, platformData) != HDF_SUCCESS) {
1216 AUDIO_DRIVER_LOG_ERR("set capture hardware params is failed.");
1217 return HDF_FAILURE;
1218 }
1219 } else {
1220 AUDIO_DRIVER_LOG_ERR("param streamType is invalid.");
1221 return HDF_FAILURE;
1222 }
1223
1224 return HDF_SUCCESS;
1225 }
1226
AudioRenderPrepare(const struct AudioCard * card)1227 int32_t AudioRenderPrepare(const struct AudioCard *card)
1228 {
1229 int32_t ret;
1230 struct PlatformData *platformData;
1231 if (card == NULL) {
1232 AUDIO_DRIVER_LOG_ERR("audio render param card is NULL.");
1233 return HDF_ERR_INVALID_PARAM;
1234 }
1235
1236 platformData = PlatformDataFromCard(card);
1237 if (platformData == NULL) {
1238 AUDIO_DRIVER_LOG_ERR("audio render PlatformDataFromCard failed.");
1239 return HDF_FAILURE;
1240 }
1241
1242 ret = AudioDmaPrep(platformData, AUDIO_RENDER_STREAM);
1243 if (ret) {
1244 AUDIO_DRIVER_LOG_ERR("Dma prepare fail.");
1245 return HDF_FAILURE;
1246 }
1247
1248 return HDF_SUCCESS;
1249 }
1250
AudioCapturePrepare(const struct AudioCard * card)1251 int32_t AudioCapturePrepare(const struct AudioCard *card)
1252 {
1253 int32_t ret;
1254 struct PlatformData *platformData;
1255 if (card == NULL) {
1256 AUDIO_DRIVER_LOG_ERR("audio capture param card is NULL.");
1257 return HDF_ERR_INVALID_PARAM;
1258 }
1259
1260 platformData = PlatformDataFromCard(card);
1261 if (platformData == NULL) {
1262 AUDIO_DRIVER_LOG_ERR("audio capture PlatformDataFromCard failed.");
1263 return HDF_FAILURE;
1264 }
1265
1266 ret = AudioDmaPrep(platformData, AUDIO_CAPTURE_STREAM);
1267 if (ret) {
1268 AUDIO_DRIVER_LOG_ERR("Dma prepare fail.");
1269 return HDF_FAILURE;
1270 }
1271
1272 return HDF_SUCCESS;
1273 }
1274
AudioPcmPointer(const struct AudioCard * card,uint32_t * pointer,enum AudioStreamType streamType)1275 int32_t AudioPcmPointer(const struct AudioCard *card, uint32_t *pointer, enum AudioStreamType streamType)
1276 {
1277 int32_t ret;
1278 struct PlatformData *data;
1279 if (card == NULL || pointer == NULL) {
1280 AUDIO_DRIVER_LOG_ERR("param card is NULL.");
1281 return HDF_ERR_INVALID_PARAM;
1282 }
1283
1284 data = PlatformDataFromCard(card);
1285 if (data == NULL) {
1286 AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed.");
1287 return HDF_FAILURE;
1288 }
1289
1290 ret = AudioDmaPointer(data, streamType, pointer);
1291 if (ret != HDF_SUCCESS) {
1292 AUDIO_DRIVER_LOG_ERR("Dma Pointer fail.");
1293 return HDF_FAILURE;
1294 }
1295
1296 return HDF_SUCCESS;
1297 }
1298
AudioCapSilenceThresholdEvent(struct HdfDeviceObject * device,const struct AudioEvent * reportMsg)1299 int32_t AudioCapSilenceThresholdEvent(struct HdfDeviceObject *device, const struct AudioEvent *reportMsg)
1300 {
1301 int32_t ret;
1302 char msgBuf[AUDIO_PNP_MSG_LEN] = {0};
1303
1304 if (device == NULL || reportMsg == NULL) {
1305 ADM_LOG_ERR("device is NULL!");
1306 return HDF_ERR_INVALID_PARAM;
1307 }
1308
1309 ret = snprintf_s(msgBuf, AUDIO_PNP_MSG_LEN, AUDIO_PNP_MSG_LEN - 1,
1310 "EVENT_TYPE=0x%x;DEVICE_TYPE=0x%x", reportMsg->eventType, reportMsg->deviceType);
1311 if (ret < 0) {
1312 ADM_LOG_ERR("snprintf_s fail");
1313 return HDF_FAILURE;
1314 }
1315 if (HdfDeviceObjectSetServInfo(device, msgBuf) != HDF_SUCCESS) {
1316 ADM_LOG_ERR("HdfDeviceObjectSetServInfo fail!");
1317 return HDF_FAILURE;
1318 }
1319
1320 ret = HdfDeviceObjectUpdate(device);
1321 if (ret != HDF_SUCCESS) {
1322 ADM_LOG_ERR("HdfDeviceObjectUpdate fail\n");
1323 return HDF_FAILURE;
1324 }
1325
1326 return HDF_SUCCESS;
1327 }
1328
1329