tool/mbed/mbed-sdk/libraries/mbed/targets/hal/TARGET_STM/TARGET_STM32F3XX/spi_api.c

   1 /* mbed Microcontroller Library
   2  *******************************************************************************
   3  * Copyright (c) 2014, STMicroelectronics
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright notice,
  10  *    this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright notice,
  12  *    this list of conditions and the following disclaimer in the documentation
  13  *    and/or other materials provided with the distribution.
  14  * 3. Neither the name of STMicroelectronics nor the names of its contributors
  15  *    may be used to endorse or promote products derived from this software
  16  *    without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  24  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  25  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  26  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *******************************************************************************
  29  */
  30 #include "mbed_assert.h"
  31 #include "spi_api.h"
  32
  33 #if DEVICE_SPI
  34
  35 #include <math.h>
  36 #include "cmsis.h"
  37 #include "pinmap.h"
  38
  39 static const PinMap PinMap_SPI_MOSI[] = {
  40     {PA_11, SPI_2, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_5)},
  41     {PB_5,  SPI_3, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_6)},
  42     {PB_15, SPI_2, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_5)},
  43     {PC_12, SPI_3, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_6)},
  44     {NC,    NC,    0}
  45 };
  46
  47 static const PinMap PinMap_SPI_MISO[] = {
  48     {PA_10, SPI_2, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_5)},
  49     {PB_4,  SPI_3, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_6)},
  50     {PB_14, SPI_2, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_5)},
  51     {PC_11, SPI_3, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_6)},
  52     {NC,    NC,    0}
  53 };
  54
  55 static const PinMap PinMap_SPI_SCLK[] = {
  56     {PB_3,  SPI_3, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_6)},
  57     {PB_13, SPI_2, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_5)},
  58     {PC_10, SPI_3, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_6)},
  59     {PF_1,  SPI_2, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_5)},
  60     {NC,    NC,    0}
  61 };
  62
  63 static const PinMap PinMap_SPI_SSEL[] = {
  64     {PA_4,  SPI_3, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_6)},
  65     {PA_15, SPI_3, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_6)},
  66     {PB_12, SPI_2, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_5)},
  67     {PF_0,  SPI_2, STM_PIN_DATA(GPIO_Mode_AF, GPIO_OType_PP, GPIO_PuPd_DOWN, GPIO_AF_5)},
  68     {NC,    NC,    0}
  69 };
  70
  71 static void init_spi(spi_t *obj) {
  72     SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
  73     SPI_InitTypeDef SPI_InitStructure;
  74
  75     SPI_Cmd(spi, DISABLE);
  76
  77     SPI_InitStructure.SPI_Mode              = obj->mode;
  78     SPI_InitStructure.SPI_NSS               = obj->nss;
  79     SPI_InitStructure.SPI_Direction         = SPI_Direction_2Lines_FullDuplex;
  80     SPI_InitStructure.SPI_DataSize          = obj->bits;
  81     SPI_InitStructure.SPI_CPOL              = obj->cpol;
  82     SPI_InitStructure.SPI_CPHA              = obj->cpha;
  83     SPI_InitStructure.SPI_BaudRatePrescaler = obj->br_presc;
  84     SPI_InitStructure.SPI_FirstBit          = SPI_FirstBit_MSB;
  85     SPI_InitStructure.SPI_CRCPolynomial     = 7;
  86     SPI_Init(spi, &SPI_InitStructure);
  87
  88     SPI_RxFIFOThresholdConfig(spi, SPI_RxFIFOThreshold_QF);
  89
  90     SPI_Cmd(spi, ENABLE);
  91 }
  92
  93 void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) {
  94     // Determine the SPI to use
  95     SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI);
  96     SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO);
  97     SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK);
  98     SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL);
  99
 100     SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso);
 101     SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel);
 102
 103     obj->spi = (SPIName)pinmap_merge(spi_data, spi_cntl);
 104
 105     MBED_ASSERT(obj->spi != (SPIName)NC);
 106
 107     // Enable SPI clock
 108     if (obj->spi == SPI_2) {
 109         RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
 110     }
 111     if (obj->spi == SPI_3) {
 112         RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);
 113     }
 114
 115     // Configure the SPI pins
 116     pinmap_pinout(mosi, PinMap_SPI_MOSI);
 117     pinmap_pinout(miso, PinMap_SPI_MISO);
 118     pinmap_pinout(sclk, PinMap_SPI_SCLK);
 119
 120     // Save new values
 121     obj->bits = SPI_DataSize_8b;
 122     obj->cpol = SPI_CPOL_Low;
 123     obj->cpha = SPI_CPHA_1Edge;
 124     obj->br_presc = SPI_BaudRatePrescaler_256;
 125
 126     if (ssel == NC) { // Master
 127         obj->mode = SPI_Mode_Master;
 128         obj->nss = SPI_NSS_Soft;
 129     } else { // Slave
 130         pinmap_pinout(ssel, PinMap_SPI_SSEL);
 131         obj->mode = SPI_Mode_Slave;
 132         obj->nss = SPI_NSS_Soft;
 133     }
 134
 135     init_spi(obj);
 136 }
 137
 138 void spi_free(spi_t *obj) {
 139     SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
 140     SPI_I2S_DeInit(spi);
 141 }
 142
 143 void spi_format(spi_t *obj, int bits, int mode, int slave) {
 144     // Save new values
 145     if (bits == 8) {
 146         obj->bits = SPI_DataSize_8b;
 147     } else {
 148         obj->bits = SPI_DataSize_16b;
 149     }
 150
 151     switch (mode) {
 152         case 0:
 153             obj->cpol = SPI_CPOL_Low;
 154             obj->cpha = SPI_CPHA_1Edge;
 155             break;
 156         case 1:
 157             obj->cpol = SPI_CPOL_Low;
 158             obj->cpha = SPI_CPHA_2Edge;
 159             break;
 160         case 2:
 161             obj->cpol = SPI_CPOL_High;
 162             obj->cpha = SPI_CPHA_1Edge;
 163             break;
 164         default:
 165             obj->cpol = SPI_CPOL_High;
 166             obj->cpha = SPI_CPHA_2Edge;
 167             break;
 168     }
 169
 170     if (slave == 0) {
 171         obj->mode = SPI_Mode_Master;
 172         obj->nss = SPI_NSS_Soft;
 173     } else {
 174         obj->mode = SPI_Mode_Slave;
 175         obj->nss = SPI_NSS_Hard;
 176     }
 177
 178     init_spi(obj);
 179 }
 180
 181 void spi_frequency(spi_t *obj, int hz) {
 182     // Values depend of PCLK1: 32 MHz if HSI is used, 36 MHz if HSE is used
 183     if (hz < 250000) {
 184         obj->br_presc = SPI_BaudRatePrescaler_256; // 125 kHz - 141 kHz
 185     } else if ((hz >= 250000) && (hz < 500000)) {
 186         obj->br_presc = SPI_BaudRatePrescaler_128; // 250 kHz - 280 kHz
 187     } else if ((hz >= 500000) && (hz < 1000000)) {
 188         obj->br_presc = SPI_BaudRatePrescaler_64; // 500 kHz - 560 kHz
 189     } else if ((hz >= 1000000) && (hz < 2000000)) {
 190         obj->br_presc = SPI_BaudRatePrescaler_32; // 1 MHz - 1.13 MHz
 191     } else if ((hz >= 2000000) && (hz < 4000000)) {
 192         obj->br_presc = SPI_BaudRatePrescaler_16; // 2 MHz - 2.25 MHz
 193     } else if ((hz >= 4000000) && (hz < 8000000)) {
 194         obj->br_presc = SPI_BaudRatePrescaler_8; // 4 MHz - 4.5 MHz
 195     } else if ((hz >= 8000000) && (hz < 16000000)) {
 196         obj->br_presc = SPI_BaudRatePrescaler_4; // 8 MHz - 9 MHz
 197     } else { // >= 16000000
 198         obj->br_presc = SPI_BaudRatePrescaler_2; // 16 MHz - 18 MHz
 199     }
 200     init_spi(obj);
 201 }
 202
 203 static inline int ssp_readable(spi_t *obj) {
 204     int status;
 205     SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
 206     // Check if data is received
 207     status = ((SPI_I2S_GetFlagStatus(spi, SPI_I2S_FLAG_RXNE) != RESET) ? 1 : 0);
 208     return status;
 209 }
 210
 211 static inline int ssp_writeable(spi_t *obj) {
 212     int status;
 213     SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
 214     // Check if data is transmitted
 215     status = ((SPI_I2S_GetFlagStatus(spi, SPI_I2S_FLAG_TXE) != RESET) ? 1 : 0);
 216     return status;
 217 }
 218
 219 static inline void ssp_write(spi_t *obj, int value) {
 220     SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
 221     while (!ssp_writeable(obj));
 222     if (obj->bits == SPI_DataSize_8b) {
 223         SPI_SendData8(spi, (uint8_t)value);
 224     } else {
 225         SPI_I2S_SendData16(spi, (uint16_t)value);
 226     }
 227 }
 228
 229 static inline int ssp_read(spi_t *obj) {
 230     SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
 231     while (!ssp_readable(obj));
 232     if (obj->bits == SPI_DataSize_8b) {
 233         return (int)SPI_ReceiveData8(spi);
 234     } else {
 235         return (int)SPI_I2S_ReceiveData16(spi);
 236     }
 237 }
 238
 239 static inline int ssp_busy(spi_t *obj) {
 240     int status;
 241     SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
 242     status = ((SPI_I2S_GetFlagStatus(spi, SPI_I2S_FLAG_BSY) != RESET) ? 1 : 0);
 243     return status;
 244 }
 245
 246 int spi_master_write(spi_t *obj, int value) {
 247     ssp_write(obj, value);
 248     return ssp_read(obj);
 249 }
 250
 251 int spi_slave_receive(spi_t *obj) {
 252     return (ssp_readable(obj) && !ssp_busy(obj)) ? (1) : (0);
 253 };
 254
 255 int spi_slave_read(spi_t *obj) {
 256     SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
 257     if (obj->bits == SPI_DataSize_8b) {
 258         return (int)SPI_ReceiveData8(spi);
 259     } else {
 260         return (int)SPI_I2S_ReceiveData16(spi);
 261     }
 262 }
 263
 264 void spi_slave_write(spi_t *obj, int value) {
 265     SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
 266     while (!ssp_writeable(obj));
 267     if (obj->bits == SPI_DataSize_8b) {
 268         SPI_SendData8(spi, (uint8_t)value);
 269     } else {
 270         SPI_I2S_SendData16(spi, (uint16_t)value);
 271     }
 272 }
 273
 274 int spi_busy(spi_t *obj) {
 275     return ssp_busy(obj);
 276 }
 277
 278 #endif