|
|
@@ -0,0 +1,1123 @@
|
|
|
+/*
|
|
|
+ * Copyright (c) 2006-2023, RT-Thread Development Team
|
|
|
+ *
|
|
|
+ * SPDX-License-Identifier: Apache-2.0
|
|
|
+ *
|
|
|
+ * Change Logs:
|
|
|
+ * Date Author Notes
|
|
|
+ * 2023-03-12 Vandoul the first version
|
|
|
+ */
|
|
|
+
|
|
|
+#include <rtthread.h>
|
|
|
+#include <drivers/audio.h>
|
|
|
+#include <drivers/i2c.h>
|
|
|
+#include "drv_sound_wm8904.h"
|
|
|
+
|
|
|
+/**
|
|
|
+ * @brief object of wm8904.
|
|
|
+ */
|
|
|
+struct drv_sound_wm8904{
|
|
|
+ struct rt_i2c_bus_device *i2c_bus;
|
|
|
+ rt_device_t i2s_bus;
|
|
|
+ int i2c_addr;
|
|
|
+};
|
|
|
+
|
|
|
+rt_err_t wm8904_write_register(struct drv_sound_wm8904 *dev, rt_uint8_t reg, rt_uint16_t value)
|
|
|
+{
|
|
|
+ struct rt_i2c_msg msg[2];
|
|
|
+ rt_uint8_t buf[2];
|
|
|
+ buf[0] = (value>>8)&0xFF;
|
|
|
+ buf[1] = value&0xFF;
|
|
|
+ msg[0].addr = dev->i2c_addr;
|
|
|
+ msg[0].buf = ®
|
|
|
+ msg[0].flags = RT_I2C_WR;
|
|
|
+ msg[0].len = 1;
|
|
|
+ msg[1].addr = dev->i2c_addr;
|
|
|
+ msg[1].buf = buf;
|
|
|
+ msg[1].flags = RT_I2C_WR|RT_I2C_NO_START;
|
|
|
+ msg[1].len = 2;
|
|
|
+ if(rt_i2c_transfer(dev->i2c_bus, msg, 2) != 2)
|
|
|
+ {
|
|
|
+ return -RT_ERROR;
|
|
|
+ }
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_read_register(struct drv_sound_wm8904 *dev, rt_uint8_t reg, rt_uint16_t *value)
|
|
|
+{
|
|
|
+ struct rt_i2c_msg msg[2];
|
|
|
+ rt_uint8_t buf[2];
|
|
|
+ msg[0].addr = dev->i2c_addr;
|
|
|
+ msg[0].buf = ®
|
|
|
+ msg[0].flags = RT_I2C_WR;
|
|
|
+ msg[0].len = 1;
|
|
|
+ msg[1].addr = dev->i2c_addr;
|
|
|
+ msg[1].buf = buf;
|
|
|
+ msg[1].flags = RT_I2C_RD|RT_I2C_NO_START;
|
|
|
+ msg[1].len = 2;
|
|
|
+ if(rt_i2c_transfer(dev->i2c_bus, msg, 2) != 2)
|
|
|
+ {
|
|
|
+ return -RT_ERROR;
|
|
|
+ }
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_modify_register(struct drv_sound_wm8904 *dev, rt_uint8_t reg, rt_uint16_t mask, rt_uint16_t value)
|
|
|
+{
|
|
|
+ rt_uint16_t reg_value;
|
|
|
+ rt_err_t ret;
|
|
|
+
|
|
|
+ ret = wm8904_read_register(dev, reg, ®_value);
|
|
|
+ if(ret != RT_EOK)
|
|
|
+ {
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+ reg_value &= (uint16_t)~mask;
|
|
|
+ reg_value |= value;
|
|
|
+ return wm8904_write_register(dev, reg, reg_value);
|
|
|
+}
|
|
|
+
|
|
|
+static rt_err_t wm8904_wait_on_write_sequencer(struct drv_sound_wm8904 *dev)
|
|
|
+{
|
|
|
+ rt_err_t ret;
|
|
|
+ rt_uint16_t value;
|
|
|
+
|
|
|
+ do {
|
|
|
+ ret = wm8904_read_register(dev, WM8904_WRT_SEQUENCER_4, &value);
|
|
|
+ }while((ret == RT_EOK) && ((value & 1U) != 0u));
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+static rt_err_t wm8904_updateformat(struct drv_sound_wm8904 *dev, wm8904_fs_ratio_t fs_ratio, wm8904_sample_rate_t sample_rate, wm8904_bit_width_t bit_width)
|
|
|
+{
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+ /** Disable SYSCLK */
|
|
|
+ err = wm8904_write_register(dev, WM8904_CLK_RATES_2, 0x00);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ /** Set clock ratio and sample rate */
|
|
|
+ err = wm8904_write_register(dev, WM8904_CLK_RATES_1, (rt_uint16_t)((rt_uint16_t)fs_ratio << 10U) | (rt_uint16_t)sample_rate);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ /** Set bit resolution. */
|
|
|
+ err = wm8904_modify_register(dev, WM8904_AUDIO_IF_1, (0x000CU), (rt_uint16_t)bit_width << 2U);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ /** Enable SYSCLK */
|
|
|
+ err = wm8904_write_register(dev, WM8904_CLK_RATES_2, 0x1007);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+static rt_err_t wm8904_i2c_bus_init(struct rt_i2c_bus_device *i2c_bus)
|
|
|
+{
|
|
|
+ (void)i2c_bus;
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+static rt_err_t wm8904_i2s_bus_init(rt_device_t i2s_bus)
|
|
|
+{
|
|
|
+ (void)i2s_bus;
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+const static uint16_t wm8904_init_list[][2] = {
|
|
|
+ /* TOCLK_RATE_DIV16=0, TOCLK_RATE_x4=1, SR_MODE=0, MCLK_DIV=1
|
|
|
+ * (Required for MMCs: SGY, KRT see erratum CE000546) */
|
|
|
+ {WM8904_CLK_RATES_0, 0xA45F},
|
|
|
+ /* INL_ENA=1, INR ENA=1 */
|
|
|
+ {WM8904_POWER_MGMT_0, 0x0003},
|
|
|
+ /* HPL_PGA_ENA=1, HPR_PGA_ENA=1 */
|
|
|
+ {WM8904_POWER_MGMT_2, 0x0003},
|
|
|
+ /* DACL_ENA=1, DACR_ENA=1, ADCL_ENA=1, ADCR_ENA=1 */
|
|
|
+ {WM8904_POWER_MGMT_6, 0x000F},
|
|
|
+ /* ADC_OSR128=1 */
|
|
|
+ {WM8904_ANALOG_ADC_0, 0x0001},
|
|
|
+ /* DACL_DATINV=0, DACR_DATINV=0, DAC_BOOST=00, LOOPBACK=0, AIFADCL_SRC=0,
|
|
|
+ * AIFADCR_SRC=1, AIFDACL_SRC=0, AIFDACR_SRC=1, ADC_COMP=0, ADC_COMPMODE=0,
|
|
|
+ * DAC_COMP=0, DAC_COMPMODE=0 */
|
|
|
+ {WM8904_AUDIO_IF_0, 0x0050},
|
|
|
+ /* DAC_MONO=0, DAC_SB_FILT-0, DAC_MUTERATE=0, DAC_UNMUTE RAMP=0,
|
|
|
+ * DAC_OSR128=1, DAC_MUTE=0, DEEMPH=0 (none) */
|
|
|
+ {WM8904_DAC_DIG_1, 0x0040},
|
|
|
+ /* LINMUTE=0, LIN_VOL=0_0101 */
|
|
|
+ {WM8904_ANALOG_LEFT_IN_0, 0x0005},
|
|
|
+ /* RINMUTE=0, RIN VOL=0_0101 LINEOUTL RMV SHORT-1, LINEOUTL ENA_OUTP=1,
|
|
|
+ * LINEOUTL_ENA_DLY=1, LINEOUTL_ENA=1, LINEOUTR_RMV_SHORT-1,
|
|
|
+ * LINEOUTR_ENA_OUTP=1 */
|
|
|
+ {WM8904_ANALOG_RIGHT_IN_0, 0x0005},
|
|
|
+ /* HPOUTL_MUTE=0, HPOUT_VU=0, HPOUTLZC=0, HPOUTL_VOL=10_1101 */
|
|
|
+ {WM8904_ANALOG_OUT1_LEFT, 0x00AD},
|
|
|
+ /* HPOUTR_MUTE=0, HPOUT_VU=0, HPOUTRZC=0, HPOUTR_VOL=10_1101 */
|
|
|
+ {WM8904_ANALOG_OUT1_RIGHT, 0x00AD},
|
|
|
+ /* Enable DC servos for headphone out */
|
|
|
+ {WM8904_DC_SERVO_0, 0x0003},
|
|
|
+ /* HPL_RMV_SHORT=1, HPL_ENA_OUTP=1, HPL_ENA_DLY=1, HPL_ENA=1,
|
|
|
+ * HPR_RMV_SHORT=1, HPR_ENA_OUTP=1, HPR_ENA_DLY=1, HPR_ENA=1 */
|
|
|
+ {WM8904_ANALOG_HP_0, 0x00FF},
|
|
|
+ /* CP_DYN_PWR=1 */
|
|
|
+ {WM8904_CLS_W_0, 0x0001},
|
|
|
+ /* CP_ENA=1 */
|
|
|
+ {WM8904_CHRG_PUMP_0, 0x0001},
|
|
|
+ /* TOCLK_RATE_DIV16=0, TOCLK_RATE_x4=1, SR_MODE=0, MCLK_DIV=1
|
|
|
+ * (Required for MMCs: SGY, KRT see erratum CE000546) */
|
|
|
+ {WM8904_CLK_RATES_0, 0xA45F},
|
|
|
+ /* INL_ENA=1, INR ENA=1 */
|
|
|
+ {WM8904_POWER_MGMT_0, 0x0003},
|
|
|
+ /* HPL_PGA_ENA=1, HPR_PGA_ENA=1 */
|
|
|
+ {WM8904_POWER_MGMT_2, 0x0003},
|
|
|
+ /* DACL_ENA=1, DACR_ENA=1, ADCL_ENA=1, ADCR_ENA=1 */
|
|
|
+ {WM8904_POWER_MGMT_6, 0x000F},
|
|
|
+ /* ADC_OSR128=1 */
|
|
|
+ {WM8904_ANALOG_ADC_0, 0x0001},
|
|
|
+ /* DACL_DATINV=0, DACR_DATINV=0, DAC_BOOST=00, LOOPBACK=0, AIFADCL_SRC=0,
|
|
|
+ * AIFADCR_SRC=1, AIFDACL_SRC=0, AIFDACR_SRC=1, ADC_COMP=0, ADC_COMPMODE=0,
|
|
|
+ * DAC_COMP=0, DAC_COMPMODE=0 */
|
|
|
+ {WM8904_AUDIO_IF_0, 0x0050},
|
|
|
+ /* DAC_MONO=0, DAC_SB_FILT-0, DAC_MUTERATE=0, DAC_UNMUTE RAMP=0,
|
|
|
+ * DAC_OSR128=1, DAC_MUTE=0, DEEMPH=0 (none) */
|
|
|
+ {WM8904_DAC_DIG_1, 0x0040},
|
|
|
+ /* LINMUTE=0, LIN_VOL=0_0101 */
|
|
|
+ {WM8904_ANALOG_LEFT_IN_0, 0x0005},
|
|
|
+ /* RINMUTE=0, RIN VOL=0_0101 LINEOUTL RMV SHORT-1, LINEOUTL ENA_OUTP=1,
|
|
|
+ * LINEOUTL_ENA_DLY=1, LINEOUTL_ENA=1, LINEOUTR_RMV_SHORT-1,
|
|
|
+ * LINEOUTR_ENA_OUTP=1 */
|
|
|
+ {WM8904_ANALOG_RIGHT_IN_0, 0x0005},
|
|
|
+ /* HPOUTL_MUTE=0, HPOUT_VU=0, HPOUTLZC=0, HPOUTL_VOL=10_1101 */
|
|
|
+ {WM8904_ANALOG_OUT1_LEFT, 0x00AD},
|
|
|
+ /* HPOUTR_MUTE=0, HPOUT_VU=0, HPOUTRZC=0, HPOUTR_VOL=10_1101 */
|
|
|
+ {WM8904_ANALOG_OUT1_RIGHT, 0x00AD},
|
|
|
+ /* Enable DC servos for headphone out */
|
|
|
+ {WM8904_DC_SERVO_0, 0x0003},
|
|
|
+ /* HPL_RMV_SHORT=1, HPL_ENA_OUTP=1, HPL_ENA_DLY=1, HPL_ENA=1,
|
|
|
+ * HPR_RMV_SHORT=1, HPR_ENA_OUTP=1, HPR_ENA_DLY=1, HPR_ENA=1 */
|
|
|
+ {WM8904_ANALOG_HP_0, 0x00FF},
|
|
|
+ /* CP_DYN_PWR=1 */
|
|
|
+ {WM8904_CLS_W_0, 0x0001},
|
|
|
+ /* CP_ENA=1 */
|
|
|
+ {WM8904_CHRG_PUMP_0, 0x0001},
|
|
|
+};
|
|
|
+rt_err_t wm8904_init(struct drv_sound_wm8904 *dev, struct wm8904_config *config)
|
|
|
+{
|
|
|
+ rt_err_t ret;
|
|
|
+
|
|
|
+ dev->i2c_bus = rt_i2c_bus_device_find(config->i2c_bus_name);
|
|
|
+ if(dev->i2c_bus == RT_NULL)
|
|
|
+ {
|
|
|
+ return -RT_EINVAL;
|
|
|
+ }
|
|
|
+ dev->i2s_bus = rt_device_find(config->i2s_bus_name);
|
|
|
+ if(dev->i2s_bus == RT_NULL)
|
|
|
+ {
|
|
|
+ return -RT_EINVAL;
|
|
|
+ }
|
|
|
+
|
|
|
+ wm8904_i2c_bus_init(dev->i2c_bus);
|
|
|
+ wm8904_i2s_bus_init(dev->i2s_bus);
|
|
|
+
|
|
|
+ ret = wm8904_write_register(dev, WM8904_RESET, 0x0000);
|
|
|
+ if(ret != RT_EOK)
|
|
|
+ {
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* MCLK_INV=0, SYSCLK_SRC=0, TOCLK_RATE=0, OPCLK_ENA=1,
|
|
|
+ * CLK_SYS_ENA=1, CLK_DSP_ENA=1, TOCLK_ENA=1 */
|
|
|
+ ret = wm8904_write_register(dev, WM8904_CLK_RATES_2, 0x000F);
|
|
|
+ if(ret != RT_EOK)
|
|
|
+ {
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* WSEQ_ENA=1, WSEQ_WRITE_INDEX=0_0000 */
|
|
|
+ ret = wm8904_write_register(dev, WM8904_WRT_SEQUENCER_0, 0x0100);
|
|
|
+ if(ret != RT_EOK)
|
|
|
+ {
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* WSEQ_ABORT=0, WSEQ_START=1, WSEQ_START_INDEX=00_0000 */
|
|
|
+ ret = wm8904_write_register(dev, WM8904_WRT_SEQUENCER_3, 0x0100);
|
|
|
+ if(ret != RT_EOK)
|
|
|
+ {
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* WSEQ_ENA=1, WSEQ_SRITE_INDEX=0_0000 */
|
|
|
+ ret = wm8904_write_register(dev, WM8904_WRT_SEQUENCER_0, 0x0100);
|
|
|
+ if(ret != RT_EOK)
|
|
|
+ {
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ ret = wm8904_wait_on_write_sequencer(dev);
|
|
|
+ if(ret != RT_EOK)
|
|
|
+ {
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ for(int i=0; i<sizeof(wm8904_init_list)/sizeof(wm8904_init_list[0]); i++)
|
|
|
+ {
|
|
|
+ ret = wm8904_write_register(dev, wm8904_init_list[i][0], wm8904_init_list[i][1]);
|
|
|
+ if(ret != RT_EOK)
|
|
|
+ {
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_deinit(struct drv_sound_wm8904 *dev)
|
|
|
+{
|
|
|
+ return wm8904_write_register(dev, WM8904_RESET, 0x0000);
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_master_clock(struct drv_sound_wm8904 *dev, rt_uint32_t sysclk, rt_uint32_t sample_rate, rt_uint32_t bit_width)
|
|
|
+{
|
|
|
+ rt_uint32_t bclk = sample_rate * bit_width * 2U;
|
|
|
+ rt_uint32_t bclk_div = 0U;
|
|
|
+ rt_uint16_t audio_interface = 0U;
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+ rt_uint16_t sysclk_div = 0;
|
|
|
+
|
|
|
+ err = wm8904_read_register(dev, WM8904_CLK_RATES_0, &sysclk_div);
|
|
|
+ sysclk = sysclk >> (sysclk_div & 0x1U);
|
|
|
+
|
|
|
+ if((sysclk / bclk > 48U) || (bclk / sample_rate > 2047U) || (bclk / sample_rate < 8U))
|
|
|
+ {
|
|
|
+ return -RT_EINVAL;
|
|
|
+ }
|
|
|
+
|
|
|
+ err = wm8904_read_register(dev, WM8904_AUDIO_IF_2, &audio_interface);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+
|
|
|
+ audio_interface &= ~(rt_uint16_t)0x1FU;
|
|
|
+ bclk_div = (sysclk * 10U) / bclk;
|
|
|
+
|
|
|
+ switch(bclk_div)
|
|
|
+ {
|
|
|
+ case 10:
|
|
|
+ audio_interface |= 0U;
|
|
|
+ break;
|
|
|
+ case 15:
|
|
|
+ audio_interface |= 1U;
|
|
|
+ break;
|
|
|
+ case 20:
|
|
|
+ audio_interface |= 2U;
|
|
|
+ break;
|
|
|
+ case 30:
|
|
|
+ audio_interface |= 3U;
|
|
|
+ break;
|
|
|
+ case 40:
|
|
|
+ audio_interface |= 4U;
|
|
|
+ break;
|
|
|
+ case 50:
|
|
|
+ audio_interface |= 5U;
|
|
|
+ break;
|
|
|
+ case 55:
|
|
|
+ audio_interface |= 6U;
|
|
|
+ break;
|
|
|
+ case 60:
|
|
|
+ audio_interface |= 7U;
|
|
|
+ break;
|
|
|
+ case 80:
|
|
|
+ audio_interface |= 8U;
|
|
|
+ break;
|
|
|
+ case 100:
|
|
|
+ audio_interface |= 9U;
|
|
|
+ break;
|
|
|
+ case 110:
|
|
|
+ audio_interface |= 10U;
|
|
|
+ break;
|
|
|
+ case 120:
|
|
|
+ audio_interface |= 11U;
|
|
|
+ break;
|
|
|
+ case 160:
|
|
|
+ audio_interface |= 12U;
|
|
|
+ break;
|
|
|
+ case 200:
|
|
|
+ audio_interface |= 13U;
|
|
|
+ break;
|
|
|
+ case 220:
|
|
|
+ audio_interface |= 14U;
|
|
|
+ break;
|
|
|
+ case 240:
|
|
|
+ audio_interface |= 15U;
|
|
|
+ break;
|
|
|
+ case 250:
|
|
|
+ audio_interface |= 16U;
|
|
|
+ break;
|
|
|
+ case 300:
|
|
|
+ audio_interface |= 17U;
|
|
|
+ break;
|
|
|
+ case 320:
|
|
|
+ audio_interface |= 18U;
|
|
|
+ break;
|
|
|
+ case 440:
|
|
|
+ audio_interface |= 19U;
|
|
|
+ break;
|
|
|
+ case 480:
|
|
|
+ audio_interface |= 20U;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ err = -RT_EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** bclk divider */
|
|
|
+ err = wm8904_write_register(dev, WM8904_AUDIO_IF_2, audio_interface);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+
|
|
|
+ err = wm8904_modify_register(dev, WM8904_GPIO_CONTROL_4, 0x8FU, 1U);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ /** LRCLK direction and divider */
|
|
|
+ audio_interface = (rt_uint16_t)((1UL << 11U) | (bclk / sample_rate));
|
|
|
+ err = wm8904_modify_register(dev, WM8904_AUDIO_IF_3, 0xFFFU, audio_interface);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_fll_config(struct drv_sound_wm8904 *dev, wm8904_fll_config_t *config)
|
|
|
+{
|
|
|
+ RT_ASSERT(dev != RT_NULL);
|
|
|
+ RT_ASSERT(config != RT_NULL);
|
|
|
+
|
|
|
+ rt_uint32_t reference_clock = config->ref_clock_hz;
|
|
|
+ rt_uint32_t input_divider = 0U;
|
|
|
+ rt_uint32_t fvco = 0U, output_div = 0U, ratio = 0U;
|
|
|
+ rt_uint32_t n = 0U, k = 0U;
|
|
|
+
|
|
|
+ /* it is recommended that the highest possible frequency - within the 13.5MHz limit - should be selected */
|
|
|
+ if(reference_clock < 13500000U)
|
|
|
+ {
|
|
|
+ input_divider = 0;
|
|
|
+ }
|
|
|
+ else if(reference_clock / 2U < 13500000U)
|
|
|
+ {
|
|
|
+ input_divider = 1;
|
|
|
+ }
|
|
|
+ else if(reference_clock / 4U < 13500000U)
|
|
|
+ {
|
|
|
+ input_divider = 2;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ input_divider = 3;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(reference_clock / (1UL << input_divider) > 13500000)
|
|
|
+ {
|
|
|
+ return -RT_EINVAL;
|
|
|
+ }
|
|
|
+
|
|
|
+ reference_clock = reference_clock / (1UL << input_divider);
|
|
|
+
|
|
|
+ for (output_div = 4U; output_div <= 64U; output_div++)
|
|
|
+ {
|
|
|
+ fvco = output_div * config->output_clock_hz;
|
|
|
+ if ((fvco >= 90000000U) && (fvco <= 100000000U))
|
|
|
+ {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(reference_clock <= 64000U)
|
|
|
+ {
|
|
|
+ ratio = 4U;
|
|
|
+ }
|
|
|
+ else if(reference_clock <= 128000U)
|
|
|
+ {
|
|
|
+ ratio = 3U;
|
|
|
+ }
|
|
|
+ else if(reference_clock <= 256000U)
|
|
|
+ {
|
|
|
+ ratio = 2U;
|
|
|
+ }
|
|
|
+ else if(reference_clock <= 1000000U)
|
|
|
+ {
|
|
|
+ ratio = 1U;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ ratio = 0U;
|
|
|
+ }
|
|
|
+
|
|
|
+ n = fvco / ((ratio + 1U) * reference_clock);
|
|
|
+ k = (rt_uint32_t)((rt_uint64_t)fvco * 1000000U) / ((ratio + 1U) * reference_clock);
|
|
|
+ if(n != 0U)
|
|
|
+ {
|
|
|
+ k = k - n * 1000000U;
|
|
|
+ }
|
|
|
+ k = (rt_uint32_t)((rt_uint64_t)k * 65536U) / 1000000U;
|
|
|
+
|
|
|
+ /* configure WM8904 */
|
|
|
+ if (wm8904_modify_register(dev, WM8904_FLL_CONTROL_1, 7U, 4U) != RT_EOK)
|
|
|
+ {
|
|
|
+ return -RT_ERROR;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* configure WM8904 */
|
|
|
+ if (wm8904_modify_register(dev, WM8904_FLL_CONTROL_2, 0x3F07U, (rt_uint16_t)(((output_div - 1U) << 8U) | ratio)) != RT_EOK)
|
|
|
+ {
|
|
|
+ return -RT_ERROR;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (wm8904_write_register(dev, WM8904_FLL_CONTROL_3, (rt_uint16_t)k) != RT_EOK)
|
|
|
+ {
|
|
|
+ return -RT_ERROR;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (wm8904_modify_register(dev, WM8904_FLL_CONTROL_4, 0x7FE0U, (rt_uint16_t)(n << 5U)) != RT_EOK)
|
|
|
+ {
|
|
|
+ return -RT_ERROR;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (wm8904_write_register(dev, WM8904_FLL_CONTROL_5, (rt_uint16_t)((input_divider << 3U) | (rt_uint16_t)config->source)) != RT_EOK)
|
|
|
+ {
|
|
|
+ return -RT_ERROR;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (wm8904_modify_register(dev, WM8904_FLL_CONTROL_1, 1U, 1) != RT_EOK)
|
|
|
+ {
|
|
|
+ return -RT_ERROR;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** enable GPIO1 output fll output clock */
|
|
|
+ if (wm8904_write_register(dev, WM8904_GPIO_CONTROL_1, (rt_uint16_t)9U) != RT_EOK)
|
|
|
+ {
|
|
|
+ return -RT_ERROR;
|
|
|
+ }
|
|
|
+
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_protocol(struct drv_sound_wm8904 *dev, wm8904_protocol_t p)
|
|
|
+{
|
|
|
+ return wm8904_modify_register(dev, WM8904_AUDIO_IF_1, (0x0003U | (1U << 4U)), (rt_uint16_t)p);
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_select_lrc_polarity(struct drv_sound_wm8904 *dev, rt_uint32_t polarity)
|
|
|
+{
|
|
|
+ return wm8904_modify_register(dev, WM8904_AUDIO_IF_1, 0x0010U, (rt_uint16_t)polarity);
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_enable_dac_time_slot(struct drv_sound_wm8904 *dev, wm8904_timeslot_t timeslot)
|
|
|
+{
|
|
|
+ return wm8904_modify_register(dev, WM8904_AUDIO_IF_1, ((rt_uint16_t)3U << 12U), (((rt_uint16_t)1U << 13U) | ((rt_uint16_t)timeslot << 12U)));
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_enable_adc_time_slot(struct drv_sound_wm8904 *dev, wm8904_timeslot_t timeslot)
|
|
|
+{
|
|
|
+ return wm8904_modify_register(dev, WM8904_AUDIO_IF_1, ((rt_uint16_t)3U << 10U), (((rt_uint16_t)1U << 11U) | ((rt_uint16_t)timeslot << 10U)));
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_check_audio_format(struct drv_sound_wm8904 *dev, wm8904_audio_format_t *format, rt_uint32_t mclk_freq)
|
|
|
+{
|
|
|
+ RT_ASSERT((dev != RT_NULL) && (format != RT_NULL));
|
|
|
+
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+ rt_uint16_t mclk_div = 0U;
|
|
|
+ rt_uint32_t sample_rate = 0U;
|
|
|
+ rt_uint32_t fs_ratio = 0;
|
|
|
+ wm8904_sample_rate_t reg_sample_rate = format->sampleRate;
|
|
|
+
|
|
|
+ err = wm8904_read_register(dev, WM8904_CLK_RATES_0, &mclk_div);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch(format->sampleRate)
|
|
|
+ {
|
|
|
+ case WM8904_SAMPLERATE_8kHz:
|
|
|
+ sample_rate = 8000;
|
|
|
+ break;
|
|
|
+ case WM8904_SAMPLERATE_12kHz :
|
|
|
+ sample_rate = 12000;
|
|
|
+ break;
|
|
|
+ case WM8904_SAMPLERATE_16kHz :
|
|
|
+ sample_rate = 16000;
|
|
|
+ break;
|
|
|
+ case WM8904_SAMPLERATE_24kHz :
|
|
|
+ sample_rate = 24000;
|
|
|
+ break;
|
|
|
+ case WM8904_SAMPLERATE_32kHz :
|
|
|
+ sample_rate = 32000;
|
|
|
+ break;
|
|
|
+ case WM8904_SAMPLERATE_48kHz :
|
|
|
+ sample_rate = 48000;
|
|
|
+ break;
|
|
|
+ case WM8904_SAMPLERATE_11025Hz:
|
|
|
+ sample_rate = 11025;
|
|
|
+ reg_sample_rate = WM8904_SAMPLERATE_12kHz;
|
|
|
+ break;
|
|
|
+ case WM8904_SAMPLERATE_22050Hz:
|
|
|
+ sample_rate = 22050;
|
|
|
+ reg_sample_rate = WM8904_SAMPLERATE_24kHz;
|
|
|
+ break;
|
|
|
+ case WM8904_SAMPLERATE_44100Hz:
|
|
|
+ sample_rate = 44100;
|
|
|
+ reg_sample_rate = WM8904_SAMPLERATE_48kHz;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ err = -RT_EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+
|
|
|
+ fs_ratio = (mclk_freq >> (mclk_div & 0x1U)) / sample_rate;
|
|
|
+
|
|
|
+ switch(fs_ratio)
|
|
|
+ {
|
|
|
+ case 64:
|
|
|
+ format->fsRatio = WM8904_FSRATIO_64X;
|
|
|
+ break;
|
|
|
+ case 128 :
|
|
|
+ format->fsRatio = WM8904_FSRATIO_128X;
|
|
|
+ break;
|
|
|
+ case 192 :
|
|
|
+ format->fsRatio = WM8904_FSRATIO_192X;
|
|
|
+ break;
|
|
|
+ case 256 :
|
|
|
+ format->fsRatio = WM8904_FSRATIO_256X;
|
|
|
+ break;
|
|
|
+ case 384 :
|
|
|
+ format->fsRatio = WM8904_FSRATIO_384X;
|
|
|
+ break;
|
|
|
+ case 512 :
|
|
|
+ format->fsRatio = WM8904_FSRATIO_512X;
|
|
|
+ break;
|
|
|
+ case 768 :
|
|
|
+ format->fsRatio = WM8904_FSRATIO_768X;
|
|
|
+ break;
|
|
|
+ case 1024:
|
|
|
+ format->fsRatio = WM8904_FSRATIO_1024X;
|
|
|
+ break;
|
|
|
+ case 1408:
|
|
|
+ format->fsRatio = WM8904_FSRATIO_1408X;
|
|
|
+ break;
|
|
|
+ case 1536:
|
|
|
+ format->fsRatio = WM8904_FSRATIO_1536X;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ err = -RT_EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ return wm8904_updateformat(dev, format->fsRatio, reg_sample_rate, format->bitWidth);
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_audio_format(struct drv_sound_wm8904 *dev, rt_uint32_t sysclk, rt_uint32_t sample_rate, rt_uint32_t bit_width)
|
|
|
+{
|
|
|
+ rt_uint32_t ratio = 0;
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+ wm8904_bit_width_t reg_bit_width = WM8904_BITWIDTH_32;
|
|
|
+ wm8904_sample_rate_t reg_sample_reate = WM8904_SAMPLERATE_48kHz;
|
|
|
+ wm8904_fs_ratio_t reg_fsratio = WM8904_FSRATIO_1536X;
|
|
|
+
|
|
|
+ rt_uint16_t temp_reg = 0U;
|
|
|
+
|
|
|
+ err = wm8904_read_register(dev, WM8904_CLK_RATES_0, &temp_reg);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch(sample_rate)
|
|
|
+ {
|
|
|
+ case 8000:
|
|
|
+ sample_rate = WM8904_SAMPLERATE_8kHz;
|
|
|
+ break;
|
|
|
+ case 11025:
|
|
|
+ sample_rate = WM8904_SAMPLERATE_12kHz;
|
|
|
+ break;
|
|
|
+ case 12000:
|
|
|
+ sample_rate = WM8904_SAMPLERATE_12kHz;
|
|
|
+ break;
|
|
|
+ case 16000:
|
|
|
+ sample_rate = WM8904_SAMPLERATE_16kHz;
|
|
|
+ break;
|
|
|
+ case 22050:
|
|
|
+ sample_rate = WM8904_SAMPLERATE_24kHz;
|
|
|
+ break;
|
|
|
+ case 24000:
|
|
|
+ sample_rate = WM8904_SAMPLERATE_24kHz;
|
|
|
+ break;
|
|
|
+ case 32000:
|
|
|
+ sample_rate = WM8904_SAMPLERATE_32kHz;
|
|
|
+ break;
|
|
|
+ case 44100:
|
|
|
+ sample_rate = WM8904_SAMPLERATE_48kHz;
|
|
|
+ break;
|
|
|
+ case 48000:
|
|
|
+ sample_rate = WM8904_SAMPLERATE_48kHz;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ err = -RT_EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch(bit_width)
|
|
|
+ {
|
|
|
+ case 16:
|
|
|
+ reg_bit_width = WM8904_BITWIDTH_16;
|
|
|
+ break;
|
|
|
+ case 20:
|
|
|
+ reg_bit_width = WM8904_BITWIDTH_20;
|
|
|
+ break;
|
|
|
+ case 24:
|
|
|
+ reg_bit_width = WM8904_BITWIDTH_24;
|
|
|
+ break;
|
|
|
+ case 32:
|
|
|
+ reg_bit_width = WM8904_BITWIDTH_32;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ err = -RT_EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+
|
|
|
+ ratio = (sysclk >> (temp_reg & 0x1U)) / sample_rate;
|
|
|
+
|
|
|
+ switch(ratio)
|
|
|
+ {
|
|
|
+ case 64:
|
|
|
+ reg_fsratio = WM8904_FSRATIO_64X;
|
|
|
+ break;
|
|
|
+ case 128 :
|
|
|
+ reg_fsratio = WM8904_FSRATIO_128X;
|
|
|
+ break;
|
|
|
+ case 192 :
|
|
|
+ reg_fsratio = WM8904_FSRATIO_192X;
|
|
|
+ break;
|
|
|
+ case 256 :
|
|
|
+ reg_fsratio = WM8904_FSRATIO_256X;
|
|
|
+ break;
|
|
|
+ case 384 :
|
|
|
+ reg_fsratio = WM8904_FSRATIO_384X;
|
|
|
+ break;
|
|
|
+ case 512 :
|
|
|
+ reg_fsratio = WM8904_FSRATIO_512X;
|
|
|
+ break;
|
|
|
+ case 768 :
|
|
|
+ reg_fsratio = WM8904_FSRATIO_768X;
|
|
|
+ break;
|
|
|
+ case 1024:
|
|
|
+ reg_fsratio = WM8904_FSRATIO_1024X;
|
|
|
+ break;
|
|
|
+ case 1408:
|
|
|
+ reg_fsratio = WM8904_FSRATIO_1408X;
|
|
|
+ break;
|
|
|
+ case 1536:
|
|
|
+ reg_fsratio = WM8904_FSRATIO_1536X;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ err = -RT_EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ err = wm8904_updateformat(dev, reg_fsratio, reg_sample_reate, reg_bit_width);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ err = wm8904_read_register(dev, WM8904_AUDIO_IF_1, &temp_reg);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ if((temp_reg & (1UL << 6U)) != 0)
|
|
|
+ {
|
|
|
+ err = wm8904_set_master_clock(dev, sysclk, sample_rate, bit_width);
|
|
|
+ }
|
|
|
+ return err;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_volume(struct drv_sound_wm8904 *dev, rt_uint16_t volume_left, rt_uint16_t volume_right)
|
|
|
+{
|
|
|
+ RT_ASSERT(volume_left <= WM8904_MAP_HEADPHONE_LINEOUT_MAX_VOLUME);
|
|
|
+ RT_ASSERT(volume_right <= WM8904_MAP_HEADPHONE_LINEOUT_MAX_VOLUME);
|
|
|
+
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT1_LEFT, 0x1BF, volume_left);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT1_RIGHT, 0x1BF, ((rt_uint16_t)volume_right | 0x0080U));
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_mute(struct drv_sound_wm8904 *dev, rt_bool_t mute_left, rt_bool_t mute_right)
|
|
|
+{
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+ rt_uint16_t left = (rt_uint16_t)(mute_left ? 0x0100U : 0x0000U);
|
|
|
+ rt_uint16_t right = (rt_uint16_t)(mute_right ? 0x0100U : 0x0000U);
|
|
|
+
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT1_LEFT, 0x0100U, left);
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT1_RIGHT, 0x0180U, ((rt_uint16_t)right | 0x0080U));
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+
|
|
|
+ return err;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_channel_volume(struct drv_sound_wm8904 *dev, rt_uint32_t channel, rt_uint32_t volume)
|
|
|
+{
|
|
|
+ RT_ASSERT(volume <= WM8904_MAP_HEADPHONE_LINEOUT_MAX_VOLUME);
|
|
|
+
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+
|
|
|
+ /* headphone left channel 0x1BF means unmute the OUT and reset the OUT volume update bit and volume range fields */
|
|
|
+ if((channel & (rt_uint32_t)WM8904_HEADPHONE_LEFT) != 0U)
|
|
|
+ {
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT1_LEFT, 0x1BFU, (rt_uint16_t)volume | 0x80U);
|
|
|
+ }
|
|
|
+ /* headphone right channel */
|
|
|
+ if((channel & (rt_uint32_t)WM8904_HEADPHONE_RIGHT) != 0U)
|
|
|
+ {
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT1_RIGHT, 0x1BFU, (rt_uint16_t)volume | 0x80U);
|
|
|
+ }
|
|
|
+ /* line out left channel */
|
|
|
+ if((channel & (rt_uint32_t)WM8904_LINEOUT_LEFT) != 0U)
|
|
|
+ {
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT2_LEFT, 0x1BFU, (rt_uint16_t)volume | 0x80U);
|
|
|
+ }
|
|
|
+ /* line out right channel */
|
|
|
+ if((channel & (rt_uint32_t)WM8904_LINEOUT_RIGHT) != 0U)
|
|
|
+ {
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT2_RIGHT, 0x1BFU, (rt_uint16_t)volume | 0x80U);
|
|
|
+ }
|
|
|
+
|
|
|
+ return err;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_channel_mute(struct drv_sound_wm8904 *dev, rt_uint32_t channel, rt_bool_t is_mute)
|
|
|
+{
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+ rt_uint16_t reg_value = 0U, reg_mask = 0U;
|
|
|
+
|
|
|
+ reg_value = is_mute ? 0x180U : 0x80U;
|
|
|
+ reg_mask = 0x100U;
|
|
|
+
|
|
|
+ /* headphone left channel */
|
|
|
+ if((channel & (rt_uint32_t)WM8904_HEADPHONE_LEFT) != 0U)
|
|
|
+ {
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT1_LEFT, reg_mask, reg_value);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* headphone right channel */
|
|
|
+ if((channel & (rt_uint32_t)WM8904_HEADPHONE_RIGHT) != 0U)
|
|
|
+ {
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT1_RIGHT, reg_mask, reg_value);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* line out left channel */
|
|
|
+ if((channel & (rt_uint32_t)WM8904_LINEOUT_LEFT) != 0U)
|
|
|
+ {
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT2_LEFT, reg_mask, reg_value);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* line out right channel */
|
|
|
+ if((channel & (rt_uint32_t)WM8904_LINEOUT_RIGHT) != 0U)
|
|
|
+ {
|
|
|
+ err = wm8904_modify_register(dev, WM8904_ANALOG_OUT2_RIGHT, reg_mask, reg_value);
|
|
|
+ }
|
|
|
+ return err;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_enable_dac_volume(struct drv_sound_wm8904 *dev, rt_uint8_t volume)
|
|
|
+{
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+ err = wm8904_write_register(dev, WM8904_DAC_DIGITAL_VOLUME_LEFT, (rt_uint16_t)(volume | 0x100UL));
|
|
|
+ if(err == RT_EOK)
|
|
|
+ {
|
|
|
+ err = wm8904_write_register(dev, WM8904_DAC_DIGITAL_VOLUME_RIGHT, (rt_uint16_t)(volume | 0x100UL));
|
|
|
+ }
|
|
|
+ return err;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_module_power(struct drv_sound_wm8904 *dev, wm8904_module_t module, rt_bool_t is_enabled)
|
|
|
+{
|
|
|
+ rt_uint8_t reg_addr = 0, reg_bit_mask = 0U, reg_value = 0U;
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+
|
|
|
+ switch(module)
|
|
|
+ {
|
|
|
+ case WM8904_MODULE_ADC:
|
|
|
+ reg_addr = WM8904_POWER_MGMT_6;
|
|
|
+ reg_bit_mask = 3U;
|
|
|
+ reg_value = is_enabled ? 3U : 0U;
|
|
|
+ break;
|
|
|
+ case WM8904_MODULE_DAC:
|
|
|
+ reg_addr = WM8904_POWER_MGMT_6;
|
|
|
+ reg_bit_mask = 0xCU;
|
|
|
+ reg_value = is_enabled ? 0xCU : 0U;
|
|
|
+ break;
|
|
|
+ case WM8904_MODULE_PGA:
|
|
|
+ reg_addr = WM8904_POWER_MGMT_0;
|
|
|
+ reg_bit_mask = 3U;
|
|
|
+ reg_value = is_enabled ? 3U : 0U;
|
|
|
+ break;
|
|
|
+ case WM8904_MODULE_HEADPHONE:
|
|
|
+ reg_addr = WM8904_POWER_MGMT_2;
|
|
|
+ reg_bit_mask = 3U;
|
|
|
+ reg_value = is_enabled ? 3U : 0U;
|
|
|
+ break;
|
|
|
+ case WM8904_MODULE_LINEOUT:
|
|
|
+ reg_addr = WM8904_POWER_MGMT_3;
|
|
|
+ reg_bit_mask = 3U;
|
|
|
+ reg_value = is_enabled ? 3U : 0U;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ err = -RT_EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(err == RT_EOK)
|
|
|
+ {
|
|
|
+ err = wm8904_modify_register(dev, reg_addr, reg_bit_mask, reg_value);
|
|
|
+ }
|
|
|
+ return err;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_record(struct drv_sound_wm8904 *dev, rt_uint32_t record_source)
|
|
|
+{
|
|
|
+ rt_uint8_t reg_left_addr = WM8904_ANALOG_LEFT_IN_1, reg_right_addr = WM8904_ANALOG_RIGHT_IN_1;
|
|
|
+ rt_uint16_t reg_left_value = 0U, reg_right_value = 0U, reg_bit_mask = 0U;
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+
|
|
|
+ switch(record_source)
|
|
|
+ {
|
|
|
+ case WM8904_RECORD_SOURCE_DIFFERENTIAL_LINE:
|
|
|
+ reg_left_value = 1U;
|
|
|
+ reg_right_value = 1U;
|
|
|
+ reg_bit_mask = 0x3FU;
|
|
|
+ break;
|
|
|
+ case WM8904_RECORD_SOURCE_DIFFERENTIAL_MIC:
|
|
|
+ reg_left_value = 2U;
|
|
|
+ reg_right_value = 2U;
|
|
|
+ reg_bit_mask = 0x3FU;
|
|
|
+ break;
|
|
|
+ case WM8904_RECORD_SOURCE_LINE_INPUT:
|
|
|
+ reg_left_value = 0U;
|
|
|
+ reg_right_value = 0U;
|
|
|
+ reg_bit_mask = 0x3FU;
|
|
|
+ break;
|
|
|
+ case WM8904_RECORD_SOURCE_DIGITAL_MIC:
|
|
|
+ reg_left_value = 1U << 12;
|
|
|
+ reg_left_addr = WM8904_DAC_DIG_0;
|
|
|
+ reg_right_addr = 0U;
|
|
|
+ reg_bit_mask = 1U << 12;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ err = -RT_EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(err != RT_EOK)
|
|
|
+ {
|
|
|
+ return err;
|
|
|
+ }
|
|
|
+ err = wm8904_modify_register(dev, reg_left_addr, reg_bit_mask, reg_left_value);
|
|
|
+ if((err == RT_EOK) && (reg_right_addr != 0U))
|
|
|
+ {
|
|
|
+ err = wm8904_modify_register(dev, reg_right_addr, reg_bit_mask, reg_right_value);
|
|
|
+ }
|
|
|
+ return err;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_record_channel(struct drv_sound_wm8904 *dev, rt_uint32_t left_record_channel, rt_uint32_t right_record_channel)
|
|
|
+{
|
|
|
+ rt_uint8_t reg_left_addr = WM8904_ANALOG_LEFT_IN_1, reg_right_addr = WM8904_ANALOG_RIGHT_IN_1;
|
|
|
+ rt_uint16_t reg_left_value = 0U, reg_right_value = 0U, reg_bit_mask;
|
|
|
+ rt_err_t err = RT_EOK;
|
|
|
+ rt_uint8_t left_positive_channel = 0U, left_negative_channel = 0U, right_positive_channel = 0U, right_negative_channel = 0U;
|
|
|
+
|
|
|
+ if((left_record_channel & (rt_uint32_t)WM8904_RECORD_CHANNEL_DIFFERENTIAL_POSITIVE1) != 0U)
|
|
|
+ {
|
|
|
+ left_positive_channel = 0U;
|
|
|
+ }
|
|
|
+ else if((left_record_channel & (rt_uint32_t)WM8904_RECORD_CHANNEL_DIFFERENTIAL_POSITIVE2) != 0U)
|
|
|
+ {
|
|
|
+ left_positive_channel = 1U;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ left_positive_channel = 2U;
|
|
|
+ }
|
|
|
+
|
|
|
+ if((left_record_channel & (rt_uint32_t)WM8904_RECORD_CHANNEL_DIFFERENTIAL_NEGATIVE1) != 0U)
|
|
|
+ {
|
|
|
+ left_negative_channel = 0U;
|
|
|
+ }
|
|
|
+ else if((left_record_channel & (rt_uint32_t)WM8904_RECORD_CHANNEL_DIFFERENTIAL_NEGATIVE2) != 0U)
|
|
|
+ {
|
|
|
+ left_negative_channel = 1U;
|
|
|
+ }
|
|
|
+ else if((left_record_channel & (rt_uint32_t)WM8904_RECORD_CHANNEL_DIFFERENTIAL_NEGATIVE3) != 0U)
|
|
|
+ {
|
|
|
+ left_negative_channel = 2U;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ left_negative_channel = left_positive_channel;
|
|
|
+ }
|
|
|
+
|
|
|
+ if((right_record_channel & (rt_uint32_t)WM8904_RECORD_CHANNEL_DIFFERENTIAL_POSITIVE1) != 0U)
|
|
|
+ {
|
|
|
+ right_positive_channel = 0U;
|
|
|
+ }
|
|
|
+ else if((right_record_channel & (rt_uint32_t)WM8904_RECORD_CHANNEL_DIFFERENTIAL_POSITIVE2) != 0U)
|
|
|
+ {
|
|
|
+ right_positive_channel = 1U;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ right_positive_channel = 2U;
|
|
|
+ }
|
|
|
+
|
|
|
+ if((right_record_channel & (rt_uint32_t)WM8904_RECORD_CHANNEL_DIFFERENTIAL_NEGATIVE1) != 0U)
|
|
|
+ {
|
|
|
+ right_negative_channel = 0U;
|
|
|
+ }
|
|
|
+ else if((right_record_channel & (rt_uint32_t)WM8904_RECORD_CHANNEL_DIFFERENTIAL_NEGATIVE2) != 0U)
|
|
|
+ {
|
|
|
+ right_negative_channel = 1U;
|
|
|
+ }
|
|
|
+ else if((right_record_channel & (rt_uint32_t)WM8904_RECORD_CHANNEL_DIFFERENTIAL_NEGATIVE3) != 0U)
|
|
|
+ {
|
|
|
+ right_negative_channel = 2U;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ right_negative_channel = right_positive_channel;
|
|
|
+ }
|
|
|
+
|
|
|
+ reg_left_value = (((rt_uint16_t)left_negative_channel & 3U) << 4U) | (((rt_uint16_t)left_positive_channel & 3U) << 2U);
|
|
|
+ reg_right_value = (((rt_uint16_t)right_negative_channel & 3U) << 4U) | (((rt_uint16_t)right_positive_channel & 3U) << 2U);
|
|
|
+ reg_bit_mask = 0x3CU;
|
|
|
+
|
|
|
+ err = wm8904_modify_register(dev, reg_left_addr, reg_bit_mask, reg_left_value);
|
|
|
+ if(err == RT_EOK)
|
|
|
+ {
|
|
|
+ return wm8904_modify_register(dev, reg_right_addr, reg_bit_mask, reg_right_value);
|
|
|
+ }
|
|
|
+ return -RT_ERROR;
|
|
|
+}
|
|
|
+
|
|
|
+rt_err_t wm8904_set_play(struct drv_sound_wm8904 *dev, rt_uint32_t play_source)
|
|
|
+{
|
|
|
+ rt_uint16_t reg_value = 0U, reg_bit_mask = 0xFU;
|
|
|
+
|
|
|
+ /* source from PGA */
|
|
|
+ if(play_source == (rt_uint32_t)WM8904_PLAY_SOURCE_PGA)
|
|
|
+ {
|
|
|
+ reg_value |= (3U << 2U) | 3U;
|
|
|
+ } else
|
|
|
+ /* source from DAC */
|
|
|
+ if(play_source == (rt_uint32_t)WM8904_PLAY_SOURCE_DAC)
|
|
|
+ {
|
|
|
+ reg_value &= (rt_uint16_t) ~((3U << 2U) | 3U);
|
|
|
+ }
|
|
|
+
|
|
|
+ return wm8904_modify_register(dev, WM8904_ANALOG_OUT12_ZC, reg_bit_mask, reg_value);
|
|
|
+}
|
|
|
+
|
|
|
+/*******************************************************************************************/
|
|
|
+rt_err_t wm8904_audio_getcaps(struct rt_audio_device *audio, struct rt_audio_caps *caps)
|
|
|
+{
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+rt_err_t wm8904_audio_configure(struct rt_audio_device *audio, struct rt_audio_caps *caps)
|
|
|
+{
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+rt_err_t wm8904_audio_init(struct rt_audio_device *audio)
|
|
|
+{
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+rt_err_t wm8904_audio_start(struct rt_audio_device *audio, int stream)
|
|
|
+{
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+rt_err_t wm8904_audio_stop(struct rt_audio_device *audio, int stream)
|
|
|
+{
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+rt_ssize_t wm8904_audio_transmit(struct rt_audio_device *audio, const void *writeBuf, void *readBuf, rt_size_t size)
|
|
|
+{
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+void wm8904_audio_buffer_info(struct rt_audio_device *audio, struct rt_audio_buf_info *info)
|
|
|
+{
|
|
|
+}
|
|
|
+/**
|
|
|
+ *
|
|
|
+ */
|
|
|
+struct rt_audio_ops wm8904_audio_ops =
|
|
|
+{
|
|
|
+ .getcaps = wm8904_audio_getcaps,
|
|
|
+ .configure = wm8904_audio_configure,
|
|
|
+ .init = wm8904_audio_init,
|
|
|
+ .start = wm8904_audio_start,
|
|
|
+ .stop = wm8904_audio_stop,
|
|
|
+ .transmit = wm8904_audio_transmit,
|
|
|
+ .buffer_info = wm8904_audio_buffer_info,
|
|
|
+};
|
vandoul