Initialization and de-initialization functions

Initialization and Configuration functions. More...

Functions
HAL_StatusTypeDef	HAL_DMA2D_Init (DMA2D_HandleTypeDef *hdma2d)
	Initialize the DMA2D according to the specified parameters in the DMA2D_InitTypeDef and create the associated handle. More...
HAL_StatusTypeDef	HAL_DMA2D_DeInit (DMA2D_HandleTypeDef *hdma2d)
	Deinitializes the DMA2D peripheral registers to their default reset values. More...
void	HAL_DMA2D_MspInit (DMA2D_HandleTypeDef *hdma2d)
	Initializes the DMA2D MSP. More...
void	HAL_DMA2D_MspDeInit (DMA2D_HandleTypeDef *hdma2d)
	DeInitializes the DMA2D MSP. More...
HAL_StatusTypeDef	HAL_DMA2D_RegisterCallback (DMA2D_HandleTypeDef *hdma2d, HAL_DMA2D_CallbackIDTypeDef CallbackID, pDMA2D_CallbackTypeDef pCallback)
	Register a User DMA2D Callback To be used instead of the weak (surcharged) predefined callback. More...
HAL_StatusTypeDef	HAL_DMA2D_UnRegisterCallback (DMA2D_HandleTypeDef *hdma2d, HAL_DMA2D_CallbackIDTypeDef CallbackID)
	Unregister a DMA2D Callback DMA2D Callback is redirected to the weak (surcharged) predefined callback. More...

Detailed Description

Initialization and Configuration functions.

 ===============================================================================
                ##### Initialization and Configuration functions #####
 ===============================================================================
    [..]  This section provides functions allowing to:
      (+) Initialize and configure the DMA2D
      (+) De-initialize the DMA2D

Function Documentation

HAL_DMA2D_DeInit()

HAL_StatusTypeDef HAL_DMA2D_DeInit

(

DMA2D_HandleTypeDef *

hdma2d

)

Deinitializes the DMA2D peripheral registers to their default reset values.

Parameters

hdma2d

pointer to a DMA2D_HandleTypeDef structure that contains the configuration information for the DMA2D.

Return values

None

Definition at line 323 of file stm32l4xx_hal_dma2d.c.

{

  /* Check the DMA2D peripheral state */
  if(hdma2d == NULL)
  {
     return HAL_ERROR;
  }

  /* Before aborting any DMA2D transfer or CLUT loading, check
     first whether or not DMA2D clock is enabled */
  if (__HAL_RCC_DMA2D_IS_CLK_ENABLED())
  {
    /* Abort DMA2D transfer if any */
    if ((hdma2d->Instance->CR & DMA2D_CR_START) == DMA2D_CR_START)
    {
      if (HAL_DMA2D_Abort(hdma2d) != HAL_OK)
      {
        /* Issue when aborting DMA2D transfer */
        return HAL_ERROR;
      }
    }
    else
    {
      /* Abort background CLUT loading if any */
      if ((hdma2d->Instance->BGPFCCR & DMA2D_BGPFCCR_START) == DMA2D_BGPFCCR_START)
      {
        if (HAL_DMA2D_CLUTLoading_Abort(hdma2d, 0U) != HAL_OK)
        {
          /* Issue when aborting background CLUT loading */
          return HAL_ERROR;
        }
      }
      else
      {
        /* Abort foreground CLUT loading if any */
        if ((hdma2d->Instance->FGPFCCR & DMA2D_FGPFCCR_START) == DMA2D_FGPFCCR_START)
        {
          if (HAL_DMA2D_CLUTLoading_Abort(hdma2d, 1U) != HAL_OK)
          {
            /* Issue when aborting foreground CLUT loading */
            return HAL_ERROR;
          }
        }
      }
    }
  }

  /* Reset DMA2D control registers*/
  hdma2d->Instance->CR       =    0U;
  hdma2d->Instance->IFCR     = 0x3FU;
  hdma2d->Instance->FGOR     =    0U;
  hdma2d->Instance->BGOR     =    0U;
  hdma2d->Instance->FGPFCCR  =    0U;
  hdma2d->Instance->BGPFCCR  =    0U;
  hdma2d->Instance->OPFCCR   =    0U;

#if (USE_HAL_DMA2D_REGISTER_CALLBACKS == 1)

    if(hdma2d->MspDeInitCallback == NULL)
    {
      hdma2d->MspDeInitCallback = HAL_DMA2D_MspDeInit;
    }

    /* DeInit the low level hardware */
    hdma2d->MspDeInitCallback(hdma2d);

#else
  /* Carry on with de-initialization of low level hardware */
  HAL_DMA2D_MspDeInit(hdma2d);
#endif /* (USE_HAL_DMA2D_REGISTER_CALLBACKS) */

  /* Update error code */
  hdma2d->ErrorCode = HAL_DMA2D_ERROR_NONE;

  /* Initialize the DMA2D state*/
  hdma2d->State  = HAL_DMA2D_STATE_RESET;

  /* Release Lock */
  __HAL_UNLOCK(hdma2d);

  return HAL_OK;
}

HAL_DMA2D_Init()

HAL_StatusTypeDef HAL_DMA2D_Init

(

DMA2D_HandleTypeDef *

hdma2d

)

Initialize the DMA2D according to the specified parameters in the DMA2D_InitTypeDef and create the associated handle.

Parameters

hdma2d

pointer to a DMA2D_HandleTypeDef structure that contains the configuration information for the DMA2D.

Return values

HAL

status

Definition at line 237 of file stm32l4xx_hal_dma2d.c.

{
  /* Check the DMA2D peripheral state */
  if(hdma2d == NULL)
  {
     return HAL_ERROR;
  }

  /* Check the parameters */
  assert_param(IS_DMA2D_ALL_INSTANCE(hdma2d->Instance));
  assert_param(IS_DMA2D_MODE(hdma2d->Init.Mode));
  assert_param(IS_DMA2D_CMODE(hdma2d->Init.ColorMode));
  assert_param(IS_DMA2D_OFFSET(hdma2d->Init.OutputOffset));
  assert_param(IS_DMA2D_ALPHA_INVERTED(hdma2d->Init.AlphaInverted));
  assert_param(IS_DMA2D_RB_SWAP(hdma2d->Init.RedBlueSwap));
#if defined(DMA2D_LINE_OFFSET_MODE_SUPPORT)
  assert_param(IS_DMA2D_LOM_MODE(hdma2d->Init.LineOffsetMode));
#endif /* DMA2D_LINE_OFFSET_MODE_SUPPORT */
#if defined(DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT)
  assert_param(IS_DMA2D_BYTES_SWAP(hdma2d->Init.BytesSwap));
#endif /* DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT */

#if (USE_HAL_DMA2D_REGISTER_CALLBACKS == 1)
  if (hdma2d->State == HAL_DMA2D_STATE_RESET)
  {
    /* Reset Callback pointers in HAL_DMA2D_STATE_RESET only */
    hdma2d->LineEventCallback       = HAL_DMA2D_LineEventCallback;
    hdma2d->CLUTLoadingCpltCallback = HAL_DMA2D_CLUTLoadingCpltCallback;
    if(hdma2d->MspInitCallback == NULL)
    {
      hdma2d->MspInitCallback = HAL_DMA2D_MspInit;
    }

    /* Init the low level hardware */
    hdma2d->MspInitCallback(hdma2d);
  }
#else
  if(hdma2d->State == HAL_DMA2D_STATE_RESET)
  {
    /* Allocate lock resource and initialize it */
    hdma2d->Lock = HAL_UNLOCKED;
    /* Init the low level hardware */
    HAL_DMA2D_MspInit(hdma2d);
  }
#endif /* (USE_HAL_DMA2D_REGISTER_CALLBACKS) */

  /* Change DMA2D peripheral state */
  hdma2d->State = HAL_DMA2D_STATE_BUSY;

  /* DMA2D CR register configuration -------------------------------------------*/
#if defined(DMA2D_LINE_OFFSET_MODE_SUPPORT)
  MODIFY_REG(hdma2d->Instance->CR, DMA2D_CR_MODE | DMA2D_CR_LOM, hdma2d->Init.Mode | hdma2d->Init.LineOffsetMode);
#else
  MODIFY_REG(hdma2d->Instance->CR, DMA2D_CR_MODE, hdma2d->Init.Mode);
#endif /* DMA2D_LINE_OFFSET_MODE_SUPPORT */

  /* DMA2D OPFCCR register configuration ---------------------------------------*/
#if defined(DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT)
  MODIFY_REG(hdma2d->Instance->OPFCCR, DMA2D_OPFCCR_CM | DMA2D_OPFCCR_SB, hdma2d->Init.ColorMode | hdma2d->Init.BytesSwap);
#else
  MODIFY_REG(hdma2d->Instance->OPFCCR, DMA2D_OPFCCR_CM, hdma2d->Init.ColorMode);
#endif /* DMA2D_OUTPUT_TWO_BY_TWO_SWAP_SUPPORT */

  /* DMA2D OOR register configuration ------------------------------------------*/
  MODIFY_REG(hdma2d->Instance->OOR, DMA2D_OOR_LO, hdma2d->Init.OutputOffset);
  /* DMA2D OPFCCR AI and RBS fields setting (Output Alpha Inversion)*/
  MODIFY_REG(hdma2d->Instance->OPFCCR,(DMA2D_OPFCCR_AI|DMA2D_OPFCCR_RBS), ((hdma2d->Init.AlphaInverted << DMA2D_OPFCCR_AI_Pos) | (hdma2d->Init.RedBlueSwap << DMA2D_OPFCCR_RBS_Pos)));


  /* Update error code */
  hdma2d->ErrorCode = HAL_DMA2D_ERROR_NONE;

  /* Initialize the DMA2D state*/
  hdma2d->State  = HAL_DMA2D_STATE_READY;

  return HAL_OK;
}

HAL_DMA2D_MspDeInit()

__weak void HAL_DMA2D_MspDeInit

(

DMA2D_HandleTypeDef *

hdma2d

)

DeInitializes the DMA2D MSP.

Parameters

hdma2d

pointer to a DMA2D_HandleTypeDef structure that contains the configuration information for the DMA2D.

Return values

None

Definition at line 429 of file stm32l4xx_hal_dma2d.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(hdma2d);

  /* NOTE : This function should not be modified; when the callback is needed,
            the HAL_DMA2D_MspDeInit can be implemented in the user file.
   */
}

HAL_DMA2D_MspInit()

__weak void HAL_DMA2D_MspInit

(

DMA2D_HandleTypeDef *

hdma2d

)

Initializes the DMA2D MSP.

Parameters

hdma2d

pointer to a DMA2D_HandleTypeDef structure that contains the configuration information for the DMA2D.

Return values

None

Definition at line 413 of file stm32l4xx_hal_dma2d.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(hdma2d);

  /* NOTE : This function should not be modified; when the callback is needed,
            the HAL_DMA2D_MspInit can be implemented in the user file.
   */
}

HAL_DMA2D_RegisterCallback()

HAL_StatusTypeDef HAL_DMA2D_RegisterCallback	(	DMA2D_HandleTypeDef *	hdma2d,
		HAL_DMA2D_CallbackIDTypeDef	CallbackID,
		pDMA2D_CallbackTypeDef	pCallback
	)

Register a User DMA2D Callback To be used instead of the weak (surcharged) predefined callback.

Parameters

hdma2d	DMA2D handle
CallbackID	ID of the callback to be registered This parameter can be one of the following values: HAL_DMA2D_TRANSFERCOMPLETE_CB_ID DMA2D transfer complete Callback ID HAL_DMA2D_TRANSFERERROR_CB_ID DMA2D transfer error Callback ID HAL_DMA2D_LINEEVENT_CB_ID DMA2D line event Callback ID HAL_DMA2D_CLUTLOADINGCPLT_CB_ID DMA2D CLUT loading completion Callback ID HAL_DMA2D_MSPINIT_CB_ID DMA2D MspInit callback ID HAL_DMA2D_MSPDEINIT_CB_ID DMA2D MspDeInit callback ID
pCallback	pointer to the Callback function

Note

No weak predefined callbacks are defined for HAL_DMA2D_TRANSFERCOMPLETE_CB_ID or HAL_DMA2D_TRANSFERERROR_CB_ID

Return values

status

Definition at line 456 of file stm32l4xx_hal_dma2d.c.

{
  HAL_StatusTypeDef status = HAL_OK;

  if(pCallback == NULL)
  {
    /* Update the error code */
    hdma2d->ErrorCode |= HAL_DMA2D_ERROR_INVALID_CALLBACK;
    return HAL_ERROR;
  }
  /* Process locked */
  __HAL_LOCK(hdma2d);

  if(HAL_DMA2D_STATE_READY == hdma2d->State)
  {
    switch (CallbackID)
    {
    case HAL_DMA2D_TRANSFERCOMPLETE_CB_ID :
      hdma2d->XferCpltCallback = pCallback;
      break;

    case HAL_DMA2D_TRANSFERERROR_CB_ID :
      hdma2d->XferErrorCallback = pCallback;
      break;

    case HAL_DMA2D_LINEEVENT_CB_ID :
      hdma2d->LineEventCallback = pCallback;
      break;

    case HAL_DMA2D_CLUTLOADINGCPLT_CB_ID :
      hdma2d->CLUTLoadingCpltCallback = pCallback;
      break;

    case HAL_DMA2D_MSPINIT_CB_ID :
      hdma2d->MspInitCallback = pCallback;
      break;

    case HAL_DMA2D_MSPDEINIT_CB_ID :
      hdma2d->MspDeInitCallback = pCallback;
      break;

    default :
     /* Update the error code */
     hdma2d->ErrorCode |= HAL_DMA2D_ERROR_INVALID_CALLBACK;
     /* update return status */
      status =  HAL_ERROR;
      break;
    }
  }
  else if(HAL_DMA2D_STATE_RESET == hdma2d->State)
  {
    switch (CallbackID)
    {
    case HAL_DMA2D_MSPINIT_CB_ID :
      hdma2d->MspInitCallback = pCallback;
      break;

    case HAL_DMA2D_MSPDEINIT_CB_ID :
      hdma2d->MspDeInitCallback = pCallback;
      break;

    default :
     /* Update the error code */
     hdma2d->ErrorCode |= HAL_DMA2D_ERROR_INVALID_CALLBACK;
     /* update return status */
      status =  HAL_ERROR;
      break;
    }
  }
  else
  {
    /* Update the error code */
     hdma2d->ErrorCode |= HAL_DMA2D_ERROR_INVALID_CALLBACK;
     /* update return status */
      status =  HAL_ERROR;
  }

  /* Release Lock */
  __HAL_UNLOCK(hdma2d);
  return status;
}

HAL_DMA2D_UnRegisterCallback()

HAL_StatusTypeDef HAL_DMA2D_UnRegisterCallback	(	DMA2D_HandleTypeDef *	hdma2d,
		HAL_DMA2D_CallbackIDTypeDef	CallbackID
	)

Unregister a DMA2D Callback DMA2D Callback is redirected to the weak (surcharged) predefined callback.

Parameters

hdma2d

DMA2D handle

CallbackID

ID of the callback to be unregistered This parameter can be one of the following values: HAL_DMA2D_TRANSFERCOMPLETE_CB_ID DMA2D transfer complete Callback ID HAL_DMA2D_TRANSFERERROR_CB_ID DMA2D transfer error Callback ID HAL_DMA2D_LINEEVENT_CB_ID DMA2D line event Callback ID HAL_DMA2D_CLUTLOADINGCPLT_CB_ID DMA2D CLUT loading completion Callback ID HAL_DMA2D_MSPINIT_CB_ID DMA2D MspInit callback ID HAL_DMA2D_MSPDEINIT_CB_ID DMA2D MspDeInit callback ID

Note

No weak predefined callbacks are defined for HAL_DMA2D_TRANSFERCOMPLETE_CB_ID or HAL_DMA2D_TRANSFERERROR_CB_ID

Return values

status

Definition at line 553 of file stm32l4xx_hal_dma2d.c.

{
HAL_StatusTypeDef status = HAL_OK;

  /* Process locked */
  __HAL_LOCK(hdma2d);

  if(HAL_DMA2D_STATE_READY == hdma2d->State)
  {
    switch (CallbackID)
    {
    case HAL_DMA2D_TRANSFERCOMPLETE_CB_ID :
      hdma2d->XferCpltCallback = NULL;
      break;

    case HAL_DMA2D_TRANSFERERROR_CB_ID :
      hdma2d->XferErrorCallback = NULL;
      break;

    case HAL_DMA2D_LINEEVENT_CB_ID :
      hdma2d->LineEventCallback = HAL_DMA2D_LineEventCallback;
      break;

    case HAL_DMA2D_CLUTLOADINGCPLT_CB_ID :
      hdma2d->CLUTLoadingCpltCallback = HAL_DMA2D_CLUTLoadingCpltCallback;
      break;

    case HAL_DMA2D_MSPINIT_CB_ID :
      hdma2d->MspInitCallback = HAL_DMA2D_MspInit; /* Legacy weak (surcharged) Msp Init */
      break;

    case HAL_DMA2D_MSPDEINIT_CB_ID :
      hdma2d->MspDeInitCallback = HAL_DMA2D_MspDeInit; /* Legacy weak (surcharged) Msp DeInit */
      break;

    default :
     /* Update the error code */
     hdma2d->ErrorCode |= HAL_DMA2D_ERROR_INVALID_CALLBACK;
     /* update return status */
      status =  HAL_ERROR;
      break;
    }
  }
  else if(HAL_DMA2D_STATE_RESET == hdma2d->State)
  {
    switch (CallbackID)
    {
    case HAL_DMA2D_MSPINIT_CB_ID :
      hdma2d->MspInitCallback = HAL_DMA2D_MspInit;   /* Legacy weak (surcharged) Msp Init */
      break;

    case HAL_DMA2D_MSPDEINIT_CB_ID :
      hdma2d->MspDeInitCallback = HAL_DMA2D_MspDeInit;  /* Legacy weak (surcharged) Msp DeInit */
      break;

    default :
     /* Update the error code */
     hdma2d->ErrorCode |= HAL_DMA2D_ERROR_INVALID_CALLBACK;
     /* update return status */
      status =  HAL_ERROR;
      break;
    }
  }
  else
  {
     /* Update the error code */
     hdma2d->ErrorCode |= HAL_DMA2D_ERROR_INVALID_CALLBACK;
     /* update return status */
      status =  HAL_ERROR;
  }

  /* Release Lock */
  __HAL_UNLOCK(hdma2d);
  return status;
}