Fawwaz Nadzmy / mbed-src

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-src by mbed official

targets/hal/TARGET_STM/TARGET_STM32L0/spi_api.c@531:47d2b67c511f, 2015-04-30 (annotated)

Committer:
mbed_official
Date:
Thu Apr 30 13:00:08 2015 +0100
Revision:
531:47d2b67c511f
Parent:
491:b97b6b70036c
Child:
552:a1b9575155a3
Synchronized with git revision 3b811aedb1c127ceaeeaf179a7f1c11c3a1c7956



Full URL: https://github.com/mbedmicro/mbed/commit/3b811aedb1c127ceaeeaf179a7f1c11c3a1c7956/



S130 v1.0 from Nordic. This brings in a lot of BLE4.1 functionality

Who changed what in which revision?

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