i2s.c

static uint32_t testDataLeft[10];
static uint32_t testDataRight[10];
static uint32_t testRxLeft[10];
static uint32_t testRxRight[10];

static LDMA_TransferCfg_t descConfLeftTx;
static LDMA_TransferCfg_t descConfRightTx;
static LDMA_Descriptor_t descLinkLeftTx[2];
static LDMA_Descriptor_t descLinkRightTx[2];


static LDMA_TransferCfg_t descConfLeftRx;
static LDMA_TransferCfg_t descConfRightRx;
static LDMA_Descriptor_t descLinkLeftRx[2];
static LDMA_Descriptor_t descLinkRightRx[2];

static int32_t setupI2S()
{
    if (codecParams == NULL)
        return 0;

    CMU_ClockEnable(cmuClock_USART1, true);

    GPIO_PinModeSet(gpioPortD, 9, gpioModePushPull, 1);
    GPIO_PinModeSet(gpioPortD, 12, gpioModeInputPull, 0);
    GPIO_PinModeSet(gpioPortD, 10, gpioModePushPull, 1);
    GPIO_PinModeSet(gpioPortD, 11, gpioModePushPull, 1);

    USART_InitI2s_TypeDef init = USART_INITI2S_DEFAULT;
    
    init.sync.databits = usartDatabits16;
    init.delay = false;
    init.sync.enable = usartDisable;
    init.sync.autoTx = true;
    init.format = usartI2sFormatW32D32;
    init.justify = usartI2sJustifyLeft;
    init.dmaSplit = true;
    init.sync.baudrate = 32000 * 64;

    USART_InitI2s(USART1, &init);

    USART1->CTRL |= USART_CTRL_CSINV;

    USART1->ROUTEPEN = USART_ROUTEPEN_TXPEN | USART_ROUTEPEN_RXPEN | USART_ROUTEPEN_CSPEN | USART_ROUTEPEN_CLKPEN;
    USART1->ROUTELOC0 = USART_ROUTELOC0_RXLOC_LOC19 |
                        USART_ROUTELOC0_TXLOC_LOC17 |
                        USART_ROUTELOC0_CSLOC_LOC16 |
                        USART_ROUTELOC0_CLKLOC_LOC16;

    return 1;
}


static int32_t setupLDMA()
{
    CMU_ClockEnable(cmuClock_LDMA, true);

    LDMA_Init_t ldmaInit = LDMA_INIT_DEFAULT;
    ldmaInit.ldmaInitCtrlNumFixed = 0;

    LDMA_Init(&ldmaInit);


    for (int32_t i = 0; i < 10; ++i)
    {
        testDataLeft[i] = 0x12345678;
        testDataRight[i] = 0x87654321 + i;
        testRxLeft[i] = 0;
        testRxRight[i] = 0;
    }

    descConfLeftTx = (LDMA_TransferCfg_t)LDMA_TRANSFER_CFG_PERIPHERAL(ldmaPeripheralSignal_USART1_TXBL);
    descConfRightTx = (LDMA_TransferCfg_t)LDMA_TRANSFER_CFG_PERIPHERAL(ldmaPeripheralSignal_USART1_TXBLRIGHT);


    descLinkLeftTx[0] = (LDMA_Descriptor_t)LDMA_DESCRIPTOR_LINKREL_M2P_BYTE(
                                                                    (uint8_t*)testDataLeft,
                                                                    &USART1->TXDOUBLE,
                                                                    20,
                                                                    0
        );


    descLinkRightTx[0] = (LDMA_Descriptor_t)LDMA_DESCRIPTOR_LINKREL_M2P_BYTE(
                                                                    (uint8_t*)testDataRight,
                                                                    &USART1->TXDOUBLE,
                                                                    20,
                                                                    0
        );




    descLinkLeftTx[0].xfer.blockSize = ldmaCtrlBlockSizeUnit1;
    descLinkLeftTx[0].xfer.ignoreSrec = true;
    descLinkLeftTx[0].xfer.size = ldmaCtrlSizeHalf;
    descLinkLeftTx[0].xfer.doneIfs = 1;

    descLinkRightTx[0].xfer.blockSize = ldmaCtrlBlockSizeUnit1;
    descLinkRightTx[0].xfer.ignoreSrec = true;
    descLinkRightTx[0].xfer.size = ldmaCtrlSizeHalf;
    descLinkRightTx[0].xfer.doneIfs = 1;





    descConfLeftRx = (LDMA_TransferCfg_t)LDMA_TRANSFER_CFG_PERIPHERAL(ldmaPeripheralSignal_USART1_RXDATAV);
    descConfRightRx = (LDMA_TransferCfg_t)LDMA_TRANSFER_CFG_PERIPHERAL(ldmaPeripheralSignal_USART1_RXDATAVRIGHT);

    descLinkLeftRx[0] = (LDMA_Descriptor_t)LDMA_DESCRIPTOR_LINKREL_P2M_BYTE(
                                                                    &USART1->RXDOUBLE,
                                                                    (uint8_t*)testRxLeft,
                                                                    20,
                                                                    0
        );

    descLinkRightRx[0] = (LDMA_Descriptor_t)LDMA_DESCRIPTOR_LINKREL_P2M_BYTE(
                                                                    &USART1->RXDOUBLE,
                                                                    (uint8_t*)testRxRight,
                                                                    20,
                                                                    0
        );



    descLinkLeftRx[0].xfer.blockSize = ldmaCtrlBlockSizeUnit1;
    descLinkLeftRx[0].xfer.ignoreSrec = true;
    descLinkLeftRx[0].xfer.size = ldmaCtrlSizeHalf;
    descLinkLeftRx[0].xfer.doneIfs = 1;

    descLinkRightRx[0].xfer.blockSize = ldmaCtrlBlockSizeUnit1;
    descLinkRightRx[0].xfer.ignoreSrec = true;
    descLinkRightRx[0].xfer.size = ldmaCtrlSizeHalf;
    descLinkRightRx[0].xfer.doneIfs = 1;


    NVIC_ClearPendingIRQ(LDMA_IRQn);
    NVIC_EnableIRQ(LDMA_IRQn);

    return 1;
}


int32_t start()
{
  LDMA_StartTransfer(1, (void *)&descConfRightTx, (void *)&descLinkRightTx);
  LDMA_StartTransfer(3, (void *)&descConfRightRx, (void *)&descLinkRightRx);
  LDMA_StartTransfer(2, (void *)&descConfLeftRx, (void *)&descLinkLeftRx);
  LDMA_StartTransfer(0, (void *)&descConfLeftTx, (void *)&descLinkLeftTx);

  USART_Enable(USART1, usartEnable);

    return 1;
}


int main()
{
  setupI2S();
  setupLDMA();
  
  start();
  
  while(1);
}


void LDMA_IRQHandler()
{
  uint32_t flag = LDMA->IF;
  if (flag & (1 << 0))
  {
    LDMA->IFC = (1 << 0);
  }


  if (flag & (1 << 1))
  {
    LDMA->IFC = (1 << 1);
  }

  if (flag & (1 << 2))
  {
    LDMA->IFC = (1 << 2);
  }

  if (flag & (1 << 3))
  {
    LDMA->IFC = (1 << 3);
  }

}