1 /*
2 * Copyright (c) 2006-2021, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2019-07-28 Ernest the first version
9 */
10
11 #include "board.h"
12 #include "drv_wm8978.h"
13 #include "drv_sound.h"
14
15 #define DBG_TAG "drv.sound"
16 #define DBG_LVL DBG_INFO
17 #include <rtdbg.h>
18
19 #define CODEC_I2C_NAME ("i2c1")
20
21 #define TX_DMA_FIFO_SIZE (2048)
22
23 struct drv_sai _sai_a = {0};
24
25 struct stm32_audio
26 {
27 struct rt_i2c_bus_device *i2c_bus;
28 struct rt_audio_device audio;
29 struct rt_audio_configure replay_config;
30 int replay_volume;
31 rt_uint8_t *tx_fifo;
32 rt_bool_t startup;
33 };
34 struct stm32_audio _stm32_audio_play = {0};
35
36 /* sample_rate, PLLI2SN(50.7), PLLI2SQ, PLLI2SDivQ, MCKDIV */
37 const rt_uint32_t SAI_PSC_TBL[][5] =
38 {
39 {AUDIO_FREQUENCY_048K, 206, 7, 0, 12},
40 {AUDIO_FREQUENCY_044K, 257, 2, 18, 2},
41 {AUDIO_FREQUENCY_032K, 206, 7, 0, 6},
42 {AUDIO_FREQUENCY_022K, 257, 2, 18, 1},
43 {AUDIO_FREQUENCY_016K, 206, 7, 0, 3},
44 {AUDIO_FREQUENCY_011K, 257, 2, 18, 0},
45 {AUDIO_FREQUENCY_008K, 206, 7, 0, 2},
46 };
47
SAIA_samplerate_set(rt_uint32_t freq)48 void SAIA_samplerate_set(rt_uint32_t freq)
49 {
50 RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;
51 int i;
52
53 /* check frequence */
54 for (i = 0; i < (sizeof(SAI_PSC_TBL) / sizeof(SAI_PSC_TBL[0])); i++)
55 {
56 if ((freq) == SAI_PSC_TBL[i][0])break;
57 }
58 if (i == (sizeof(SAI_PSC_TBL) / sizeof(SAI_PSC_TBL[0])))
59 {
60 LOG_E("Can not support this frequence: %d.", freq);
61 return;
62 }
63
64 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_SAI_PLLI2S;
65 PeriphClkInitStruct.PLLI2S.PLLI2SN = SAI_PSC_TBL[i][1];
66 PeriphClkInitStruct.PLLI2S.PLLI2SQ = SAI_PSC_TBL[i][2];
67 PeriphClkInitStruct.PLLI2SDivQ = SAI_PSC_TBL[i][3] + 1;
68
69 HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
70
71 __HAL_RCC_SAI_BLOCKACLKSOURCE_CONFIG(RCC_SAIACLKSOURCE_PLLI2S);
72
73 __HAL_SAI_DISABLE(&_sai_a.hsai);
74 _sai_a.hsai.Init.AudioFrequency = freq;
75 HAL_SAI_Init(&_sai_a.hsai);
76 __HAL_SAI_ENABLE(&_sai_a.hsai);
77 }
78
SAIA_channels_set(rt_uint16_t channels)79 void SAIA_channels_set(rt_uint16_t channels)
80 {
81 if (channels == 2)
82 {
83 _sai_a.hsai.Init.MonoStereoMode = SAI_STEREOMODE;
84 }
85 else
86 {
87 _sai_a.hsai.Init.MonoStereoMode = SAI_MONOMODE;
88 }
89 __HAL_SAI_DISABLE(&_sai_a.hsai);
90 HAL_SAI_Init(&_sai_a.hsai);
91 __HAL_SAI_ENABLE(&_sai_a.hsai);
92 }
93
SAIA_samplebits_set(rt_uint16_t samplebits)94 void SAIA_samplebits_set(rt_uint16_t samplebits)
95 {
96 switch (samplebits)
97 {
98 case 16:
99 _sai_a.hsai.Init.DataSize = SAI_DATASIZE_16;
100 break;
101 case 24:
102 _sai_a.hsai.Init.DataSize = SAI_DATASIZE_24;
103 break;
104 case 32:
105 _sai_a.hsai.Init.DataSize = SAI_DATASIZE_32;
106 break;
107 default:
108 _sai_a.hsai.Init.DataSize = SAI_DATASIZE_16;
109 break;
110 }
111 __HAL_SAI_DISABLE(&_sai_a.hsai);
112 HAL_SAI_Init(&_sai_a.hsai);
113 __HAL_SAI_ENABLE(&_sai_a.hsai);
114 }
115
SAIA_config_set(struct rt_audio_configure config)116 void SAIA_config_set(struct rt_audio_configure config)
117 {
118 SAIA_channels_set(config.channels);
119 SAIA_samplerate_set(config.samplerate);
120 SAIA_samplebits_set(config.samplebits);
121 }
122
123 /* initial sai A */
SAIA_config_init(void)124 rt_err_t SAIA_config_init(void)
125 {
126 _sai_a.hsai.Instance = SAI1_Block_A;
127 _sai_a.hsai.Init.AudioMode = SAI_MODEMASTER_TX;
128 _sai_a.hsai.Init.Synchro = SAI_ASYNCHRONOUS;
129 _sai_a.hsai.Init.OutputDrive = SAI_OUTPUTDRIVE_ENABLE;
130 _sai_a.hsai.Init.NoDivider = SAI_MASTERDIVIDER_ENABLE;
131 _sai_a.hsai.Init.FIFOThreshold = SAI_FIFOTHRESHOLD_1QF;
132 _sai_a.hsai.Init.ClockSource = SAI_CLKSOURCE_PLLI2S;
133
134 _sai_a.hsai.Init.Protocol = SAI_FREE_PROTOCOL;
135 _sai_a.hsai.Init.DataSize = SAI_DATASIZE_16;
136 _sai_a.hsai.Init.FirstBit = SAI_FIRSTBIT_MSB;
137 _sai_a.hsai.Init.ClockStrobing = SAI_CLOCKSTROBING_RISINGEDGE;
138
139 //frame
140 _sai_a.hsai.FrameInit.FrameLength = 64;
141 _sai_a.hsai.FrameInit.ActiveFrameLength = 32;
142 _sai_a.hsai.FrameInit.FSDefinition = SAI_FS_CHANNEL_IDENTIFICATION;
143 _sai_a.hsai.FrameInit.FSPolarity = SAI_FS_ACTIVE_LOW;
144 _sai_a.hsai.FrameInit.FSOffset = SAI_FS_BEFOREFIRSTBIT;
145
146 //slot
147 _sai_a.hsai.SlotInit.FirstBitOffset = 0;
148 _sai_a.hsai.SlotInit.SlotSize = SAI_SLOTSIZE_32B;
149 _sai_a.hsai.SlotInit.SlotNumber = 2;
150 _sai_a.hsai.SlotInit.SlotActive = SAI_SLOTACTIVE_0 | SAI_SLOTACTIVE_1;
151
152 HAL_SAI_Init(&_sai_a.hsai);
153 __HAL_SAI_ENABLE(&_sai_a.hsai);
154
155 return RT_EOK;
156 }
157
SAIA_tx_dma(void)158 rt_err_t SAIA_tx_dma(void)
159 {
160 __HAL_RCC_DMA2_CLK_ENABLE();
161 __HAL_LINKDMA(&_sai_a.hsai, hdmatx, _sai_a.hdma);
162
163 _sai_a.hdma.Instance = DMA2_Stream3;
164 _sai_a.hdma.Init.Channel = DMA_CHANNEL_0;
165 _sai_a.hdma.Init.Direction = DMA_MEMORY_TO_PERIPH;
166 _sai_a.hdma.Init.PeriphInc = DMA_PINC_DISABLE;
167 _sai_a.hdma.Init.MemInc = DMA_MINC_ENABLE;
168
169 _sai_a.hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
170 _sai_a.hdma.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
171
172 _sai_a.hdma.Init.Mode = DMA_CIRCULAR;
173 _sai_a.hdma.Init.Priority = DMA_PRIORITY_HIGH;
174 _sai_a.hdma.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
175 _sai_a.hdma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
176 _sai_a.hdma.Init.MemBurst = DMA_MBURST_SINGLE;
177 _sai_a.hdma.Init.PeriphBurst = DMA_PBURST_SINGLE;
178
179 HAL_DMA_DeInit(&_sai_a.hdma);
180 HAL_DMA_Init(&_sai_a.hdma);
181
182 __HAL_DMA_DISABLE(&_sai_a.hdma);
183
184 __HAL_DMA_ENABLE_IT(&_sai_a.hdma, DMA_IT_TC);
185 __HAL_DMA_CLEAR_FLAG(&_sai_a.hdma, DMA_FLAG_TCIF3_7);
186 /* set nvic */
187 HAL_NVIC_SetPriority(DMA2_Stream3_IRQn, 5, 0);
188 HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
189 return RT_EOK;
190 }
191
DMA2_Stream3_IRQHandler(void)192 void DMA2_Stream3_IRQHandler(void)
193 {
194 rt_interrupt_enter();
195 HAL_DMA_IRQHandler(_sai_a.hsai.hdmatx);
196 rt_interrupt_leave();
197 }
198
HAL_SAI_TxHalfCpltCallback(SAI_HandleTypeDef * hsai)199 void HAL_SAI_TxHalfCpltCallback(SAI_HandleTypeDef *hsai)
200 {
201 rt_audio_tx_complete(&_stm32_audio_play.audio);
202 }
203
HAL_SAI_TxCpltCallback(SAI_HandleTypeDef * hsai)204 void HAL_SAI_TxCpltCallback(SAI_HandleTypeDef *hsai)
205 {
206 rt_audio_tx_complete(&_stm32_audio_play.audio);
207 }
208
sai_a_init()209 rt_err_t sai_a_init()
210 {
211 /* set sai_a DMA */
212 SAIA_tx_dma();
213 SAIA_config_init();
214
215 return RT_EOK;
216 }
217
stm32_player_getcaps(struct rt_audio_device * audio,struct rt_audio_caps * caps)218 static rt_err_t stm32_player_getcaps(struct rt_audio_device *audio, struct rt_audio_caps *caps)
219 {
220 rt_err_t result = RT_EOK;
221 struct stm32_audio *st_audio = (struct stm32_audio *)audio->parent.user_data;
222
223 LOG_D("%s:main_type: %d, sub_type: %d", __FUNCTION__, caps->main_type, caps->sub_type);
224
225 switch (caps->main_type)
226 {
227 case AUDIO_TYPE_QUERY: /* query the types of hw_codec device */
228 {
229 switch (caps->sub_type)
230 {
231 case AUDIO_TYPE_QUERY:
232 caps->udata.mask = AUDIO_TYPE_OUTPUT | AUDIO_TYPE_MIXER;
233 break;
234
235 default:
236 result = -RT_ERROR;
237 break;
238 }
239
240 break;
241 }
242
243 case AUDIO_TYPE_OUTPUT: /* Provide capabilities of OUTPUT unit */
244 {
245 switch (caps->sub_type)
246 {
247 case AUDIO_DSP_PARAM:
248 caps->udata.config.channels = st_audio->replay_config.channels;
249 caps->udata.config.samplebits = st_audio->replay_config.samplebits;
250 caps->udata.config.samplerate = st_audio->replay_config.samplerate;
251 break;
252
253 case AUDIO_DSP_SAMPLERATE:
254 caps->udata.config.samplerate = st_audio->replay_config.samplerate;
255 break;
256
257 case AUDIO_DSP_CHANNELS:
258 caps->udata.config.channels = st_audio->replay_config.channels;
259 break;
260
261 case AUDIO_DSP_SAMPLEBITS:
262 caps->udata.config.samplebits = st_audio->replay_config.samplebits;
263 break;
264
265 default:
266 result = -RT_ERROR;
267 break;
268 }
269
270 break;
271 }
272
273 case AUDIO_TYPE_MIXER: /* report the Mixer Units */
274 {
275 switch (caps->sub_type)
276 {
277 case AUDIO_MIXER_QUERY:
278 caps->udata.mask = AUDIO_MIXER_VOLUME | AUDIO_MIXER_LINE;
279 break;
280
281 case AUDIO_MIXER_VOLUME:
282 caps->udata.value = st_audio->replay_volume;
283 break;
284
285 case AUDIO_MIXER_LINE:
286 break;
287
288 default:
289 result = -RT_ERROR;
290 break;
291 }
292
293 break;
294 }
295
296 default:
297 result = -RT_ERROR;
298 break;
299 }
300
301 return result;
302 }
303
stm32_player_configure(struct rt_audio_device * audio,struct rt_audio_caps * caps)304 static rt_err_t stm32_player_configure(struct rt_audio_device *audio, struct rt_audio_caps *caps)
305 {
306 rt_err_t result = RT_EOK;
307 struct stm32_audio *st_audio = (struct stm32_audio *)audio->parent.user_data;
308
309 LOG_D("%s:main_type: %d, sub_type: %d", __FUNCTION__, caps->main_type, caps->sub_type);
310
311 switch (caps->main_type)
312 {
313 case AUDIO_TYPE_MIXER:
314 {
315 switch (caps->sub_type)
316 {
317 case AUDIO_MIXER_MUTE:
318 {
319 /* set mute mode */
320 wm8978_mute_enabled(_stm32_audio_play.i2c_bus, RT_FALSE);
321 break;
322 }
323
324 case AUDIO_MIXER_VOLUME:
325 {
326 int volume = caps->udata.value;
327
328 st_audio->replay_volume = volume;
329 /* set mixer volume */
330 wm8978_set_volume(_stm32_audio_play.i2c_bus, volume);
331
332 break;
333 }
334
335 default:
336 result = -RT_ERROR;
337 break;
338 }
339
340 break;
341 }
342
343 case AUDIO_TYPE_OUTPUT:
344 {
345 switch (caps->sub_type)
346 {
347 case AUDIO_DSP_PARAM:
348 {
349 struct rt_audio_configure config = caps->udata.config;
350
351 st_audio->replay_config.samplerate = config.samplerate;
352 st_audio->replay_config.samplebits = config.samplebits;
353 st_audio->replay_config.channels = config.channels;
354
355 SAIA_config_set(config);
356 break;
357 }
358
359 case AUDIO_DSP_SAMPLERATE:
360 {
361 st_audio->replay_config.samplerate = caps->udata.config.samplerate;
362 SAIA_samplerate_set(caps->udata.config.samplerate);
363 break;
364 }
365
366 case AUDIO_DSP_CHANNELS:
367 {
368 st_audio->replay_config.channels = caps->udata.config.channels;
369 SAIA_channels_set(caps->udata.config.channels);
370 break;
371 }
372
373 case AUDIO_DSP_SAMPLEBITS:
374 {
375 st_audio->replay_config.samplebits = caps->udata.config.samplebits;
376 SAIA_samplebits_set(caps->udata.config.samplebits);
377 break;
378 }
379
380 default:
381 result = -RT_ERROR;
382 break;
383 }
384 break;
385 }
386
387 default:
388 break;
389 }
390
391 return result;
392 }
393
stm32_player_init(struct rt_audio_device * audio)394 static rt_err_t stm32_player_init(struct rt_audio_device *audio)
395 {
396 /* initialize wm8978 */
397 _stm32_audio_play.i2c_bus = (struct rt_i2c_bus_device *)rt_device_find(CODEC_I2C_NAME);
398
399 sai_a_init();
400 wm8978_init(_stm32_audio_play.i2c_bus);
401 return RT_EOK;
402 }
403
stm32_player_start(struct rt_audio_device * audio,int stream)404 static rt_err_t stm32_player_start(struct rt_audio_device *audio, int stream)
405 {
406 if (stream == AUDIO_STREAM_REPLAY)
407 {
408 HAL_SAI_Transmit_DMA(&_sai_a.hsai, _stm32_audio_play.tx_fifo, TX_DMA_FIFO_SIZE / 2);
409 wm8978_player_start(_stm32_audio_play.i2c_bus);
410 }
411
412 return RT_EOK;
413 }
414
stm32_player_stop(struct rt_audio_device * audio,int stream)415 static rt_err_t stm32_player_stop(struct rt_audio_device *audio, int stream)
416 {
417 if (stream == AUDIO_STREAM_REPLAY)
418 {
419 HAL_SAI_DMAStop(&_sai_a.hsai);
420 }
421
422 return RT_EOK;
423 }
424
stm32_player_buffer_info(struct rt_audio_device * audio,struct rt_audio_buf_info * info)425 static void stm32_player_buffer_info(struct rt_audio_device *audio, struct rt_audio_buf_info *info)
426 {
427 /**
428 * TX_FIFO
429 * +----------------+----------------+
430 * | block1 | block2 |
431 * +----------------+----------------+
432 * \ block_size /
433 */
434 info->buffer = _stm32_audio_play.tx_fifo;
435 info->total_size = TX_DMA_FIFO_SIZE;
436 info->block_size = TX_DMA_FIFO_SIZE / 2;
437 info->block_count = 2;
438 }
439 static struct rt_audio_ops _p_audio_ops =
440 {
441 .getcaps = stm32_player_getcaps,
442 .configure = stm32_player_configure,
443 .init = stm32_player_init,
444 .start = stm32_player_start,
445 .stop = stm32_player_stop,
446 .transmit = RT_NULL,
447 .buffer_info = stm32_player_buffer_info,
448 };
449
rt_hw_sound_init(void)450 int rt_hw_sound_init(void)
451 {
452 rt_uint8_t *tx_fifo;
453
454 /* player */
455 tx_fifo = rt_malloc(TX_DMA_FIFO_SIZE);
456 if (tx_fifo == RT_NULL)
457 {
458 return -RT_ENOMEM;
459 }
460 rt_memset(tx_fifo, 0, TX_DMA_FIFO_SIZE);
461 _stm32_audio_play.tx_fifo = tx_fifo;
462
463 /* register sound device */
464 _stm32_audio_play.audio.ops = &_p_audio_ops;
465 rt_audio_register(&_stm32_audio_play.audio, "sound0", RT_DEVICE_FLAG_WRONLY, &_stm32_audio_play);
466
467 return RT_EOK;
468 }
469
470 INIT_DEVICE_EXPORT(rt_hw_sound_init);
471