1 /*
2 * Copyright (c) 2020-2021, Bluetrum Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Date Author Notes
7 * 2020-12-12 greedyhao first implementation
8 */
9
10 #include <board.h>
11
12 #define DBG_TAG "drv.snd_dev"
13 #define DBG_LVL DBG_INFO
14 #include <rtdbg.h>
15
16 #define SAI_AUDIO_FREQUENCY_48K ((uint32_t)48000u)
17 #define SAI_AUDIO_FREQUENCY_44K ((uint32_t)44100u)
18 #define SAI_AUDIO_FREQUENCY_38K ((uint32_t)38000u)
19 #define TX_FIFO_SIZE (1024)
20
21 struct sound_device
22 {
23 struct rt_audio_device audio;
24 struct rt_audio_configure replay_config;
25 rt_sem_t semaphore;
26 rt_thread_t thread;
27 rt_uint8_t *tx_fifo;
28 rt_uint8_t *rx_fifo;
29 rt_uint8_t volume;
30 rt_uint8_t dma_to_aubuf;
31 };
32
33 static struct sound_device snd_dev = {0};
34
35 //apll = 采样率*ADPLL_DIV*512
36 //audio pll init
adpll_init(uint8_t out_spr)37 void adpll_init(uint8_t out_spr)
38 {
39 PLL1CON &= ~(BIT(16) | BIT(17)); //PLL1 refclk select xosc26m
40 CLKCON2 &= ~(BIT(4)| BIT(5) | BIT(6) | BIT(7));
41
42 PLL1CON &= ~(BIT(3) | BIT(4) | BIT(5));
43 PLL1CON |= BIT(3); //Select PLL/VCO frequency band (PLL大于206M vcos = 0x01, 否则为0)
44
45 PLL1CON |= BIT(12); //enable pll1 ldo
46 hal_mdelay(1);
47 PLL1CON |= BIT(18); //pll1 sdm enable
48
49 if (out_spr) {
50 CLKCON2 |= BIT(4) | BIT(7); //adpll_div = 10
51 PLL1DIV = (245.76 * 65536) / 26; //245.76Mhz for 48K
52 // sys.aupll_type = 1;
53 } else {
54 CLKCON2 |= BIT(5) | BIT(7); //adpll_div = 11
55 PLL1DIV = (248.3712 * 65536) / 26; //248.3712MHz for 44.1k
56 // sys.aupll_type = 0;
57 }
58 hal_mdelay(1);
59 PLL1CON |= BIT(20); //update pll1div
60 PLL1CON |= BIT(6); //enable analog pll1
61 hal_mdelay(1); //wait pll1 stable
62 }
63
dac_start(void)64 void dac_start(void)
65 {
66 AUANGCON0 |= BIT(0) | BIT(1) | BIT(3); // bg ldoh bias enable
67
68 AUANGCON0 &= ~(BIT(6)|BIT(5)|BIT(4)); // LDOH voltage select：3bit
69 AUANGCON0 |= (3<<4); // 2.4/2.5/2.7/2.9/3.1/3.2
70
71 AUANGCON0 |= BIT(2); // LDOL enable
72
73 AUANGCON0 |= BIT(9); //VCM enable
74 AUANGCON0 &= ~(BIT(13)|BIT(12)); // VCM voltage select, 2bit
75 AUANGCON0 |= (2<<12);
76
77 AUANGCON0 |= BIT(15) | BIT(16) | BIT(17) | BIT(18); // d2a lpf audpa audpa_dly
78
79 AUANGCON0 &= ~BIT(11); //VCM type: 0-->res divider with off-chip cap; 1-->internal VCM
80 //AUANGCON0 |= BIT(11);
81
82 AUANGCON0 &= ~BIT(19); // dac type: 0-->SC; 1-->SR
83 //AUANGCON0 |= BIT(19);
84
85 AUANGCON0 |= BIT(20); // pa type: 0-->diff; 1-->3.3V single
86
87 AUANGCON3 &= ~(0x7<<4); //BIT[6:4]=PA_GF[2:0]
88 AUANGCON3 |= (0<<4);
89 AUANGCON3 &= ~(0xf); //BIT[3:0]=PA_GX[3:0]
90 AUANGCON3 |= 0;
91
92 AUANGCON3 &= ~(0xF<<8); //BIT[11:8]=PA2_GX[3:0]
93 AUANGCON3 |= (0<<8);
94 AUANGCON3 &= ~(0x7<<12); //BIT[14:12]=PA2_GF[2:0]
95 AUANGCON3 |= (0<<12);
96
97 AUANGCON1 |= BIT(0) | BIT(1); // dac enable: BIT(0)-->right channel; BIT(1)-->left channel
98 //AUANGCON1 &= ~BIT(1); //disable left channel
99
100 AUANGCON1 |= BIT(12); // lpf2pa enable
101
102 AUANGCON1 &= ~BIT(29); // vcmbuf enable: 0-->disable
103 //AUANGCON1 |= BIT(29);
104
105 //AUANGCON1 |= BIT(30); // mirror enable
106
107 //AUANGCON2 |= BIT(29) | BIT(30); // adc mute
108
109 //AUANGCON1 |= BIT(3); // pa mute
110 }
111
112 rt_section(".irq.audio")
audio_sem_post(void)113 void audio_sem_post(void)
114 {
115 rt_sem_release(snd_dev.semaphore);
116 }
117
audio_sem_pend(void)118 void audio_sem_pend(void)
119 {
120 rt_sem_take(snd_dev.semaphore, RT_WAITING_FOREVER);
121 }
122
saia_frequency_set(uint32_t frequency)123 void saia_frequency_set(uint32_t frequency)
124 {
125 DACDIGCON0 &= ~(0xf << 2);
126 if (frequency == SAI_AUDIO_FREQUENCY_48K) {
127 DACDIGCON0 |= (0 << 2);
128 } else if (frequency == SAI_AUDIO_FREQUENCY_44K) {
129 DACDIGCON0 |= (1 << 2);
130 } else if (frequency == SAI_AUDIO_FREQUENCY_38K) {
131 DACDIGCON0 |= (2 << 2);
132 }
133 DACDIGCON0 |= BIT(6);
134 }
135
saia_channels_set(uint8_t channels)136 void saia_channels_set(uint8_t channels)
137 {
138 LOG_D("saia_channels_set=%d", channels);
139 if (channels == 1) {
140 AU0LMIXCOEF = 0x00007FFF;
141 AU1LMIXCOEF = 0x00007FFF;
142 DACDIGCON0 |= BIT(7);
143 DACDIGCON0 |= BIT(8);
144 AUANGCON1 &= ~BIT(0);
145 } else {
146 AUANGCON1 |= BIT(0);
147 DACDIGCON0 &= ~BIT(7);
148 DACDIGCON0 &= ~BIT(8);
149 }
150 }
151
saia_volume_set(rt_uint8_t volume)152 void saia_volume_set(rt_uint8_t volume)
153 {
154 if (volume > 100)
155 volume = 100;
156
157 uint32_t dvol = volume * 327; // max is 0x7ffff
158 LOG_D("dvol=0x%x", dvol);
159 DACVOLCON = dvol | (0x02 << 16); // dac fade in
160 }
161
saia_volume_get(void)162 uint8_t saia_volume_get(void)
163 {
164 return ((DACVOLCON & 0xffff) / 327);
165 }
166
sound_getcaps(struct rt_audio_device * audio,struct rt_audio_caps * caps)167 static rt_err_t sound_getcaps(struct rt_audio_device *audio, struct rt_audio_caps *caps)
168 {
169 rt_err_t result = RT_EOK;
170 struct sound_device *snd_dev = RT_NULL;
171
172 RT_ASSERT(audio != RT_NULL);
173 snd_dev = (struct sound_device *)audio->parent.user_data;
174
175 switch (caps->main_type)
176 {
177 case AUDIO_TYPE_QUERY: /* qurey the types of hw_codec device */
178 {
179 switch (caps->sub_type)
180 {
181 case AUDIO_TYPE_QUERY:
182 caps->udata.mask = AUDIO_TYPE_OUTPUT | AUDIO_TYPE_MIXER;
183 break;
184
185 default:
186 result = -RT_ERROR;
187 break;
188 }
189
190 break;
191 }
192
193 case AUDIO_TYPE_OUTPUT: /* Provide capabilities of OUTPUT unit */
194 {
195 switch (caps->sub_type)
196 {
197 case AUDIO_DSP_PARAM:
198 caps->udata.config.samplerate = snd_dev->replay_config.samplerate;
199 caps->udata.config.channels = snd_dev->replay_config.channels;
200 caps->udata.config.samplebits = snd_dev->replay_config.samplebits;
201 break;
202
203 case AUDIO_DSP_SAMPLERATE:
204 caps->udata.config.samplerate = snd_dev->replay_config.samplerate;
205 break;
206
207 case AUDIO_DSP_CHANNELS:
208 caps->udata.config.channels = snd_dev->replay_config.channels;
209 break;
210
211 case AUDIO_DSP_SAMPLEBITS:
212 caps->udata.config.samplebits = snd_dev->replay_config.samplebits;
213 break;
214
215 default:
216 result = -RT_ERROR;
217 break;
218 }
219
220 break;
221 }
222
223 case AUDIO_TYPE_MIXER: /* report the Mixer Units */
224 {
225 switch (caps->sub_type)
226 {
227 case AUDIO_MIXER_QUERY:
228 caps->udata.mask = AUDIO_MIXER_VOLUME;
229 break;
230
231 case AUDIO_MIXER_VOLUME:
232 caps->udata.value = saia_volume_get();
233 break;
234
235 default:
236 result = -RT_ERROR;
237 break;
238 }
239
240 break;
241 }
242
243 default:
244 result = -RT_ERROR;
245 break;
246 }
247
248 return RT_EOK;
249 }
250
sound_configure(struct rt_audio_device * audio,struct rt_audio_caps * caps)251 static rt_err_t sound_configure(struct rt_audio_device *audio, struct rt_audio_caps *caps)
252 {
253 rt_err_t result = RT_EOK;
254 struct sound_device *snd_dev = RT_NULL;
255
256 RT_ASSERT(audio != RT_NULL);
257 snd_dev = (struct sound_device *)audio->parent.user_data;
258
259 switch (caps->main_type)
260 {
261 case AUDIO_TYPE_MIXER:
262 {
263 switch (caps->sub_type)
264 {
265 case AUDIO_MIXER_VOLUME:
266 {
267 rt_uint8_t volume = caps->udata.value;
268
269 saia_volume_set(volume);
270 snd_dev->volume = volume;
271 LOG_D("set volume %d", volume);
272 break;
273 }
274
275 case AUDIO_MIXER_EXTEND:
276 snd_dev->dma_to_aubuf = caps->udata.value;
277 break;
278
279 default:
280 result = -RT_ERROR;
281 break;
282 }
283
284 break;
285 }
286
287 case AUDIO_TYPE_OUTPUT:
288 {
289 switch (caps->sub_type)
290 {
291 case AUDIO_DSP_PARAM:
292 {
293 /* set samplerate */
294 saia_frequency_set(caps->udata.config.samplerate);
295 /* set channels */
296 saia_channels_set(caps->udata.config.channels);
297
298 /* save configs */
299 snd_dev->replay_config.samplerate = caps->udata.config.samplerate;
300 snd_dev->replay_config.channels = caps->udata.config.channels;
301 snd_dev->replay_config.samplebits = caps->udata.config.samplebits;
302 LOG_D("set samplerate %d", snd_dev->replay_config.samplerate);
303 break;
304 }
305
306 case AUDIO_DSP_SAMPLERATE:
307 {
308 saia_frequency_set(caps->udata.config.samplerate);
309 snd_dev->replay_config.samplerate = caps->udata.config.samplerate;
310 LOG_D("set samplerate %d", snd_dev->replay_config.samplerate);
311 break;
312 }
313
314 case AUDIO_DSP_CHANNELS:
315 {
316 saia_channels_set(caps->udata.config.channels);
317 snd_dev->replay_config.channels = caps->udata.config.channels;
318 LOG_D("set channels %d", snd_dev->replay_config.channels);
319 break;
320 }
321
322 case AUDIO_DSP_SAMPLEBITS:
323 {
324 /* not support */
325 snd_dev->replay_config.samplebits = caps->udata.config.samplebits;
326 break;
327 }
328
329 default:
330 result = -RT_ERROR;
331 break;
332 }
333
334 break;
335 }
336
337 default:
338 break;
339 }
340
341 return RT_EOK;
342 }
343
sound_init(struct rt_audio_device * audio)344 static rt_err_t sound_init(struct rt_audio_device *audio)
345 {
346 struct sound_device *snd_dev = RT_NULL;
347
348 RT_ASSERT(audio != RT_NULL);
349 snd_dev = (struct sound_device *)audio->parent.user_data;
350
351 adpll_init(0);
352 dac_start();
353
354 /* set default params */
355 saia_frequency_set(snd_dev->replay_config.samplerate);
356 saia_channels_set(snd_dev->replay_config.channels);
357 saia_volume_set(snd_dev->volume);
358
359 return RT_EOK;
360 }
361
sound_start(struct rt_audio_device * audio,int stream)362 static rt_err_t sound_start(struct rt_audio_device *audio, int stream)
363 {
364 struct sound_device *snd_dev = RT_NULL;
365
366 RT_ASSERT(audio != RT_NULL);
367 snd_dev = (struct sound_device *)audio->parent.user_data;
368
369 if (stream == AUDIO_STREAM_REPLAY)
370 {
371 LOG_D("open sound device");
372
373 AUBUFSIZE = (TX_FIFO_SIZE / 4 - 1);
374 AUBUFSIZE |= (TX_FIFO_SIZE / 8) << 16;
375 AUBUFSTARTADDR = DMA_ADR(snd_dev->rx_fifo);
376
377 DACDIGCON0 |= BIT(0) | BIT(10); // (0x01<<2)
378
379 AUBUFCON |= BIT(1);
380 }
381
382 return RT_EOK;
383 }
384
sound_stop(struct rt_audio_device * audio,int stream)385 static rt_err_t sound_stop(struct rt_audio_device *audio, int stream)
386 {
387 RT_ASSERT(audio != RT_NULL);
388
389 if (stream == AUDIO_STREAM_REPLAY)
390 {
391 LOG_D("close sound device");
392 }
393
394 return RT_EOK;
395 }
396
sound_transmit(struct rt_audio_device * audio,const void * writeBuf,void * readBuf,rt_size_t size)397 rt_size_t sound_transmit(struct rt_audio_device *audio, const void *writeBuf, void *readBuf, rt_size_t size)
398 {
399 struct sound_device *snd_dev = RT_NULL;
400 rt_size_t tmp_size = size / 4;
401 rt_size_t count = 0;
402
403 RT_ASSERT(audio != RT_NULL);
404 snd_dev = (struct sound_device *)audio->parent.user_data;
405
406 while (tmp_size-- > 0) {
407 if (AUBUFCON & BIT(8)) { // aubuf full
408 AUBUFCON |= BIT(1) | BIT(4);
409 audio_sem_pend();
410 }
411 AUBUFDATA = ((const uint32_t *)writeBuf)[count++];
412 }
413
414 return size;
415 }
416
sound_buffer_info(struct rt_audio_device * audio,struct rt_audio_buf_info * info)417 static void sound_buffer_info(struct rt_audio_device *audio, struct rt_audio_buf_info *info)
418 {
419 struct sound_device *snd_dev = RT_NULL;
420
421 RT_ASSERT(audio != RT_NULL);
422 snd_dev = (struct sound_device *)audio->parent.user_data;
423
424 /**
425 * TX_FIFO
426 * +----------------+----------------+
427 * | block1 | block2 |
428 * +----------------+----------------+
429 * \ block_size /
430 */
431 info->buffer = snd_dev->tx_fifo;
432 info->total_size = TX_FIFO_SIZE;
433 info->block_size = TX_FIFO_SIZE / 2;
434 info->block_count = 2;
435 }
436
437 static struct rt_audio_ops ops =
438 {
439 .getcaps = sound_getcaps,
440 .configure = sound_configure,
441 .init = sound_init,
442 .start = sound_start,
443 .stop = sound_stop,
444 .transmit = sound_transmit,
445 .buffer_info = sound_buffer_info,
446 };
447
448 rt_section(".irq.audio")
audio_isr(int vector,void * param)449 static void audio_isr(int vector, void *param)
450 {
451 rt_interrupt_enter();
452
453 //Audio buffer pend
454 if (AUBUFCON & BIT(5)) {
455 AUBUFCON |= BIT(1); //Audio Buffer Pend Clear
456 AUBUFCON &= ~BIT(4);
457 audio_sem_post();
458 }
459 rt_interrupt_leave();
460 }
461
audio_thread_entry(void * parameter)462 static void audio_thread_entry(void *parameter)
463 {
464 while (1)
465 {
466 if ((snd_dev.dma_to_aubuf == RT_FALSE) && (snd_dev.audio.replay->activated == RT_TRUE)) {
467 rt_audio_tx_complete(&snd_dev.audio);
468 } else {
469 rt_thread_mdelay(50);
470 }
471 }
472 }
473
rt_hw_sound_init(void)474 static int rt_hw_sound_init(void)
475 {
476 rt_uint8_t *tx_fifo = RT_NULL;
477 rt_uint8_t *rx_fifo = RT_NULL;
478
479 /* 分配 DMA 搬运 buffer */
480 tx_fifo = rt_calloc(1, TX_FIFO_SIZE);
481 if(tx_fifo == RT_NULL)
482 {
483 return -RT_ENOMEM;
484 }
485
486 snd_dev.tx_fifo = tx_fifo;
487
488 /* 分配 DMA 搬运 buffer */
489 rx_fifo = rt_calloc(1, TX_FIFO_SIZE);
490 if(rx_fifo == RT_NULL)
491 {
492 return -RT_ENOMEM;
493 }
494
495 snd_dev.rx_fifo = rx_fifo;
496
497 snd_dev.semaphore = rt_sem_create("snd", 0, RT_IPC_FLAG_FIFO);
498 if (snd_dev.semaphore == RT_NULL)
499 {
500 return -RT_ENOMEM;
501 }
502
503 snd_dev.thread = rt_thread_create(
504 "audio",
505 audio_thread_entry,
506 RT_NULL,
507 1024,
508 20, // must equal or lower than tshell priority
509 1
510 );
511
512 if (snd_dev.thread != RT_NULL)
513 {
514 rt_thread_startup(snd_dev.thread);
515 }
516
517 /* init default configuration */
518 {
519 snd_dev.replay_config.samplerate = SAI_AUDIO_FREQUENCY_48K;
520 snd_dev.replay_config.channels = 2;
521 snd_dev.replay_config.samplebits = 16;
522 snd_dev.volume = 55;
523 }
524
525 /* register snd_dev device */
526 snd_dev.audio.ops = &ops;
527 rt_audio_register(&snd_dev.audio, "sound0", RT_DEVICE_FLAG_WRONLY, &snd_dev);
528
529 rt_hw_interrupt_install(IRQ_AUBUF0_1_VECTOR, audio_isr, RT_NULL, "au_isr");
530
531 return RT_EOK;
532 }
533 INIT_DEVICE_EXPORT(rt_hw_sound_init);
534