URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [CORTEX_STM32F103_Keil/] [STM32F10xFWLib/] [src/] [stm32f10x_spi.c] - Rev 609
Go to most recent revision | Compare with Previous | Blame | View Log
/******************** (C) COPYRIGHT 2007 STMicroelectronics ******************** * File Name : stm32f10x_spi.c * Author : MCD Application Team * Date First Issued : 09/29/2006 * Description : This file provides all the SPI firmware functions. ******************************************************************************** * History: * 04/02/2007: V0.2 * 02/05/2007: V0.1 * 09/29/2006: V0.01 ******************************************************************************** * THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT, * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. *******************************************************************************/ /* Includes ------------------------------------------------------------------*/ #include "stm32f10x_spi.h" #include "stm32f10x_rcc.h" /* Private typedef -----------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/ /* SPI SPE mask */ #define CR1_SPE_Set ((u16)0x0040) #define CR1_SPE_Reset ((u16)0xFFBF) /* SPI CRCNext mask */ #define CR1_CRCNext_Set ((u16)0x1000) /* SPI CRCEN mask */ #define CR1_CRCEN_Set ((u16)0x2000) #define CR1_CRCEN_Reset ((u16)0xDFFF) /* SPI SSOE mask */ #define CR2_SSOE_Set ((u16)0x0004) #define CR2_SSOE_Reset ((u16)0xFFFB) /* SPI registers Masks */ #define CR1_CLEAR_Mask ((u16)0x3040) /* Private macro -------------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/ /* Private functions ---------------------------------------------------------*/ /******************************************************************************* * Function Name : SPI_DeInit * Description : Deinitializes the SPIx peripheral registers to their default * reset values. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * Output : None * Return : None *******************************************************************************/ void SPI_DeInit(SPI_TypeDef* SPIx) { switch (*(u32*)&SPIx) { case SPI1_BASE: /* Enable SPI1 reset state */ RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE); /* Release SPI1 from reset state */ RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, DISABLE); break; case SPI2_BASE: /* Enable SPI2 reset state */ RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE); /* Release SPI2 from reset state */ RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, DISABLE); break; default: break; } } /******************************************************************************* * Function Name : SPI_Init * Description : Initializes the SPIx according to the specified parameters * in the SPI_InitStruct. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_InitStruct: pointer to a SPI_InitTypeDef structure that * contains the configuration information for the specified * SPI peripheral. * Output : None * Return : None ******************************************************************************/ void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct) { u16 tmpreg = 0; /* Check the parameters */ assert(IS_SPI_DIRECTION_MODE(SPI_InitStruct->SPI_Direction)); assert(IS_SPI_MODE(SPI_InitStruct->SPI_Mode)); assert(IS_SPI_DATASIZE(SPI_InitStruct->SPI_DataSize)); assert(IS_SPI_CPOL(SPI_InitStruct->SPI_CPOL)); assert(IS_SPI_CPHA(SPI_InitStruct->SPI_CPHA)); assert(IS_SPI_NSS(SPI_InitStruct->SPI_NSS)); assert(IS_SPI_BAUDRATE_PRESCALER(SPI_InitStruct->SPI_BaudRatePrescaler)); assert(IS_SPI_FIRST_BIT(SPI_InitStruct->SPI_FirstBit)); assert(IS_SPI_CRC_POLYNOMIAL(SPI_InitStruct->SPI_CRCPolynomial)); /*---------------------------- SPIx CR1 Configuration ------------------------*/ /* Get the SPIx CR1 value */ tmpreg = SPIx->CR1; /* Clear BIDIMode, BIDIOE, RxONLY, SSM, SSI, LSBFirst, BR, MSTR, CPOL and CPHA bits */ tmpreg &= CR1_CLEAR_Mask; /* Configure SPIx: direction, NSS management, first transmitted bit, BaudRate prescaler master/salve mode, CPOL and CPHA */ /* Set BIDImode, BIDIOE and RxONLY bits according to SPI_Direction value */ /* Set SSM, SSI and MSTR bits according to SPI_Mode and SPI_NSS values */ /* Set LSBFirst bit according to SPI_FirstBit value */ /* Set BR bits according to SPI_BaudRatePrescaler value */ /* Set CPOL bit according to SPI_CPOL value */ /* Set CPHA bit according to SPI_CPHA value */ tmpreg |= (u16)((u32)SPI_InitStruct->SPI_Direction | SPI_InitStruct->SPI_Mode | SPI_InitStruct->SPI_DataSize | SPI_InitStruct->SPI_CPOL | SPI_InitStruct->SPI_CPHA | SPI_InitStruct->SPI_NSS | SPI_InitStruct->SPI_BaudRatePrescaler | SPI_InitStruct->SPI_FirstBit); /* Write to SPIx CR1 */ SPIx->CR1 = tmpreg; /*---------------------------- SPIx CRCPOLY Configuration --------------------*/ /* Write to SPIx CRCPOLY */ SPIx->CRCPR = SPI_InitStruct->SPI_CRCPolynomial; } /******************************************************************************* * Function Name : SPI_StructInit * Description : Fills each SPI_InitStruct member with its default value. * Input : - SPI_InitStruct : pointer to a SPI_InitTypeDef structure * which will be initialized. * Output : None * Return : None *******************************************************************************/ void SPI_StructInit(SPI_InitTypeDef* SPI_InitStruct) { /*--------------- Reset SPI init structure parameters values -----------------*/ /* Initialize the SPI_Direction member */ SPI_InitStruct->SPI_Direction = SPI_Direction_2Lines_FullDuplex; /* initialize the SPI_Mode member */ SPI_InitStruct->SPI_Mode = SPI_Mode_Slave; /* initialize the SPI_DataSize member */ SPI_InitStruct->SPI_DataSize = SPI_DataSize_8b; /* Initialize the SPI_CPOL member */ SPI_InitStruct->SPI_CPOL = SPI_CPOL_Low; /* Initialize the SPI_CPHA member */ SPI_InitStruct->SPI_CPHA = SPI_CPHA_1Edge; /* Initialize the SPI_NSS member */ SPI_InitStruct->SPI_NSS = SPI_NSS_Hard; /* Initialize the SPI_BaudRatePrescaler member */ SPI_InitStruct->SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2; /* Initialize the SPI_FirstBit member */ SPI_InitStruct->SPI_FirstBit = SPI_FirstBit_MSB; /* Initialize the SPI_CRCPolynomial member */ SPI_InitStruct->SPI_CRCPolynomial = 7; } /******************************************************************************* * Function Name : SPI_Cmd * Description : Enables or disables the specified SPI peripheral. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - NewState: new state of the SPIx peripheral. * This parameter can be: ENABLE or DISABLE. * Output : None * Return : None *******************************************************************************/ void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState) { /* Check the parameters */ assert(IS_FUNCTIONAL_STATE(NewState)); if (NewState != DISABLE) { /* Enable the selected SPI peripheral */ SPIx->CR1 |= CR1_SPE_Set; } else { /* Disable the selected SPI peripheral */ SPIx->CR1 &= CR1_SPE_Reset; } } /******************************************************************************* * Function Name : SPI_ITConfig * Description : Enables or disables the specified SPI interrupts. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_IT: specifies the SPI interrupts sources to be enabled * or disabled. * This parameter can be one of the following values: * - SPI_IT_TXE: Tx buffer empty interrupt mask * - SPI_IT_RXNE: Rx buffer not empty interrupt mask * - SPI_IT_ERR: Error interrupt mask * - NewState: new state of the specified SPI interrupts. * This parameter can be: ENABLE or DISABLE. * Output : None * Return : None *******************************************************************************/ void SPI_ITConfig(SPI_TypeDef* SPIx, u8 SPI_IT, FunctionalState NewState) { u16 itpos = 0, itmask = 0 ; /* Check the parameters */ assert(IS_FUNCTIONAL_STATE(NewState)); assert(IS_SPI_CONFIG_IT(SPI_IT)); /* Get the SPI IT index */ itpos = SPI_IT >> 4; /* Set the IT mask */ itmask = (u16)((u16)1 << itpos); if (NewState != DISABLE) { /* Enable the selected SPI interrupt */ SPIx->CR2 |= itmask; } else { /* Disable the selected SPI interrupt */ SPIx->CR2 &= (u16)~itmask; } } /******************************************************************************* * Function Name : SPI_DMACmd * Description : Enables or disables the SPIx’s DMA interface. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_DMAReq: specifies the SPI DMA transfer request to be * enabled or disabled. * This parameter can be any combination of the following values: * - SPI_DMAReq_Tx: Tx buffer DMA transfer request * - SPI_DMAReq_Rx: Rx buffer DMA transfer request * - NewState: new state of the selected SPI DMA transfer request. * This parameter can be: ENABLE or DISABLE. * Output : None * Return : None *******************************************************************************/ void SPI_DMACmd(SPI_TypeDef* SPIx, u16 SPI_DMAReq, FunctionalState NewState) { /* Check the parameters */ assert(IS_FUNCTIONAL_STATE(NewState)); assert(IS_SPI_DMA_REQ(SPI_DMAReq)); if (NewState != DISABLE) { /* Enable the selected SPI DMA requests */ SPIx->CR2 |= SPI_DMAReq; } else { /* Disable the selected SPI DMA requests */ SPIx->CR2 &= (u16)~SPI_DMAReq; } } /******************************************************************************* * Function Name : SPI_SendData * Description : Transmits a Data through the SPIx peripheral. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - Data : Data to be transmitted.. * Output : None * Return : None *******************************************************************************/ void SPI_SendData(SPI_TypeDef* SPIx, u16 Data) { /* Write in the DR register the data to be sent */ SPIx->DR = Data; } /******************************************************************************* * Function Name : SPI_ReceiveData * Description : Returns the most recent received data by the SPIx peripheral. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * Output : None * Return : The value of the received data. *******************************************************************************/ u16 SPI_ReceiveData(SPI_TypeDef* SPIx) { /* Return the data in the DR register */ return SPIx->DR; } /******************************************************************************* * Function Name : SPI_NSSInternalSoftwareConfig * Description : Configures internally by software the NSS pin for the selected * SPI. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_NSSInternalSoft: specifies the SPI NSS internal state. * This parameter can be one of the following values: * - SPI_NSSInternalSoft_Set: Set NSS pin internally * - SPI_NSSInternalSoft_Reset: Reset NSS pin internally * Output : None * Return : None *******************************************************************************/ void SPI_NSSInternalSoftwareConfig(SPI_TypeDef* SPIx, u16 SPI_NSSInternalSoft) { /* Check the parameters */ assert(IS_SPI_NSS_INTERNAL(SPI_NSSInternalSoft)); if (SPI_NSSInternalSoft != SPI_NSSInternalSoft_Reset) { /* Set NSS pin internally by software */ SPIx->CR1 |= SPI_NSSInternalSoft_Set; } else { /* Reset NSS pin internally by software */ SPIx->CR1 &= SPI_NSSInternalSoft_Reset; } } /******************************************************************************* * Function Name : SPI_SSOutputCmd * Description : Enables or disables the SS output for the selected SPI. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - NewState: new state of the SPIx SS output. * This parameter can be: ENABLE or DISABLE. * Output : None * Return : None *******************************************************************************/ void SPI_SSOutputCmd(SPI_TypeDef* SPIx, FunctionalState NewState) { /* Check the parameters */ assert(IS_FUNCTIONAL_STATE(NewState)); if (NewState != DISABLE) { /* Enable the selected SPI SS output */ SPIx->CR2 |= CR2_SSOE_Set; } else { /* Disable the selected SPI SS output */ SPIx->CR2 &= CR2_SSOE_Reset; } } /******************************************************************************* * Function Name : SPI_DataSizeConfig * Description : Configures the data size for the selected SPI. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_DataSize: specifies the SPI data size. * This parameter can be one of the following values: * - SPI_DataSize_16b: Set data frame format to 16bit * - SPI_DataSize_8b: Set data frame format to 8bit * Output : None * Return : None *******************************************************************************/ void SPI_DataSizeConfig(SPI_TypeDef* SPIx, u16 SPI_DataSize) { /* Check the parameters */ assert(IS_SPI_DATASIZE(SPI_DataSize)); if (SPI_DataSize != SPI_DataSize_8b) { /* Set data frame format to 16bit */ SPIx->CR1 |= SPI_DataSize_16b; } else { /* Set data frame format to 8bit */ SPIx->CR1 &= SPI_DataSize_8b; } } /******************************************************************************* * Function Name : SPI_TransmitCRC * Description : Transmit the SPIx CRC value. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * Output : None * Return : None *******************************************************************************/ void SPI_TransmitCRC(SPI_TypeDef* SPIx) { /* Enable the selected SPI CRC transmission */ SPIx->CR1 |= CR1_CRCNext_Set; } /******************************************************************************* * Function Name : SPI_CalculateCRC * Description : Enables or disables the CRC value calculation of the * transfered bytes. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - NewState: new state of the SPIx CRC value calculation. * This parameter can be: ENABLE or DISABLE. * Output : None * Return : None *******************************************************************************/ void SPI_CalculateCRC(SPI_TypeDef* SPIx, FunctionalState NewState) { /* Check the parameters */ assert(IS_FUNCTIONAL_STATE(NewState)); if (NewState != DISABLE) { /* Enable the selected SPI CRC calculation */ SPIx->CR1 |= CR1_CRCEN_Set; } else { /* Disable the selected SPI CRC calculation */ SPIx->CR1 &= CR1_CRCEN_Reset; } } /******************************************************************************* * Function Name : SPI_GetCRC * Description : Returns the transmit or the receive CRC register value for * the specified SPI. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_CRC: specifies the CRC register to be read. * This parameter can be one of the following values: * - SPI_CRC_Tx: Selects Tx CRC register * - SPI_CRC_Rx: Selects Rx CRC register * Output : None * Return : The selected CRC register value.. *******************************************************************************/ u16 SPI_GetCRC(SPI_TypeDef* SPIx, u8 SPI_CRC) { u16 crcreg = 0; /* Check the parameters */ assert(IS_SPI_CRC(SPI_CRC)); if (SPI_CRC != SPI_CRC_Rx) { /* Get the Tx CRC register */ crcreg = SPIx->TXCRCR; } else { /* Get the Rx CRC register */ crcreg = SPIx->RXCRCR; } /* Return the selected CRC register */ return crcreg; } /******************************************************************************* * Function Name : SPI_GetCRCPolynomial * Description : Returns the CRC Polynomial register value for the specified SPI. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * Output : None * Return : The CRC Polynomial register value. *******************************************************************************/ u16 SPI_GetCRCPolynomial(SPI_TypeDef* SPIx) { /* Return the CRC polynomial register */ return SPIx->CRCPR; } /******************************************************************************* * Function Name : SPI_BiDirectionalLineConfig * Description : Selects the data transfer direction in bi-directional mode * for the specified SPI. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_Direction: specifies the data transfer direction in * bi-directional mode. * This parameter can be one of the following values: * - SPI_Direction_Tx: Selects Tx transmission direction * - SPI_Direction_Rx: Selects Rx receive direction * Output : None * Return : None *******************************************************************************/ void SPI_BiDirectionalLineConfig(SPI_TypeDef* SPIx, u16 SPI_Direction) { /* Check the parameters */ assert(IS_SPI_DIRECTION(SPI_Direction)); if (SPI_Direction == SPI_Direction_Tx) { /* Set the Tx only mode */ SPIx->CR1 |= SPI_Direction_Tx; } else { /* Set the Rx only mode */ SPIx->CR1 &= SPI_Direction_Rx; } } /******************************************************************************* * Function Name : SPI_GetFlagStatus * Description : Checks whether the specified SPI flag is set or not. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_FLAG: specifies the flag to check. * This parameter can be one of the following values: * - SPI_FLAG_BSY: Busy flag. * - SPI_FLAG_OVR: Overrun flag. * - SPI_FLAG_MODF: Mode Fault flag. * - SPI_FLAG_CRCERR: CRC Error flag. * - SPI_FLAG_TXE: Transmit buffer empty flag. * - SPI_FLAG_RXNE: Receive buffer not empty flag. * Output : None * Return : The new state of SPI_FLAG (SET or RESET). *******************************************************************************/ FlagStatus SPI_GetFlagStatus(SPI_TypeDef* SPIx, u16 SPI_FLAG) { FlagStatus bitstatus = RESET; /* Check the parameters */ assert(IS_SPI_GET_FLAG(SPI_FLAG)); /* Check the status of the specified SPI flag */ if ((SPIx->SR & SPI_FLAG) != (u16)RESET) { /* SPI_FLAG is set */ bitstatus = SET; } else { /* SPI_FLAG is reset */ bitstatus = RESET; } /* Return the SPI_FLAG status */ return bitstatus; } /******************************************************************************* * Function Name : SPI_ClearFlag * Description : Clears the SPIx's pending flags. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_FLAG: specifies the flag to clear. * This parameter can be any combination of the following values: * - SPI_FLAG_OVR: Overrun flag. * - SPI_FLAG_MODF: Mode Fault flag. * - SPI_FLAG_CRCERR: CRC Error flag. * Output : None * Return : None *******************************************************************************/ void SPI_ClearFlag(SPI_TypeDef* SPIx, u16 SPI_FLAG) { /* Check the parameters */ assert(IS_SPI_CLEAR_FLAG(SPI_FLAG)); /* SPI_FLAG_MODF flag clear */ if(SPI_FLAG == SPI_FLAG_MODF) { /* Read SR register */ (void)SPIx->SR; /* Write on CR1 register */ SPIx->CR1 |= CR1_SPE_Set; } /* SPI_FLAG_OVR flag clear */ else if(SPI_FLAG == SPI_FLAG_OVR) { /* Read SR register */ (void)SPIx->SR; } else /* SPI_FLAG_CRCERR flag clear */ { /* Clear the selected SPI flag */ SPIx->SR &= (u16)~SPI_FLAG; } } /******************************************************************************* * Function Name : SPI_GetITStatus * Description : Checks whether the specified SPI interrupt has occurred or not. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_IT: specifies the SPI interrupt source to check. * This parameter can be one of the following values: * - SPI_IT_OVR: Overrun interrupt. * - SPI_IT_MODF: Mode Fault interrupt. * - SPI_IT_CRCERR: CRC Error interrupt. * - SPI_IT_TXE: Transmit buffer empty interrupt. * - SPI_IT_RXNE: Receive buffer not empty interrupt. * Output : None * Return : The new state of SPI_IT (SET or RESET). *******************************************************************************/ ITStatus SPI_GetITStatus(SPI_TypeDef* SPIx, u8 SPI_IT) { ITStatus bitstatus = RESET; u16 itpos = 0, itmask = 0, enablestatus = 0; /* Check the parameters */ assert(IS_SPI_GET_IT(SPI_IT)); /* Get the SPI IT index */ itpos = (u16)((u16)0x01 << (SPI_IT & (u8)0x0F)); /* Get the SPI IT index */ itmask = SPI_IT >> 4; /* Set the IT mask */ itmask = (u16)((u16)0x01 << itmask); /* Get the SPI_IT enable bit status */ enablestatus = (SPIx->CR2 & itmask) ; /* Check the status of the specified SPI interrupt */ if (((SPIx->SR & itpos) != (u16)RESET) && enablestatus) { /* SPI_IT is set */ bitstatus = SET; } else { /* SPI_IT is reset */ bitstatus = RESET; } /* Return the SPI_IT status */ return bitstatus; } /******************************************************************************* * Function Name : SPI_ClearITPendingBit * Description : Clears the SPI’s interrupt pending bits. * Input : - SPIx: where x can be 1 or 2 to select the SPI peripheral. * - SPI_IT: specifies the SPI interrupt pending bit to clear. * This parameter can be one of the following values: * - SPI_IT_OVR: Overrun interrupt. * - SPI_IT_MODF: Mode Fault interrupt. * - SPI_IT_CRCERR: CRC Error interrupt. * Output : None * Return : None *******************************************************************************/ void SPI_ClearITPendingBit(SPI_TypeDef* SPIx, u8 SPI_IT) { u16 itpos = 0; /* Check the parameters */ assert(IS_SPI_CLEAR_IT(SPI_IT)); /* SPI_IT_MODF pending bit clear */ if(SPI_IT == SPI_IT_MODF) { /* Read SR register */ (void)SPIx->SR; /* Write on CR1 register */ SPIx->CR1 |= CR1_SPE_Set; } else if(SPI_IT == SPI_IT_OVR) /* SPI_IT_OVR pending bit clear */ { /* Read SR register */ (void)(SPIx->SR); } else /* SPI_IT_CRCERR pending bit clear */ { /* Get the SPI IT index */ itpos = (u16)((u16)0x01 << (SPI_IT & (u8)0x0F)); /* Clear the selected SPI interrupt pending bits */ SPIx->SR &= (u16)~itpos; } } /******************* (C) COPYRIGHT 2007 STMicroelectronics *****END OF FILE****/
Go to most recent revision | Compare with Previous | Blame | View Log