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