main.c

Go to the documentation of this file.

/* Includes ------------------------------------------------------------------*/
#include "cmsis_os.h"
#include "FreeRTOSConfig.h"

#include "main.h"
#include "FFT.h"
#include "GUI_pages.h"

#include <string.h>
#include <stdio.h>

#include "ip_addr.h"

/* select if USB or SPDIF Rx is input */
#define USB_AUDIO_INPUT

/* Private typedef -----------------------------------------------------------*/
#if 0
static DMA2D_HandleTypeDef          hdma2d;
#endif
DSI_VidCfgTypeDef                   hdsivideo_handle;
DSI_CmdCfgTypeDef                   CmdCfg;
DSI_LPCmdTypeDef                    LPCmd;
DSI_PLLInitTypeDef                  dsiPllInit;
static RCC_PeriphCLKInitTypeDef     PeriphClkInitStruct;
DMA_HandleTypeDef                   hSaiDma;

SPDIFRX_HandleTypeDef               hspdif;
DMA_HandleTypeDef                   hdma_spdif_rx_dt;

/* Private define ------------------------------------------------------------*/

#define VSYNC               1 
#define VBP                 1 
#define VFP                 1
#define VACT                480
#define HSYNC               1
#define HBP                 1
#define HFP                 1
#define HACT                800

#define LAYER0_ADDRESS                  (LCD_FB_START_ADDRESS)

/* Private macro -------------------------------------------------------------*/
#define DEFAULT_THREAD_STACKSIZE        500
#define AUDIO_THREAD_PRIO               (tskIDLE_PRIORITY+2)    //osPriorityNormal
#define UARTCMD_THREAD_PRIO             (tskIDLE_PRIORITY+1)    //osPriorityNormal

/* Private variables ---------------------------------------------------------*/
static __IO int32_t  front_buffer       = 0;
static __IO int32_t  pend_buffer        = -1;

static const uint32_t Buffers[] = 
{
  LAYER0_ADDRESS,
  LAYER0_ADDRESS + (800*480*4),  
};

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
void MPU_Config(void);
void CPU_CACHE_Enable(void);

static void OnError_Handler(uint32_t condition);
#if 0
static void CopyBuffer(uint32_t *pSrc, 
                           uint32_t *pDst, 
                           uint16_t x, 
                           uint16_t y, 
                           uint16_t xsize, 
                           uint16_t ysize);
#endif
static uint8_t LCD_Init(void);
void LTDC_Init(void);
static int GetInterfaceSelection(int *outSelection, int *sampleRate);
static void LCD_Config(void);

static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_SPDIFRX_Init(void);

static void Audio_Thread(void const * argument);

extern void http_taskCreate(void);

SemaphoreHandle_t xSemaphoreAudio;
xTaskHandle CreatedTaskAudio;

#ifdef UART_THREAD
static void UARTCmd_Thread(void const * argument);
SemaphoreHandle_t xSemaphoreUART;
xTaskHandle CreatedTaskUART;
#endif

#define SCRATCH_BUFF_SIZE  (AUDIO_OUT_BUFFER_SIZE/sizeof(int32_t))
int32_t Scratch [SCRATCH_BUFF_SIZE];

/* Private functions ---------------------------------------------------------*/

static void OnError_Handler(uint32_t condition)
{
  if(condition)
  {
    BSP_LED_On(LED1);
    while(1) { ; } /* Blocking on error */
  }
}

static void TIM_Start(void)
{
  /* for stop watch */
  __HAL_RCC_TIM2_CLK_ENABLE();
  __HAL_RCC_TIMCLKPRESCALER(RCC_TIMPRES_ACTIVATED);
  hTim2.Instance = TIM2;
  hTim2.Instance->ARR = 0xFFFFFFFF;
  __HAL_TIM_ENABLE(&hTim2);
}

int main_audio(void)
{
  /* Enable the MPU */
  MPU_Config();

  /* Enable the CPU Cache */
  CPU_CACHE_Enable();

  /* Configure the system clock to 216 or 200 MHz if with DDR RAM */
  SystemClock_Config();
  SystemCoreClockUpdate();

  /* STM32F7xx HAL library initialization:
       - Configure the Flash prefetch
       - Systick timer is configured by default as source of time base, but user 
         can eventually implement his proper time base source (a general purpose 
         timer for example or other time source), keeping in mind that Time base 
         duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and 
         handled in milliseconds basis.
       - Set NVIC Group Priority to 4
       - Low Level Initialization
     */
  HAL_Init();

  /* Initialize used Leds */
  BSP_LED_Init(LED1);

  /* Initialize the SDRAM - needed for DSI LCD */
  BSP_SDRAM_Init();

  //initialize QSPI
  BSP_QSPI_Init();

  //Enable QSPI memory mapped mode
  BSP_QSPI_EnableMemoryMappedMode();

  /* Initialize the LCD */
  LCD_Config();

  BSP_TS_Init(800, 480);

  /* create semaphores for the threads - we have to do before we start scheduler! */            //Give must be called, otherwise semaphore is empty
  vSemaphoreCreateBinary(xSemaphoreAudio);
#ifdef UART_THREAD
  vSemaphoreCreateBinary(xSemaphoreUART);
#endif

#if 0
  /* Init threads - we have to create all tasks before scheduler launched! */
  xTaskCreate((TaskFunction_t)Audio_Thread, (const portCHAR *)"Audio", DEFAULT_THREAD_STACKSIZE, NULL, AUDIO_THREAD_PRIO, &CreatedTaskAudio);
#ifdef UART_THREAD
  UART_cmd_init();
  xTaskCreate((TaskFunction_t)UARTCmd_Thread, (const portCHAR *)"UARTCmd", DEFAULT_THREAD_STACKSIZE, NULL, UARTCMD_THREAD_PRIO, &CreatedTaskUART);
#endif

  /* Start scheduler */
  vTaskStartScheduler();
#else
#if defined(__GNUC__)
  osThreadDef(Audio, Audio_Thread, AUDIO_THREAD_PRIO, 0, configMINIMAL_STACK_SIZE * 6);
#else
  osThreadDef(Start, Audio_Thread, AUDIO_THREAD_PRIO, 0, configMINIMAL_STACK_SIZE * 6);
#endif

  osThreadCreate(osThread(Audio), NULL);

  http_taskCreate();

  /* Start scheduler */
  osKernelStart();
#endif

  /* We should never get here as control is now taken by the scheduler */
  for( ;; );
}

static void Audio_Thread(void const * argument)
{
  int ifSelection, outSelection;
  int sampleFreq = 48000;               //will be changed by config

  /* after Touch init - get the selection but before DSI_Refresh because it displays text */
  ifSelection = GetInterfaceSelection(&outSelection, &sampleFreq);

  /*Refresh the LCD display*/
  HAL_DSI_Refresh(&hdsi_discovery);

  /* Init Audio interface - important to do in this order */
  AUDIO_PLAYER_Init(outSelection, sampleFreq);

  /* SPDIF Tx Out - always active */
  SPDIF_Tx_Init();

  /* Network Audio selection: 48KHz, 16bit */
  if (ifSelection == 4)
  {
      //similar to USB but nothing else to do here
  }

  /* select here between USB, SPDIF_Rx, MIC, ... as input */
  if (ifSelection == 3)
  {
      /* Line In Init */
      int bufSize;
      uint8_t *buffer;

      BSP_AUDIO_IN_InitEx(INPUT_DEVICE_INPUT_LINE_1, sampleFreq, DEFAULT_AUDIO_IN_BIT_RESOLUTION, DEFAULT_AUDIO_IN_CHANNEL_NBR);
      bufSize = AUDIO_PLAYER_GetBuffer(&buffer);
      BSP_AUDIO_IN_Record((uint16_t*)buffer, bufSize /(sizeof(uint16_t)));
  }

  if (ifSelection == 2)
  {
      //use onboard MICs
      int bufSize;
      uint8_t *buffer;

      BSP_AUDIO_IN_Init(sampleFreq, DEFAULT_AUDIO_IN_BIT_RESOLUTION, DEFAULT_AUDIO_IN_CHANNEL_NBR);
      BSP_AUDIO_IN_AllocScratch(Scratch, SCRATCH_BUFF_SIZE); //it is needed but what is the size of the buffer?
      bufSize = AUDIO_PLAYER_GetBuffer(&buffer);
      BSP_AUDIO_IN_Record((uint16_t*)buffer, bufSize / (sizeof(uint16_t)));
  }

  if (ifSelection == 1)
  {
      /* USB Audio Init */
      USB_Interface(0);
  }

  if (ifSelection == 0)
  {
      /* Init SPDIF Rx */
      MX_GPIO_Init();
      MX_DMA_Init();
      MX_SPDIFRX_Init();

      /* start SPDIF Rx */
      SPDIF_RX_Start();
  }

  //now start the audio output functions
  AUDIO_PLAYER_Start();

  /* SPDIF Tx Out - always active */
  SPDIF_Tx_Start();

  /* init FFT */
  FFT_Init();

  /* TIM for CPU load measurement */
  TIM_Start();

  /* Infinite loop */
  while (1)
  {
    TIM_MEASURE_BEGIN;

    if (AUDIO_PLAYER_GetClock())
    {
        TIM_MEASURE_START;  // start stop watch

        //check if we have audio in received - if not - clear the buffers
        AUDIO_Player_GetHeartbeat();

        {
            extern ip_addr_t UDANTE_IPAddr;
            extern u16_t UDANTE_UDPPort;
            extern void Netif_AddUDANTE(ip_addr_t ipAddr);
            extern void main_UDanteUDP(void);

            static int done = 0;
            if ((UDANTE_IPAddr.addr != 0) && ( ! done))
            {
                Netif_AddUDANTE(UDANTE_IPAddr);
                main_UDanteUDP();
                done = 1;

                {
                    //print where found DANTE audio stream
                    uint8_t iptxt[20];
                    sprintf((char*)iptxt, "uDANTE: %ld.%ld.%ld.%ld | %d", UDANTE_IPAddr.addr & 0xFF, UDANTE_IPAddr.addr >> 8 & 0xFF, UDANTE_IPAddr.addr >> 16 & 0xFF, UDANTE_IPAddr.addr >> 24 & 0xFF,
                            UDANTE_UDPPort);

                    BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
                    BSP_LCD_DisplayStringAt(380, 100, (uint8_t *)iptxt, LEFT_MODE);
                }
            }
        }

        //if we touch Peak Meter - stop all
        {
            TS_StateTypeDef tsState;

            BSP_TS_GetState(&tsState);
            if (tsState.touchDetected)
            {
                if (tsState.touchY[0] < FFT_Y_BORDER_TOP)
                    goto END;
            }
        }

        VUMETER_Analyse();
        VUMETER_Input(0);
        VUMETER_Input(1);
        VUMETER_Display(0);
        VUMETER_Display(1);

        FFT_Filter(0);
        FFT_DisplayGraph(0);

        FFT_Filter(1);
        FFT_DisplayGraph(1);

END:
        //display CPU load in percentage
        {
            static float sMaxLoad = 0.0f;
            int sMaxLoadInt;
            float load;
            char text [10];

            load = (float)((100.0 * (float)time_diff) / (float)time_total);
            if (sMaxLoad < load)
                sMaxLoad = load;
            sMaxLoadInt = (int)(sMaxLoad * 10.0);
            sprintf(text, "%3d.%1d%%", sMaxLoadInt / 10, sMaxLoadInt % 10);         //keep text shortest as possible
            //BSP_LCD_SetFont(&Font16);                 //use smaller font here
            if (sMaxLoad > 30.0f)
                BSP_LCD_SetTextColor(LCD_COLOR_LIGHTRED);
            else
                BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
            BSP_LCD_DisplayStringAt(715, FFT_Y_BORDER_TOP + 130, (uint8_t *)text, LEFT_MODE);
            if (sMaxLoad > 0.05f)
                sMaxLoad -= 0.05f;
        }

        /*Refresh the LCD display*/
        HAL_DSI_Refresh(&hdsi_discovery);

        TIM_MEASURE_END;                        // stop stop watch for audio processing
        TIM_MEASURE_TOTAL;                      //total time for audio sample loops
    }
  }
}
void LCD_Config(void)
{
  uint8_t  lcd_status = LCD_OK;

  /* LCD Initialization Layer 0 */
  lcd_status = LCD_Init();
  OnError_Handler(lcd_status != LCD_OK);

  BSP_LCD_LayerDefaultInit(0, LAYER0_ADDRESS);
  BSP_LCD_SelectLayer(0);

  /* Enable the LCD */
  BSP_LCD_DisplayOn();
}

int GetInterfaceSelection(int *outSelection, int *sampleRate)
{
    TS_StateTypeDef tsState;
    int ret = -1;

    *outSelection = 1;                  //default, in case we do not select
    *sampleRate = I2S_AUDIOFREQ_48K;

    /* set the background layer */
    //BSP_LCD_SelectLayer(0);
    //BSP_LCD_SelectLayer(1);
    BSP_LCD_DrawBitmap(0, 0, (uint8_t *)PAGE_SPLASH);

    /*Refresh the LCD display*/
    HAL_DSI_Refresh(&hdsi_discovery);

    HAL_Delay(100); /* let us see the splash screen */

    //with BMP as background
    while (1)
    {
        BSP_TS_GetState(&tsState);
        if (tsState.touchDetected)
        {
            if ((tsState.touchY[0] > 44) && (tsState.touchY[0] < 144))
            {
                if ((tsState.touchX[0] > 260) && (tsState.touchX[0] < 360))
                {
                    *sampleRate = I2S_AUDIOFREQ_48K;
                }
                if ((tsState.touchX[0] > 660) && (tsState.touchX[0] < 760))
                {
                    *sampleRate = I2S_AUDIOFREQ_44K;
                }
            }

            if ((tsState.touchY[0] > 200) && (tsState.touchY[0] < 300))
            {
                if ((tsState.touchX[0] > 260) && (tsState.touchX[0] < 360))
                {
                    *outSelection = 0;
                }
                if ((tsState.touchX[0] > 660) && (tsState.touchX[0] < 760))
                {
                    *outSelection = 1;
                }
                if ((tsState.touchX[0] > 390) && (tsState.touchX[0] < 620))
                {
                    //Network Audio selection
                    *sampleRate = I2S_AUDIOFREQ_48K;
                    ret = 4;
                    break;
                }
            }

            if ((tsState.touchY[0] > 356) && (tsState.touchY[0] < 456))
            {
                if ((tsState.touchX[0] >  60) && (tsState.touchX[0] < 160))
                {
                    ret = 0;
                    break;
                }
                if ((tsState.touchX[0] > 260) && (tsState.touchX[0] < 360))
                {
                    ret = 2;
                    break;
                }
                if ((tsState.touchX[0] > 460) && (tsState.touchX[0] < 560))
                {
                    ret = 1;
                    break;
                }
                if ((tsState.touchX[0] > 660) && (tsState.touchX[0] < 760))
                {
                    ret = 3;
                    break;
                }
            }
        }
    }

    //BSP_LCD_SelectLayer(1);

    BSP_LCD_SetFont(&Font12);
    //BSP_LCD_SetBackColor(LCD_COLOR_TRANSPARENT);
    BSP_LCD_SetBackColor(LCD_COLOR_BLACK);

    //clear all
    BSP_LCD_FillRect(0, 0, 800, 480);

    //display left and right
    BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
    BSP_LCD_DisplayStringAt(  2,  0, (uint8_t *)"LEFT", LEFT_MODE);
    BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
    BSP_LCD_DisplayStringAt(  2, 60, (uint8_t *)"RIGHT", LEFT_MODE);

    BSP_LCD_SetTextColor(LCD_COLOR_WHITE);

    //create labels for the Peak Meter
    BSP_LCD_DisplayStringAt(  45, 0, (uint8_t *)"-30", LEFT_MODE);
    BSP_LCD_DisplayStringAt( 168, 0, (uint8_t *)"-20", LEFT_MODE);
    BSP_LCD_DisplayStringAt( 478, 0, (uint8_t *)"-10", LEFT_MODE);
    BSP_LCD_DisplayStringAt( 697, 0, (uint8_t *)"-7", LEFT_MODE);
    BSP_LCD_DisplayStringAt( 760, 0, (uint8_t *)"-6dB", LEFT_MODE);

    //create X, Y axis labels for FFT
    BSP_LCD_DisplayStringAt( 46, FFT_Y_BORDER_TOP - 10, (uint8_t *)"1K", LEFT_MODE);
    BSP_LCD_DisplayStringAt( 88, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(124, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(160, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(197, FFT_Y_BORDER_TOP - 10, (uint8_t *)"5K", LEFT_MODE);
    BSP_LCD_DisplayStringAt(236, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(272, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(313, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(349, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(380, FFT_Y_BORDER_TOP - 10, (uint8_t *)"10K", LEFT_MODE);
    BSP_LCD_DisplayStringAt(424, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(460, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(495, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(535, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(569, FFT_Y_BORDER_TOP - 10, (uint8_t *)"15K", LEFT_MODE);
    BSP_LCD_DisplayStringAt(608, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(644, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(684, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(721, FFT_Y_BORDER_TOP - 10, (uint8_t *)"|", LEFT_MODE);
    BSP_LCD_DisplayStringAt(758, FFT_Y_BORDER_TOP - 10, (uint8_t *)"20KHz", LEFT_MODE);

#if 0
    /* Copy Buffer 0 into buffer 1, so only image area to be redrawn later */
    CopyBuffer((uint32_t *)Buffers[0], (uint32_t *)Buffers[1], 0, 0, 800, 480);
#endif

    return ret;
}

void HAL_DSI_EndOfRefreshCallback(DSI_HandleTypeDef *hdsi)
{
  if(pend_buffer >= 0)
  { 
    /* Disable DSI Wrapper */
    __HAL_DSI_WRAPPER_DISABLE(&hdsi_discovery);
    /* Update LTDC configuration */
    LTDC_LAYER(&hltdc_discovery, 0)->CFBAR = ((uint32_t)Buffers[pend_buffer]);
    __HAL_LTDC_RELOAD_CONFIG(&hltdc_discovery);
    /* Enable DSI Wrapper */
    __HAL_DSI_WRAPPER_ENABLE(&hdsi_discovery);
    
    front_buffer = pend_buffer;  
    pend_buffer = -1;
  }
}

static uint8_t LCD_Init(void)
{
  /* Toggle Hardware Reset of the DSI LCD using
  * its XRES signal (active low) */
  BSP_LCD_Reset();
  
  /* Call first MSP Initialize only in case of first initialization
  * This will set IP blocks LTDC, DSI and DMA2D
  * - out of reset
  * - clocked
  * - NVIC IRQ related to IP blocks enabled
  */
  BSP_LCD_MspInit();
  
  /* LCD clock configuration */
  /* PLLSAI_VCO Input = HSE_VALUE/PLL_M = 1 Mhz */
  /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN = 417 Mhz */
  /* PLLLCDCLK = PLLSAI_VCO Output/PLLSAIR = 417 MHz / 5 = 83.4 MHz */
  /* LTDC clock frequency = PLLLCDCLK / LTDC_PLLSAI_DIVR_2 = 83.4 / 2 = 41.7 MHz */
  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC;
  PeriphClkInitStruct.PLLSAI.PLLSAIN = 417;
  PeriphClkInitStruct.PLLSAI.PLLSAIR = 5;
  PeriphClkInitStruct.PLLSAIDivR = RCC_PLLSAIDIVR_2;
  HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
  
  /* Base address of DSI Host/Wrapper registers to be set before calling De-Init */
  hdsi_discovery.Instance = DSI;
  
  HAL_DSI_DeInit(&(hdsi_discovery));
  
  dsiPllInit.PLLNDIV  = 100;
  dsiPllInit.PLLIDF   = DSI_PLL_IN_DIV5;
  dsiPllInit.PLLODF   = DSI_PLL_OUT_DIV1;  

  hdsi_discovery.Init.NumberOfLanes = DSI_TWO_DATA_LANES;
  hdsi_discovery.Init.TXEscapeCkdiv = 0x4;
  HAL_DSI_Init(&(hdsi_discovery), &(dsiPllInit));
    
  /* Configure the DSI for Command mode */
  CmdCfg.VirtualChannelID      = 0;
  CmdCfg.HSPolarity            = DSI_HSYNC_ACTIVE_HIGH;
  CmdCfg.VSPolarity            = DSI_VSYNC_ACTIVE_HIGH;
  CmdCfg.DEPolarity            = DSI_DATA_ENABLE_ACTIVE_HIGH;
  CmdCfg.ColorCoding           = DSI_RGB888;
  CmdCfg.CommandSize           = HACT;
  CmdCfg.TearingEffectSource   = DSI_TE_DSILINK;
  CmdCfg.TearingEffectPolarity = DSI_TE_RISING_EDGE;
  CmdCfg.VSyncPol              = DSI_VSYNC_FALLING;
  CmdCfg.AutomaticRefresh      = DSI_AR_DISABLE;
  CmdCfg.TEAcknowledgeRequest  = DSI_TE_ACKNOWLEDGE_ENABLE;
  HAL_DSI_ConfigAdaptedCommandMode(&hdsi_discovery, &CmdCfg);
  
  LPCmd.LPGenShortWriteNoP    = DSI_LP_GSW0P_ENABLE;
  LPCmd.LPGenShortWriteOneP   = DSI_LP_GSW1P_ENABLE;
  LPCmd.LPGenShortWriteTwoP   = DSI_LP_GSW2P_ENABLE;
  LPCmd.LPGenShortReadNoP     = DSI_LP_GSR0P_ENABLE;
  LPCmd.LPGenShortReadOneP    = DSI_LP_GSR1P_ENABLE;
  LPCmd.LPGenShortReadTwoP    = DSI_LP_GSR2P_ENABLE;
  LPCmd.LPGenLongWrite        = DSI_LP_GLW_ENABLE;
  LPCmd.LPDcsShortWriteNoP    = DSI_LP_DSW0P_ENABLE;
  LPCmd.LPDcsShortWriteOneP   = DSI_LP_DSW1P_ENABLE;
  LPCmd.LPDcsShortReadNoP     = DSI_LP_DSR0P_ENABLE;
  LPCmd.LPDcsLongWrite        = DSI_LP_DLW_ENABLE;
  HAL_DSI_ConfigCommand(&hdsi_discovery, &LPCmd);

  /* Initialize LTDC */
  LTDC_Init();
  
  /* Start DSI */
  HAL_DSI_Start(&(hdsi_discovery));
    
  /* Initialize the OTM8009A LCD Display IC Driver (KoD LCD IC Driver)
  *  depending on configuration set in 'hdsivideo_handle'.
  */
  OTM8009A_Init(OTM8009A_COLMOD_RGB888, LCD_ORIENTATION_LANDSCAPE);
  
  LPCmd.LPGenShortWriteNoP    = DSI_LP_GSW0P_DISABLE;
  LPCmd.LPGenShortWriteOneP   = DSI_LP_GSW1P_DISABLE;
  LPCmd.LPGenShortWriteTwoP   = DSI_LP_GSW2P_DISABLE;
  LPCmd.LPGenShortReadNoP     = DSI_LP_GSR0P_DISABLE;
  LPCmd.LPGenShortReadOneP    = DSI_LP_GSR1P_DISABLE;
  LPCmd.LPGenShortReadTwoP    = DSI_LP_GSR2P_DISABLE;
  LPCmd.LPGenLongWrite        = DSI_LP_GLW_DISABLE;
  LPCmd.LPDcsShortWriteNoP    = DSI_LP_DSW0P_DISABLE;
  LPCmd.LPDcsShortWriteOneP   = DSI_LP_DSW1P_DISABLE;
  LPCmd.LPDcsShortReadNoP     = DSI_LP_DSR0P_DISABLE;
  LPCmd.LPDcsLongWrite        = DSI_LP_DLW_DISABLE;
  HAL_DSI_ConfigCommand(&hdsi_discovery, &LPCmd);
  
   HAL_DSI_ConfigFlowControl(&hdsi_discovery, DSI_FLOW_CONTROL_BTA);
  /* Refresh the display */
  HAL_DSI_Refresh(&hdsi_discovery);
  
  return LCD_OK; 
}

void LTDC_Init(void)
{
  /* DeInit */
  HAL_LTDC_DeInit(&hltdc_discovery);
  
  /* LTDC Config */
  /* Timing and polarity */
  hltdc_discovery.Init.HorizontalSync = HSYNC;
  hltdc_discovery.Init.VerticalSync = VSYNC;
  hltdc_discovery.Init.AccumulatedHBP = HSYNC+HBP;
  hltdc_discovery.Init.AccumulatedVBP = VSYNC+VBP;
  hltdc_discovery.Init.AccumulatedActiveH = VSYNC+VBP+VACT;
  hltdc_discovery.Init.AccumulatedActiveW = HSYNC+HBP+HACT;
  hltdc_discovery.Init.TotalHeigh = VSYNC+VBP+VACT+VFP;
  hltdc_discovery.Init.TotalWidth = HSYNC+HBP+HACT+HFP;
  
  /* background value */
  hltdc_discovery.Init.Backcolor.Blue = 0;
  hltdc_discovery.Init.Backcolor.Green = 0;
  hltdc_discovery.Init.Backcolor.Red = 0;
  
  /* Polarity */
  hltdc_discovery.Init.HSPolarity = LTDC_HSPOLARITY_AL;
  hltdc_discovery.Init.VSPolarity = LTDC_VSPOLARITY_AL;
  hltdc_discovery.Init.DEPolarity = LTDC_DEPOLARITY_AL;
  hltdc_discovery.Init.PCPolarity = LTDC_PCPOLARITY_IPC;
  hltdc_discovery.Instance = LTDC;

  HAL_LTDC_Init(&hltdc_discovery);
}

#if 0

static void CopyBuffer(uint32_t *pSrc, uint32_t *pDst, uint16_t x, uint16_t y, uint16_t xsize, uint16_t ysize)
{   
  uint32_t destination = (uint32_t)pDst + (y * 800 + x) * 4;
  uint32_t source      = (uint32_t)pSrc;
  
  /*##-1- Configure the DMA2D Mode, Color Mode and output offset #############*/ 
  hdma2d.Init.Mode         = DMA2D_M2M;
  hdma2d.Init.ColorMode    = DMA2D_OUTPUT_ARGB8888;
  hdma2d.Init.OutputOffset = 800 - xsize;
  hdma2d.Init.AlphaInverted = DMA2D_REGULAR_ALPHA;  /* No Output Alpha Inversion*/  
  hdma2d.Init.RedBlueSwap   = DMA2D_RB_REGULAR;     /* No Output Red & Blue swap */    
  
  /*##-2- DMA2D Callbacks Configuration ######################################*/
  hdma2d.XferCpltCallback  = NULL;
  
  /*##-3- Foreground Configuration ###########################################*/
  hdma2d.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
  hdma2d.LayerCfg[1].InputAlpha = 0xFF;
  hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_ARGB8888;
  hdma2d.LayerCfg[1].InputOffset = 0;
  hdma2d.LayerCfg[1].RedBlueSwap = DMA2D_RB_REGULAR; /* No ForeGround Red/Blue swap */
  hdma2d.LayerCfg[1].AlphaInverted = DMA2D_REGULAR_ALPHA; /* No ForeGround Alpha inversion */  

  hdma2d.Instance          = DMA2D; 
   
  /* DMA2D Initialization */
  if(HAL_DMA2D_Init(&hdma2d) == HAL_OK) 
  {
    if(HAL_DMA2D_ConfigLayer(&hdma2d, 1) == HAL_OK) 
    {
      if (HAL_DMA2D_Start(&hdma2d, source, destination, xsize, ysize) == HAL_OK)
      {
        /* Polling For DMA transfer */  
        HAL_DMA2D_PollForTransfer(&hdma2d, 100);
      }
    }
  }   
}
#endif

void MPU_Config(void)
{
  MPU_Region_InitTypeDef MPU_InitStruct;

  /* Disable the MPU */
  HAL_MPU_Disable();

  /* Configure the MPU attributes as WT for SRAM */
  MPU_InitStruct.Enable = MPU_REGION_ENABLE;
  MPU_InitStruct.BaseAddress = 0x20010000;                      //0x20020000
  MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;
  MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
  MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
  MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
  MPU_InitStruct.Number = MPU_REGION_NUMBER0;
  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
  MPU_InitStruct.SubRegionDisable = 0x00;
  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;

  HAL_MPU_ConfigRegion(&MPU_InitStruct);

  /* Configure the MPU attributes as WT for SDRAM */
  MPU_InitStruct.Enable = MPU_REGION_ENABLE;
  MPU_InitStruct.BaseAddress = 0xC0000000;
  MPU_InitStruct.Size = MPU_REGION_SIZE_256MB;
  MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
  MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
  MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
  MPU_InitStruct.Number = MPU_REGION_NUMBER2;
  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
  MPU_InitStruct.SubRegionDisable = 0x00;
  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;

  HAL_MPU_ConfigRegion(&MPU_InitStruct);

  /* Configure the MPU attributes as WT for SDRAM */
  MPU_InitStruct.Enable = MPU_REGION_ENABLE;
  MPU_InitStruct.BaseAddress = 0xC0000000;
  MPU_InitStruct.Size = MPU_REGION_SIZE_8MB;
  MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
  MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
  MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
  MPU_InitStruct.Number = MPU_REGION_NUMBER3;
  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
  MPU_InitStruct.SubRegionDisable = 0x00;
  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;

  HAL_MPU_ConfigRegion(&MPU_InitStruct);

  /* Configure the MPU attributes as strongly ordred for QSPI (unused zone) */
  MPU_InitStruct.Enable = MPU_REGION_ENABLE;
  MPU_InitStruct.BaseAddress = 0x90000000;
  MPU_InitStruct.Size = MPU_REGION_SIZE_256MB;
  MPU_InitStruct.AccessPermission = MPU_REGION_PRIV_RO;
  MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
  MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
  MPU_InitStruct.Number = MPU_REGION_NUMBER4;
  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
  MPU_InitStruct.SubRegionDisable = 0x00;
  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;

  HAL_MPU_ConfigRegion(&MPU_InitStruct);

  /* Configure the MPU attributes as WT for QSPI (used 16Mbytes) */
  MPU_InitStruct.Enable = MPU_REGION_ENABLE;
  MPU_InitStruct.BaseAddress = 0x90000000;
  MPU_InitStruct.Size = MPU_REGION_SIZE_16MB;
  MPU_InitStruct.AccessPermission = MPU_REGION_PRIV_RO;
  MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
  MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
  MPU_InitStruct.Number = MPU_REGION_NUMBER5;
  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
  MPU_InitStruct.SubRegionDisable = 0x00;
  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;

  HAL_MPU_ConfigRegion(&MPU_InitStruct);

  /* Enable the MPU */
  HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
}

void SystemClock_Config(void)
{
  RCC_ClkInitTypeDef RCC_ClkInitStruct;
  RCC_OscInitTypeDef RCC_OscInitStruct;
  HAL_StatusTypeDef ret = HAL_OK;

  /* Enable HSE Oscillator and activate PLL with HSE as source */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 25;
  RCC_OscInitStruct.PLL.PLLN = 400;                 //was 400, for 200 MHz - needed if DDR RAM!, otherwise 432 for 216 MHz
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 8;                   //9 for 216MHz, 8 for 200 MHz with PLLN 400;
  //RCC_OscInitStruct.PLL.PLLR = 7;                 //should be default 2
  
  ret = HAL_RCC_OscConfig(&RCC_OscInitStruct);
  if(ret != HAL_OK)
  {
    while(1) { ; }
  }
  
  /* Activate the OverDrive to reach the 216/200 MHz Frequency */
  ret = HAL_PWREx_EnableOverDrive();
  if(ret != HAL_OK)
  {
      while(1) { ; }
  }

  //if with 200 MHz HSE Clock - USB needs other clock setting for 48MHz on USB
  /* Select PLLSAI output as USB clock source */
  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_CLK48;
  PeriphClkInitStruct.Clk48ClockSelection = RCC_CLK48SOURCE_PLLSAIP;
  PeriphClkInitStruct.PLLSAI.PLLSAIN = 384;
  PeriphClkInitStruct.PLLSAI.PLLSAIQ = 7;
  PeriphClkInitStruct.PLLSAI.PLLSAIP = RCC_PLLSAIP_DIV8;
  if(HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct)  != HAL_OK)
  {
      while(1) { ; }
  }
  
  /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2 clocks dividers */
  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;  
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2; 
  
  ret = HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4); //FLASH_LATENCY_5 or _6 - unreliable with _5?
  if(ret != HAL_OK)
  {
      while(1) { ; }
  }

  //it results in 96KHz SPDIFRX clock - but for 48KHz SPDIF Rx
  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_SPDIFRX;
  PeriphClkInitStruct.PLLI2S.PLLI2SN = 192;
  PeriphClkInitStruct.PLLI2S.PLLI2SP = RCC_PLLP_DIV2;
  PeriphClkInitStruct.PLLI2S.PLLI2SR = 2;
  PeriphClkInitStruct.PLLI2S.PLLI2SQ = 2;
  PeriphClkInitStruct.PLLI2SDivQ = 1;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
  {
      return;
  }
}

void CPU_CACHE_Enable(void)
{
  /* Enable I-Cache */
  SCB_EnableICache();

  /* Enable D-Cache */
  SCB_EnableDCache();
}

/* SPDIFRX init function */
static void MX_SPDIFRX_Init(void)
{
  hspdif.Instance = SPDIFRX;
  hspdif.Init.InputSelection = SPDIFRX_INPUT_IN1;
  hspdif.Init.Retries = SPDIFRX_MAXRETRIES_NONE;
  hspdif.Init.WaitForActivity = SPDIFRX_WAITFORACTIVITY_ON; //SPDIFRX_WAITFORACTIVITY_OFF;
  hspdif.Init.ChannelSelection = SPDIFRX_CHANNEL_A;
  hspdif.Init.DataFormat = SPDIFRX_DATAFORMAT_32BITS;       //SPDIFRX_DATAFORMAT_LSB;
  hspdif.Init.StereoMode = SPDIFRX_STEREOMODE_ENABLE;       //SPDIFRX_STEREOMODE_DISABLE;
  hspdif.Init.PreambleTypeMask = SPDIFRX_PREAMBLETYPEMASK_OFF;
  hspdif.Init.ChannelStatusMask = SPDIFRX_CHANNELSTATUS_OFF;
  hspdif.Init.ValidityBitMask = SPDIFRX_VALIDITYMASK_OFF;
  hspdif.Init.ParityErrorMask = SPDIFRX_PARITYERRORMASK_OFF;
  if (HAL_SPDIFRX_Init(&hspdif) != HAL_OK)
  {
    return;
  }
}

static void MX_DMA_Init(void)
{
  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA1_Stream1_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
}

static void MX_GPIO_Init(void)
{
  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOG_CLK_ENABLE();

}

void BSP_AUDIO_IN_TransferComplete_CallBack(void)
{

}

void BSP_AUDIO_IN_HalfTransfer_CallBack(void)
{

}

#ifdef  USE_FULL_ASSERT

void assert_failed(uint8_t *file, uint32_t line)
{
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* Infinite loop */
  while (1)
  {
  }
}
#endif

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/