long dao / mbed-src

Mbed for VNG board

Fork of mbed-src by mbed official

targets/hal/TARGET_STM/TARGET_NUCLEO_F302R8/spi_api.c@404:cbc7dfcb0ce9, 2014-11-14 (annotated)

Committer:
mbed_official
Date:
Fri Nov 14 10:15:07 2014 +0000
Revision:
404:cbc7dfcb0ce9
Parent:
330:c80ac197fa6a
Child:
414:4ec4c5b614b0
Synchronized with git revision c4901dbb33541e1dcda3fe69a1ec2a11caf496bf



Full URL: https://github.com/mbedmicro/mbed/commit/c4901dbb33541e1dcda3fe69a1ec2a11caf496bf/



Targets: NUCLEOs - Align hal files

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 125:23cc3068a9e4 1 /* mbed Microcontroller Library
mbed_official 125:23cc3068a9e4 2 *******************************************************************************
mbed_official 125:23cc3068a9e4 3 * Copyright (c) 2014, STMicroelectronics
mbed_official 125:23cc3068a9e4 4 * All rights reserved.
mbed_official 125:23cc3068a9e4 5 *
mbed_official 125:23cc3068a9e4 6 * Redistribution and use in source and binary forms, with or without
mbed_official 125:23cc3068a9e4 7 * modification, are permitted provided that the following conditions are met:
mbed_official 125:23cc3068a9e4 8 *
mbed_official 125:23cc3068a9e4 9 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 125:23cc3068a9e4 10 * this list of conditions and the following disclaimer.
mbed_official 125:23cc3068a9e4 11 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 125:23cc3068a9e4 12 * this list of conditions and the following disclaimer in the documentation
mbed_official 125:23cc3068a9e4 13 * and/or other materials provided with the distribution.
mbed_official 125:23cc3068a9e4 14 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 125:23cc3068a9e4 15 * may be used to endorse or promote products derived from this software
mbed_official 125:23cc3068a9e4 16 * without specific prior written permission.
mbed_official 125:23cc3068a9e4 17 *
mbed_official 125:23cc3068a9e4 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 125:23cc3068a9e4 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 125:23cc3068a9e4 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 125:23cc3068a9e4 21 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 125:23cc3068a9e4 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 125:23cc3068a9e4 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 125:23cc3068a9e4 24 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 125:23cc3068a9e4 25 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 125:23cc3068a9e4 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 125:23cc3068a9e4 27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 125:23cc3068a9e4 28 *******************************************************************************
mbed_official 125:23cc3068a9e4 29 */
mbed_official 227:7bd0639b8911 30 #include "mbed_assert.h"
mbed_official 125:23cc3068a9e4 31 #include "spi_api.h"
mbed_official 125:23cc3068a9e4 32
mbed_official 125:23cc3068a9e4 33 #if DEVICE_SPI
mbed_official 125:23cc3068a9e4 34
mbed_official 125:23cc3068a9e4 35 #include <math.h>
mbed_official 125:23cc3068a9e4 36 #include "cmsis.h"
mbed_official 125:23cc3068a9e4 37 #include "pinmap.h"
mbed_official 125:23cc3068a9e4 38
mbed_official 125:23cc3068a9e4 39 static const PinMap PinMap_SPI_MOSI[] = {
mbed_official 330:c80ac197fa6a 40 {PA_11, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF5_SPI2)},
mbed_official 330:c80ac197fa6a 41 {PB_5, SPI_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_SPI3)},
mbed_official 330:c80ac197fa6a 42 {PB_15, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF5_SPI2)},
mbed_official 330:c80ac197fa6a 43 {PC_12, SPI_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_SPI3)},
mbed_official 125:23cc3068a9e4 44 {NC, NC, 0}
mbed_official 125:23cc3068a9e4 45 };
mbed_official 125:23cc3068a9e4 46
mbed_official 125:23cc3068a9e4 47 static const PinMap PinMap_SPI_MISO[] = {
mbed_official 330:c80ac197fa6a 48 {PA_10, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF5_SPI2)},
mbed_official 330:c80ac197fa6a 49 {PB_4, SPI_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_SPI3)},
mbed_official 330:c80ac197fa6a 50 {PB_14, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF5_SPI2)},
mbed_official 330:c80ac197fa6a 51 {PC_11, SPI_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_SPI3)},
mbed_official 125:23cc3068a9e4 52 {NC, NC, 0}
mbed_official 125:23cc3068a9e4 53 };
mbed_official 125:23cc3068a9e4 54
mbed_official 125:23cc3068a9e4 55 static const PinMap PinMap_SPI_SCLK[] = {
mbed_official 330:c80ac197fa6a 56 {PB_3, SPI_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_SPI3)},
mbed_official 330:c80ac197fa6a 57 {PB_13, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF5_SPI2)},
mbed_official 330:c80ac197fa6a 58 {PC_10, SPI_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_SPI3)},
mbed_official 330:c80ac197fa6a 59 {PF_1, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF5_SPI2)},
mbed_official 125:23cc3068a9e4 60 {NC, NC, 0}
mbed_official 125:23cc3068a9e4 61 };
mbed_official 125:23cc3068a9e4 62
mbed_official 125:23cc3068a9e4 63 static const PinMap PinMap_SPI_SSEL[] = {
mbed_official 330:c80ac197fa6a 64 {PA_4, SPI_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_SPI3)},
mbed_official 330:c80ac197fa6a 65 {PA_15, SPI_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF6_SPI3)},
mbed_official 330:c80ac197fa6a 66 {PB_12, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF5_SPI2)},
mbed_official 330:c80ac197fa6a 67 {PF_0, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF5_SPI2)},
mbed_official 125:23cc3068a9e4 68 {NC, NC, 0}
mbed_official 125:23cc3068a9e4 69 };
mbed_official 125:23cc3068a9e4 70
mbed_official 330:c80ac197fa6a 71 static SPI_HandleTypeDef SpiHandle;
mbed_official 125:23cc3068a9e4 72
mbed_official 330:c80ac197fa6a 73 static void init_spi(spi_t *obj)
mbed_official 330:c80ac197fa6a 74 {
mbed_official 330:c80ac197fa6a 75 SpiHandle.Instance = (SPI_TypeDef *)(obj->spi);
mbed_official 330:c80ac197fa6a 76
mbed_official 330:c80ac197fa6a 77 __HAL_SPI_DISABLE(&SpiHandle);
mbed_official 125:23cc3068a9e4 78
mbed_official 330:c80ac197fa6a 79 SpiHandle.Init.Mode = obj->mode;
mbed_official 330:c80ac197fa6a 80 SpiHandle.Init.BaudRatePrescaler = obj->br_presc;
mbed_official 330:c80ac197fa6a 81 SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
mbed_official 330:c80ac197fa6a 82 SpiHandle.Init.CLKPhase = obj->cpha;
mbed_official 330:c80ac197fa6a 83 SpiHandle.Init.CLKPolarity = obj->cpol;
mbed_official 330:c80ac197fa6a 84 SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
mbed_official 330:c80ac197fa6a 85 SpiHandle.Init.CRCPolynomial = 7;
mbed_official 330:c80ac197fa6a 86 SpiHandle.Init.DataSize = obj->bits;
mbed_official 330:c80ac197fa6a 87 SpiHandle.Init.FirstBit = SPI_FIRSTBIT_MSB;
mbed_official 330:c80ac197fa6a 88 SpiHandle.Init.NSS = obj->nss;
mbed_official 330:c80ac197fa6a 89 SpiHandle.Init.TIMode = SPI_TIMODE_DISABLED;
mbed_official 125:23cc3068a9e4 90
mbed_official 330:c80ac197fa6a 91 HAL_SPI_Init(&SpiHandle);
mbed_official 135:067cc8ba23da 92
mbed_official 330:c80ac197fa6a 93 __HAL_SPI_ENABLE(&SpiHandle);
mbed_official 125:23cc3068a9e4 94 }
mbed_official 125:23cc3068a9e4 95
mbed_official 330:c80ac197fa6a 96 void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)
mbed_official 330:c80ac197fa6a 97 {
mbed_official 125:23cc3068a9e4 98 // Determine the SPI to use
mbed_official 125:23cc3068a9e4 99 SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI);
mbed_official 125:23cc3068a9e4 100 SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO);
mbed_official 125:23cc3068a9e4 101 SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK);
mbed_official 125:23cc3068a9e4 102 SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL);
mbed_official 135:067cc8ba23da 103
mbed_official 125:23cc3068a9e4 104 SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso);
mbed_official 125:23cc3068a9e4 105 SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel);
mbed_official 135:067cc8ba23da 106
mbed_official 125:23cc3068a9e4 107 obj->spi = (SPIName)pinmap_merge(spi_data, spi_cntl);
mbed_official 227:7bd0639b8911 108 MBED_ASSERT(obj->spi != (SPIName)NC);
mbed_official 135:067cc8ba23da 109
mbed_official 125:23cc3068a9e4 110 // Enable SPI clock
mbed_official 125:23cc3068a9e4 111 if (obj->spi == SPI_2) {
mbed_official 330:c80ac197fa6a 112 __SPI2_CLK_ENABLE();
mbed_official 125:23cc3068a9e4 113 }
mbed_official 404:cbc7dfcb0ce9 114
mbed_official 125:23cc3068a9e4 115 if (obj->spi == SPI_3) {
mbed_official 330:c80ac197fa6a 116 __SPI3_CLK_ENABLE();
mbed_official 125:23cc3068a9e4 117 }
mbed_official 135:067cc8ba23da 118
mbed_official 125:23cc3068a9e4 119 // Configure the SPI pins
mbed_official 125:23cc3068a9e4 120 pinmap_pinout(mosi, PinMap_SPI_MOSI);
mbed_official 125:23cc3068a9e4 121 pinmap_pinout(miso, PinMap_SPI_MISO);
mbed_official 125:23cc3068a9e4 122 pinmap_pinout(sclk, PinMap_SPI_SCLK);
mbed_official 135:067cc8ba23da 123
mbed_official 125:23cc3068a9e4 124 // Save new values
mbed_official 330:c80ac197fa6a 125 obj->bits = SPI_DATASIZE_8BIT;
mbed_official 330:c80ac197fa6a 126 obj->cpol = SPI_POLARITY_LOW;
mbed_official 330:c80ac197fa6a 127 obj->cpha = SPI_PHASE_1EDGE;
mbed_official 330:c80ac197fa6a 128 obj->br_presc = SPI_BAUDRATEPRESCALER_32; // 1 MHz (HSI) or 1.13 MHz (HSE)
mbed_official 135:067cc8ba23da 129
mbed_official 216:577900467c9e 130 obj->pin_miso = miso;
mbed_official 216:577900467c9e 131 obj->pin_mosi = mosi;
mbed_official 216:577900467c9e 132 obj->pin_sclk = sclk;
mbed_official 216:577900467c9e 133 obj->pin_ssel = ssel;
mbed_official 216:577900467c9e 134
mbed_official 330:c80ac197fa6a 135 if (ssel == NC) { // SW NSS Master mode
mbed_official 330:c80ac197fa6a 136 obj->mode = SPI_MODE_MASTER;
mbed_official 330:c80ac197fa6a 137 obj->nss = SPI_NSS_SOFT;
mbed_official 135:067cc8ba23da 138 } else { // Slave
mbed_official 125:23cc3068a9e4 139 pinmap_pinout(ssel, PinMap_SPI_SSEL);
mbed_official 330:c80ac197fa6a 140 obj->mode = SPI_MODE_SLAVE;
mbed_official 330:c80ac197fa6a 141 obj->nss = SPI_NSS_HARD_INPUT;
mbed_official 125:23cc3068a9e4 142 }
mbed_official 125:23cc3068a9e4 143
mbed_official 125:23cc3068a9e4 144 init_spi(obj);
mbed_official 125:23cc3068a9e4 145 }
mbed_official 125:23cc3068a9e4 146
mbed_official 330:c80ac197fa6a 147 void spi_free(spi_t *obj)
mbed_official 330:c80ac197fa6a 148 {
mbed_official 216:577900467c9e 149 // Reset SPI and disable clock
mbed_official 216:577900467c9e 150 if (obj->spi == SPI_2) {
mbed_official 330:c80ac197fa6a 151 __SPI2_FORCE_RESET();
mbed_official 330:c80ac197fa6a 152 __SPI2_RELEASE_RESET();
mbed_official 330:c80ac197fa6a 153 __SPI2_CLK_DISABLE();
mbed_official 216:577900467c9e 154 }
mbed_official 404:cbc7dfcb0ce9 155
mbed_official 216:577900467c9e 156 if (obj->spi == SPI_3) {
mbed_official 330:c80ac197fa6a 157 __SPI3_FORCE_RESET();
mbed_official 330:c80ac197fa6a 158 __SPI3_RELEASE_RESET();
mbed_official 330:c80ac197fa6a 159 __SPI3_CLK_DISABLE();
mbed_official 216:577900467c9e 160 }
mbed_official 216:577900467c9e 161
mbed_official 216:577900467c9e 162 // Configure GPIOs
mbed_official 330:c80ac197fa6a 163 pin_function(obj->pin_miso, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
mbed_official 330:c80ac197fa6a 164 pin_function(obj->pin_mosi, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
mbed_official 330:c80ac197fa6a 165 pin_function(obj->pin_sclk, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
mbed_official 330:c80ac197fa6a 166 pin_function(obj->pin_ssel, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
mbed_official 125:23cc3068a9e4 167 }
mbed_official 125:23cc3068a9e4 168
mbed_official 330:c80ac197fa6a 169 void spi_format(spi_t *obj, int bits, int mode, int slave)
mbed_official 330:c80ac197fa6a 170 {
mbed_official 125:23cc3068a9e4 171 // Save new values
mbed_official 233:1bbc1451db33 172 if (bits == 16) {
mbed_official 330:c80ac197fa6a 173 obj->bits = SPI_DATASIZE_16BIT;
mbed_official 233:1bbc1451db33 174 } else {
mbed_official 330:c80ac197fa6a 175 obj->bits = SPI_DATASIZE_8BIT;
mbed_official 125:23cc3068a9e4 176 }
mbed_official 135:067cc8ba23da 177
mbed_official 125:23cc3068a9e4 178 switch (mode) {
mbed_official 125:23cc3068a9e4 179 case 0:
mbed_official 330:c80ac197fa6a 180 obj->cpol = SPI_POLARITY_LOW;
mbed_official 330:c80ac197fa6a 181 obj->cpha = SPI_PHASE_1EDGE;
mbed_official 135:067cc8ba23da 182 break;
mbed_official 125:23cc3068a9e4 183 case 1:
mbed_official 330:c80ac197fa6a 184 obj->cpol = SPI_POLARITY_LOW;
mbed_official 330:c80ac197fa6a 185 obj->cpha = SPI_PHASE_2EDGE;
mbed_official 135:067cc8ba23da 186 break;
mbed_official 125:23cc3068a9e4 187 case 2:
mbed_official 330:c80ac197fa6a 188 obj->cpol = SPI_POLARITY_HIGH;
mbed_official 330:c80ac197fa6a 189 obj->cpha = SPI_PHASE_1EDGE;
mbed_official 135:067cc8ba23da 190 break;
mbed_official 125:23cc3068a9e4 191 default:
mbed_official 330:c80ac197fa6a 192 obj->cpol = SPI_POLARITY_HIGH;
mbed_official 330:c80ac197fa6a 193 obj->cpha = SPI_PHASE_2EDGE;
mbed_official 135:067cc8ba23da 194 break;
mbed_official 125:23cc3068a9e4 195 }
mbed_official 135:067cc8ba23da 196
mbed_official 125:23cc3068a9e4 197 if (slave == 0) {
mbed_official 330:c80ac197fa6a 198 obj->mode = SPI_MODE_MASTER;
mbed_official 330:c80ac197fa6a 199 obj->nss = SPI_NSS_SOFT;
mbed_official 135:067cc8ba23da 200 } else {
mbed_official 330:c80ac197fa6a 201 obj->mode = SPI_MODE_SLAVE;
mbed_official 330:c80ac197fa6a 202 obj->nss = SPI_NSS_HARD_INPUT;
mbed_official 330:c80ac197fa6a 203 }
mbed_official 330:c80ac197fa6a 204
mbed_official 330:c80ac197fa6a 205 init_spi(obj);
mbed_official 330:c80ac197fa6a 206 }
mbed_official 330:c80ac197fa6a 207
mbed_official 330:c80ac197fa6a 208 void spi_frequency(spi_t *obj, int hz)
mbed_official 330:c80ac197fa6a 209 {
mbed_official 330:c80ac197fa6a 210 // Values depend of APB1CLK : 32 MHz if HSI is used, 36 MHz if HSE is used
mbed_official 330:c80ac197fa6a 211 if (hz < 250000) {
mbed_official 330:c80ac197fa6a 212 obj->br_presc = SPI_BAUDRATEPRESCALER_256; // 125 kHz - 141 kHz
mbed_official 330:c80ac197fa6a 213 } else if ((hz >= 250000) && (hz < 500000)) {
mbed_official 330:c80ac197fa6a 214 obj->br_presc = SPI_BAUDRATEPRESCALER_128; // 250 kHz - 280 kHz
mbed_official 330:c80ac197fa6a 215 } else if ((hz >= 500000) && (hz < 1000000)) {
mbed_official 330:c80ac197fa6a 216 obj->br_presc = SPI_BAUDRATEPRESCALER_64; // 500 kHz - 560 kHz
mbed_official 330:c80ac197fa6a 217 } else if ((hz >= 1000000) && (hz < 2000000)) {
mbed_official 330:c80ac197fa6a 218 obj->br_presc = SPI_BAUDRATEPRESCALER_32; // 1 MHz - 1.13 MHz
mbed_official 330:c80ac197fa6a 219 } else if ((hz >= 2000000) && (hz < 4000000)) {
mbed_official 330:c80ac197fa6a 220 obj->br_presc = SPI_BAUDRATEPRESCALER_16; // 2 MHz - 2.25 MHz
mbed_official 330:c80ac197fa6a 221 } else if ((hz >= 4000000) && (hz < 8000000)) {
mbed_official 330:c80ac197fa6a 222 obj->br_presc = SPI_BAUDRATEPRESCALER_8; // 4 MHz - 4.5 MHz
mbed_official 330:c80ac197fa6a 223 } else if ((hz >= 8000000) && (hz < 16000000)) {
mbed_official 330:c80ac197fa6a 224 obj->br_presc = SPI_BAUDRATEPRESCALER_4; // 8 MHz - 9 MHz
mbed_official 330:c80ac197fa6a 225 } else { // >= 16000000
mbed_official 330:c80ac197fa6a 226 obj->br_presc = SPI_BAUDRATEPRESCALER_2; // 16 MHz - 18 MHz
mbed_official 125:23cc3068a9e4 227 }
mbed_official 135:067cc8ba23da 228
mbed_official 125:23cc3068a9e4 229 init_spi(obj);
mbed_official 125:23cc3068a9e4 230 }
mbed_official 125:23cc3068a9e4 231
mbed_official 330:c80ac197fa6a 232 static inline int ssp_readable(spi_t *obj)
mbed_official 330:c80ac197fa6a 233 {
mbed_official 330:c80ac197fa6a 234 int status;
mbed_official 330:c80ac197fa6a 235 SpiHandle.Instance = (SPI_TypeDef *)(obj->spi);
mbed_official 330:c80ac197fa6a 236 // Check if data is received
mbed_official 330:c80ac197fa6a 237 status = ((__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_RXNE) != RESET) ? 1 : 0);
mbed_official 330:c80ac197fa6a 238 return status;
mbed_official 125:23cc3068a9e4 239 }
mbed_official 125:23cc3068a9e4 240
mbed_official 330:c80ac197fa6a 241 static inline int ssp_writeable(spi_t *obj)
mbed_official 330:c80ac197fa6a 242 {
mbed_official 125:23cc3068a9e4 243 int status;
mbed_official 330:c80ac197fa6a 244 SpiHandle.Instance = (SPI_TypeDef *)(obj->spi);
mbed_official 330:c80ac197fa6a 245 // Check if data is transmitted
mbed_official 330:c80ac197fa6a 246 status = ((__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_TXE) != RESET) ? 1 : 0);
mbed_official 135:067cc8ba23da 247 return status;
mbed_official 125:23cc3068a9e4 248 }
mbed_official 125:23cc3068a9e4 249
mbed_official 330:c80ac197fa6a 250 static inline void ssp_write(spi_t *obj, int value)
mbed_official 330:c80ac197fa6a 251 {
mbed_official 135:067cc8ba23da 252 SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
mbed_official 125:23cc3068a9e4 253 while (!ssp_writeable(obj));
mbed_official 330:c80ac197fa6a 254 if (obj->bits == SPI_DATASIZE_8BIT) {
mbed_official 330:c80ac197fa6a 255 // Force 8-bit access to the data register
mbed_official 330:c80ac197fa6a 256 uint8_t *p_spi_dr = 0;
mbed_official 330:c80ac197fa6a 257 p_spi_dr = (uint8_t *) & (spi->DR);
mbed_official 330:c80ac197fa6a 258 *p_spi_dr = (uint8_t)value;
mbed_official 330:c80ac197fa6a 259 } else { // SPI_DATASIZE_16BIT
mbed_official 330:c80ac197fa6a 260 spi->DR = (uint16_t)value;
mbed_official 125:23cc3068a9e4 261 }
mbed_official 125:23cc3068a9e4 262 }
mbed_official 125:23cc3068a9e4 263
mbed_official 330:c80ac197fa6a 264 static inline int ssp_read(spi_t *obj)
mbed_official 330:c80ac197fa6a 265 {
mbed_official 135:067cc8ba23da 266 SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
mbed_official 125:23cc3068a9e4 267 while (!ssp_readable(obj));
mbed_official 330:c80ac197fa6a 268 if (obj->bits == SPI_DATASIZE_8BIT) {
mbed_official 330:c80ac197fa6a 269 // Force 8-bit access to the data register
mbed_official 330:c80ac197fa6a 270 uint8_t *p_spi_dr = 0;
mbed_official 330:c80ac197fa6a 271 p_spi_dr = (uint8_t *) & (spi->DR);
mbed_official 330:c80ac197fa6a 272 return (int)(*p_spi_dr);
mbed_official 135:067cc8ba23da 273 } else {
mbed_official 330:c80ac197fa6a 274 return (int)spi->DR;
mbed_official 125:23cc3068a9e4 275 }
mbed_official 125:23cc3068a9e4 276 }
mbed_official 125:23cc3068a9e4 277
mbed_official 330:c80ac197fa6a 278 static inline int ssp_busy(spi_t *obj)
mbed_official 330:c80ac197fa6a 279 {
mbed_official 125:23cc3068a9e4 280 int status;
mbed_official 330:c80ac197fa6a 281 SpiHandle.Instance = (SPI_TypeDef *)(obj->spi);
mbed_official 330:c80ac197fa6a 282 status = ((__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_BSY) != RESET) ? 1 : 0);
mbed_official 125:23cc3068a9e4 283 return status;
mbed_official 125:23cc3068a9e4 284 }
mbed_official 125:23cc3068a9e4 285
mbed_official 330:c80ac197fa6a 286 int spi_master_write(spi_t *obj, int value)
mbed_official 330:c80ac197fa6a 287 {
mbed_official 125:23cc3068a9e4 288 ssp_write(obj, value);
mbed_official 125:23cc3068a9e4 289 return ssp_read(obj);
mbed_official 125:23cc3068a9e4 290 }
mbed_official 125:23cc3068a9e4 291
mbed_official 330:c80ac197fa6a 292 int spi_slave_receive(spi_t *obj)
mbed_official 330:c80ac197fa6a 293 {
mbed_official 233:1bbc1451db33 294 return ((ssp_readable(obj) && !ssp_busy(obj)) ? 1 : 0);
mbed_official 125:23cc3068a9e4 295 };
mbed_official 125:23cc3068a9e4 296
mbed_official 330:c80ac197fa6a 297 int spi_slave_read(spi_t *obj)
mbed_official 330:c80ac197fa6a 298 {
mbed_official 125:23cc3068a9e4 299 SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
mbed_official 330:c80ac197fa6a 300 while (!ssp_readable(obj));
mbed_official 330:c80ac197fa6a 301 if (obj->bits == SPI_DATASIZE_8BIT) {
mbed_official 330:c80ac197fa6a 302 // Force 8-bit access to the data register
mbed_official 330:c80ac197fa6a 303 uint8_t *p_spi_dr = 0;
mbed_official 330:c80ac197fa6a 304 p_spi_dr = (uint8_t *) & (spi->DR);
mbed_official 330:c80ac197fa6a 305 return (int)(*p_spi_dr);
mbed_official 135:067cc8ba23da 306 } else {
mbed_official 330:c80ac197fa6a 307 return (int)spi->DR;
mbed_official 125:23cc3068a9e4 308 }
mbed_official 125:23cc3068a9e4 309 }
mbed_official 125:23cc3068a9e4 310
mbed_official 330:c80ac197fa6a 311 void spi_slave_write(spi_t *obj, int value)
mbed_official 330:c80ac197fa6a 312 {
mbed_official 135:067cc8ba23da 313 SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
mbed_official 135:067cc8ba23da 314 while (!ssp_writeable(obj));
mbed_official 330:c80ac197fa6a 315 if (obj->bits == SPI_DATASIZE_8BIT) {
mbed_official 330:c80ac197fa6a 316 // Force 8-bit access to the data register
mbed_official 330:c80ac197fa6a 317 uint8_t *p_spi_dr = 0;
mbed_official 330:c80ac197fa6a 318 p_spi_dr = (uint8_t *) & (spi->DR);
mbed_official 330:c80ac197fa6a 319 *p_spi_dr = (uint8_t)value;
mbed_official 330:c80ac197fa6a 320 } else { // SPI_DATASIZE_16BIT
mbed_official 330:c80ac197fa6a 321 spi->DR = (uint16_t)value;
mbed_official 125:23cc3068a9e4 322 }
mbed_official 125:23cc3068a9e4 323 }
mbed_official 125:23cc3068a9e4 324
mbed_official 330:c80ac197fa6a 325 int spi_busy(spi_t *obj)
mbed_official 330:c80ac197fa6a 326 {
mbed_official 125:23cc3068a9e4 327 return ssp_busy(obj);
mbed_official 125:23cc3068a9e4 328 }
mbed_official 125:23cc3068a9e4 329
mbed_official 125:23cc3068a9e4 330 #endif