Tux Leon / mbed-dev

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-dev by mbed official

targets/TARGET_NORDIC/TARGET_NRF5/spi_api.c@160:d5399cc887bb, 2017-03-14 (annotated)

Committer:
<>
Date:
Tue Mar 14 16:40:56 2017 +0000
Revision:
160:d5399cc887bb
Parent:
150:02e0a0aed4ec
Child:
165:e614a9f1c9e2
This updates the lib to the mbed lib v138

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /*
<> 144:ef7eb2e8f9f7 2 * Copyright (c) 2013 Nordic Semiconductor ASA
<> 144:ef7eb2e8f9f7 3 * All rights reserved.
<> 144:ef7eb2e8f9f7 4 *
<> 144:ef7eb2e8f9f7 5 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 6 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 7 *
<> 144:ef7eb2e8f9f7 8 * 1. Redistributions of source code must retain the above copyright notice, this list
<> 144:ef7eb2e8f9f7 9 * of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 10 *
<> 144:ef7eb2e8f9f7 11 * 2. Redistributions in binary form, except as embedded into a Nordic Semiconductor ASA
<> 144:ef7eb2e8f9f7 12 * integrated circuit in a product or a software update for such product, must reproduce
<> 144:ef7eb2e8f9f7 13 * the above copyright notice, this list of conditions and the following disclaimer in
<> 144:ef7eb2e8f9f7 14 * the documentation and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 15 *
<> 144:ef7eb2e8f9f7 16 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its contributors may be
<> 144:ef7eb2e8f9f7 17 * used to endorse or promote products derived from this software without specific prior
<> 144:ef7eb2e8f9f7 18 * written permission.
<> 144:ef7eb2e8f9f7 19 *
<> 144:ef7eb2e8f9f7 20 * 4. This software, with or without modification, must only be used with a
<> 144:ef7eb2e8f9f7 21 * Nordic Semiconductor ASA integrated circuit.
<> 144:ef7eb2e8f9f7 22 *
<> 144:ef7eb2e8f9f7 23 * 5. Any software provided in binary or object form under this license must not be reverse
<> 144:ef7eb2e8f9f7 24 * engineered, decompiled, modified and/or disassembled.
<> 144:ef7eb2e8f9f7 25 *
<> 144:ef7eb2e8f9f7 26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
<> 144:ef7eb2e8f9f7 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
<> 144:ef7eb2e8f9f7 28 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 29 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
<> 144:ef7eb2e8f9f7 30 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
<> 144:ef7eb2e8f9f7 31 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
<> 144:ef7eb2e8f9f7 32 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
<> 144:ef7eb2e8f9f7 33 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
<> 144:ef7eb2e8f9f7 34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
<> 144:ef7eb2e8f9f7 35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 36 *
<> 144:ef7eb2e8f9f7 37 */
<> 144:ef7eb2e8f9f7 38
<> 144:ef7eb2e8f9f7 39
<> 144:ef7eb2e8f9f7 40 #include "spi_api.h"
<> 144:ef7eb2e8f9f7 41
<> 144:ef7eb2e8f9f7 42 #if DEVICE_SPI
<> 144:ef7eb2e8f9f7 43
<> 144:ef7eb2e8f9f7 44 #include "cmsis.h"
<> 144:ef7eb2e8f9f7 45 #include "pinmap.h"
<> 144:ef7eb2e8f9f7 46 #include "mbed_assert.h"
<> 144:ef7eb2e8f9f7 47 #include "mbed_error.h"
<> 144:ef7eb2e8f9f7 48 #include "nrf_drv_spi.h"
<> 144:ef7eb2e8f9f7 49 #include "nrf_drv_spis.h"
<> 144:ef7eb2e8f9f7 50 #include "app_util_platform.h"
<> 144:ef7eb2e8f9f7 51
<> 144:ef7eb2e8f9f7 52 #if DEVICE_SPI_ASYNCH
<> 144:ef7eb2e8f9f7 53 #define SPI_IDX(obj) ((obj)->spi.spi_idx)
<> 144:ef7eb2e8f9f7 54 #else
<> 144:ef7eb2e8f9f7 55 #define SPI_IDX(obj) ((obj)->spi_idx)
<> 144:ef7eb2e8f9f7 56 #endif
<> 144:ef7eb2e8f9f7 57 #define SPI_INFO(obj) (&m_spi_info[SPI_IDX(obj)])
<> 144:ef7eb2e8f9f7 58 #define MASTER_INST(obj) (&m_instances[SPI_IDX(obj)].master)
<> 144:ef7eb2e8f9f7 59 #define SLAVE_INST(obj) (&m_instances[SPI_IDX(obj)].slave)
<> 144:ef7eb2e8f9f7 60
<> 144:ef7eb2e8f9f7 61 typedef struct {
<> 144:ef7eb2e8f9f7 62 bool initialized;
<> 144:ef7eb2e8f9f7 63 bool master;
<> 144:ef7eb2e8f9f7 64 uint8_t sck_pin;
<> 144:ef7eb2e8f9f7 65 uint8_t mosi_pin;
<> 144:ef7eb2e8f9f7 66 uint8_t miso_pin;
<> 144:ef7eb2e8f9f7 67 uint8_t ss_pin;
<> 144:ef7eb2e8f9f7 68 uint8_t spi_mode;
<> 144:ef7eb2e8f9f7 69 nrf_drv_spi_frequency_t frequency;
<> 144:ef7eb2e8f9f7 70 volatile union {
<> 144:ef7eb2e8f9f7 71 bool busy; // master
<> 144:ef7eb2e8f9f7 72 bool readable; // slave
<> 144:ef7eb2e8f9f7 73 } flag;
<> 144:ef7eb2e8f9f7 74 volatile uint8_t tx_buf;
<> 144:ef7eb2e8f9f7 75 volatile uint8_t rx_buf;
<> 144:ef7eb2e8f9f7 76
<> 144:ef7eb2e8f9f7 77 #if DEVICE_SPI_ASYNCH
<> 144:ef7eb2e8f9f7 78 uint32_t handler;
<> 144:ef7eb2e8f9f7 79 uint32_t event;
<> 144:ef7eb2e8f9f7 80 #endif
<> 144:ef7eb2e8f9f7 81 } spi_info_t;
<> 144:ef7eb2e8f9f7 82 static spi_info_t m_spi_info[SPI_COUNT];
<> 144:ef7eb2e8f9f7 83
<> 144:ef7eb2e8f9f7 84 typedef struct {
<> 144:ef7eb2e8f9f7 85 nrf_drv_spi_t master;
<> 144:ef7eb2e8f9f7 86 nrf_drv_spis_t slave;
<> 144:ef7eb2e8f9f7 87 } sdk_driver_instances_t;
<> 150:02e0a0aed4ec 88
<> 150:02e0a0aed4ec 89 void SPI0_TWI0_IRQHandler(void);
<> 150:02e0a0aed4ec 90 void SPI1_TWI1_IRQHandler(void);
<> 150:02e0a0aed4ec 91 void SPIM2_SPIS2_SPI2_IRQHandler(void);
<> 150:02e0a0aed4ec 92
<> 160:d5399cc887bb 93 static const peripheral_handler_desc_t spi_handler_desc[SPI_COUNT] = {
<> 150:02e0a0aed4ec 94 #if SPI0_ENABLED
<> 150:02e0a0aed4ec 95 {
<> 160:d5399cc887bb 96 SPI0_IRQ,
<> 150:02e0a0aed4ec 97 (uint32_t) SPI0_TWI0_IRQHandler
<> 150:02e0a0aed4ec 98 },
<> 150:02e0a0aed4ec 99 #endif
<> 150:02e0a0aed4ec 100 #if SPI1_ENABLED
<> 150:02e0a0aed4ec 101 {
<> 160:d5399cc887bb 102 SPI1_IRQ,
<> 150:02e0a0aed4ec 103 (uint32_t) SPI1_TWI1_IRQHandler
<> 150:02e0a0aed4ec 104 },
<> 150:02e0a0aed4ec 105 #endif
<> 150:02e0a0aed4ec 106 #if SPI2_ENABLED
<> 150:02e0a0aed4ec 107 {
<> 160:d5399cc887bb 108 SPI2_IRQ,
<> 150:02e0a0aed4ec 109 (uint32_t) SPIM2_SPIS2_SPI2_IRQHandler
<> 150:02e0a0aed4ec 110 },
<> 150:02e0a0aed4ec 111 #endif
<> 150:02e0a0aed4ec 112 };
<> 150:02e0a0aed4ec 113
<> 150:02e0a0aed4ec 114
<> 144:ef7eb2e8f9f7 115 static sdk_driver_instances_t m_instances[SPI_COUNT] = {
<> 150:02e0a0aed4ec 116 #if SPI0_ENABLED
<> 144:ef7eb2e8f9f7 117 {
<> 144:ef7eb2e8f9f7 118 NRF_DRV_SPI_INSTANCE(0),
<> 144:ef7eb2e8f9f7 119 NRF_DRV_SPIS_INSTANCE(0)
<> 144:ef7eb2e8f9f7 120 },
<> 150:02e0a0aed4ec 121 #endif
<> 150:02e0a0aed4ec 122 #if SPI1_ENABLED
<> 144:ef7eb2e8f9f7 123 {
<> 144:ef7eb2e8f9f7 124 NRF_DRV_SPI_INSTANCE(1),
<> 144:ef7eb2e8f9f7 125 NRF_DRV_SPIS_INSTANCE(1)
<> 144:ef7eb2e8f9f7 126 },
<> 150:02e0a0aed4ec 127 #endif
<> 150:02e0a0aed4ec 128 #if SPI2_ENABLED
<> 144:ef7eb2e8f9f7 129 {
<> 144:ef7eb2e8f9f7 130 NRF_DRV_SPI_INSTANCE(2),
<> 144:ef7eb2e8f9f7 131 NRF_DRV_SPIS_INSTANCE(2)
<> 144:ef7eb2e8f9f7 132 },
<> 150:02e0a0aed4ec 133 #endif
<> 144:ef7eb2e8f9f7 134 };
<> 144:ef7eb2e8f9f7 135
<> 144:ef7eb2e8f9f7 136 static void master_event_handler(uint8_t spi_idx,
<> 144:ef7eb2e8f9f7 137 nrf_drv_spi_evt_t const *p_event)
<> 144:ef7eb2e8f9f7 138 {
<> 144:ef7eb2e8f9f7 139 spi_info_t *p_spi_info = &m_spi_info[spi_idx];
<> 144:ef7eb2e8f9f7 140
<> 144:ef7eb2e8f9f7 141 if (p_event->type == NRF_DRV_SPI_EVENT_DONE) {
<> 144:ef7eb2e8f9f7 142 p_spi_info->flag.busy = false;
<> 144:ef7eb2e8f9f7 143 if (p_spi_info->handler) {
<> 144:ef7eb2e8f9f7 144 void (*handler)(void) = (void (*)(void))p_spi_info->handler;
<> 144:ef7eb2e8f9f7 145 p_spi_info->handler = 0;
<> 144:ef7eb2e8f9f7 146 handler();
<> 144:ef7eb2e8f9f7 147 }
<> 144:ef7eb2e8f9f7 148 }
<> 144:ef7eb2e8f9f7 149 }
<> 144:ef7eb2e8f9f7 150 #define MASTER_EVENT_HANDLER(idx) \
<> 144:ef7eb2e8f9f7 151 static void master_event_handler_##idx(nrf_drv_spi_evt_t const *p_event) { \
<> 144:ef7eb2e8f9f7 152 master_event_handler(SPI##idx##_INSTANCE_INDEX, p_event); \
<> 144:ef7eb2e8f9f7 153 }
<> 144:ef7eb2e8f9f7 154 #if SPI0_ENABLED
<> 144:ef7eb2e8f9f7 155 MASTER_EVENT_HANDLER(0)
<> 144:ef7eb2e8f9f7 156 #endif
<> 144:ef7eb2e8f9f7 157 #if SPI1_ENABLED
<> 144:ef7eb2e8f9f7 158 MASTER_EVENT_HANDLER(1)
<> 144:ef7eb2e8f9f7 159 #endif
<> 144:ef7eb2e8f9f7 160 #if SPI2_ENABLED
<> 144:ef7eb2e8f9f7 161 MASTER_EVENT_HANDLER(2)
<> 144:ef7eb2e8f9f7 162 #endif
<> 144:ef7eb2e8f9f7 163
<> 144:ef7eb2e8f9f7 164 static nrf_drv_spi_handler_t const m_master_event_handlers[SPI_COUNT] = {
<> 144:ef7eb2e8f9f7 165 #if SPI0_ENABLED
<> 144:ef7eb2e8f9f7 166 master_event_handler_0,
<> 144:ef7eb2e8f9f7 167 #endif
<> 144:ef7eb2e8f9f7 168 #if SPI1_ENABLED
<> 144:ef7eb2e8f9f7 169 master_event_handler_1,
<> 144:ef7eb2e8f9f7 170 #endif
<> 144:ef7eb2e8f9f7 171 #if SPI2_ENABLED
<> 144:ef7eb2e8f9f7 172 master_event_handler_2,
<> 144:ef7eb2e8f9f7 173 #endif
<> 144:ef7eb2e8f9f7 174 };
<> 144:ef7eb2e8f9f7 175
<> 144:ef7eb2e8f9f7 176
<> 144:ef7eb2e8f9f7 177 static void slave_event_handler(uint8_t spi_idx,
<> 144:ef7eb2e8f9f7 178 nrf_drv_spis_event_t event)
<> 144:ef7eb2e8f9f7 179 {
<> 144:ef7eb2e8f9f7 180 spi_info_t *p_spi_info = &m_spi_info[spi_idx];
<> 144:ef7eb2e8f9f7 181
<> 144:ef7eb2e8f9f7 182 if (event.evt_type == NRF_DRV_SPIS_XFER_DONE) {
<> 144:ef7eb2e8f9f7 183 // Signal that there is some data received that could be read.
<> 144:ef7eb2e8f9f7 184 p_spi_info->flag.readable = true;
<> 144:ef7eb2e8f9f7 185
<> 144:ef7eb2e8f9f7 186 // And prepare for the next transfer.
<> 144:ef7eb2e8f9f7 187 // Previous data set in 'spi_slave_write' (if any) has been transmitted,
<> 144:ef7eb2e8f9f7 188 // now use the default one, until some new is set by 'spi_slave_write'.
<> 144:ef7eb2e8f9f7 189 p_spi_info->tx_buf = NRF_DRV_SPIS_DEFAULT_ORC;
<> 144:ef7eb2e8f9f7 190 nrf_drv_spis_buffers_set(&m_instances[spi_idx].slave,
<> 144:ef7eb2e8f9f7 191 (uint8_t const *)&p_spi_info->tx_buf, 1,
<> 144:ef7eb2e8f9f7 192 (uint8_t *)&p_spi_info->rx_buf, 1);
<> 144:ef7eb2e8f9f7 193 }
<> 144:ef7eb2e8f9f7 194 }
<> 144:ef7eb2e8f9f7 195 #define SLAVE_EVENT_HANDLER(idx) \
<> 144:ef7eb2e8f9f7 196 static void slave_event_handler_##idx(nrf_drv_spis_event_t event) { \
<> 144:ef7eb2e8f9f7 197 slave_event_handler(SPIS##idx##_INSTANCE_INDEX, event); \
<> 144:ef7eb2e8f9f7 198 }
<> 144:ef7eb2e8f9f7 199 #if SPIS0_ENABLED
<> 144:ef7eb2e8f9f7 200 SLAVE_EVENT_HANDLER(0)
<> 144:ef7eb2e8f9f7 201 #endif
<> 144:ef7eb2e8f9f7 202 #if SPIS1_ENABLED
<> 144:ef7eb2e8f9f7 203 SLAVE_EVENT_HANDLER(1)
<> 144:ef7eb2e8f9f7 204 #endif
<> 144:ef7eb2e8f9f7 205 #if SPIS2_ENABLED
<> 144:ef7eb2e8f9f7 206 SLAVE_EVENT_HANDLER(2)
<> 144:ef7eb2e8f9f7 207 #endif
<> 144:ef7eb2e8f9f7 208
<> 144:ef7eb2e8f9f7 209 static nrf_drv_spis_event_handler_t const m_slave_event_handlers[SPIS_COUNT] = {
<> 144:ef7eb2e8f9f7 210 #if SPIS0_ENABLED
<> 144:ef7eb2e8f9f7 211 slave_event_handler_0,
<> 144:ef7eb2e8f9f7 212 #endif
<> 144:ef7eb2e8f9f7 213 #if SPIS1_ENABLED
<> 144:ef7eb2e8f9f7 214 slave_event_handler_1,
<> 144:ef7eb2e8f9f7 215 #endif
<> 144:ef7eb2e8f9f7 216 #if SPIS2_ENABLED
<> 144:ef7eb2e8f9f7 217 slave_event_handler_2,
<> 144:ef7eb2e8f9f7 218 #endif
<> 144:ef7eb2e8f9f7 219 };
<> 144:ef7eb2e8f9f7 220
<> 144:ef7eb2e8f9f7 221 static void prepare_master_config(nrf_drv_spi_config_t *p_config,
<> 144:ef7eb2e8f9f7 222 spi_info_t const *p_spi_info)
<> 144:ef7eb2e8f9f7 223 {
<> 144:ef7eb2e8f9f7 224 p_config->sck_pin = p_spi_info->sck_pin;
<> 144:ef7eb2e8f9f7 225 p_config->mosi_pin = p_spi_info->mosi_pin;
<> 144:ef7eb2e8f9f7 226 p_config->miso_pin = p_spi_info->miso_pin;
<> 144:ef7eb2e8f9f7 227 p_config->ss_pin = p_spi_info->ss_pin;
<> 144:ef7eb2e8f9f7 228 p_config->frequency = p_spi_info->frequency;
<> 144:ef7eb2e8f9f7 229 p_config->mode = (nrf_drv_spi_mode_t)p_spi_info->spi_mode;
<> 144:ef7eb2e8f9f7 230
<> 150:02e0a0aed4ec 231 p_config->irq_priority = SPI1_CONFIG_IRQ_PRIORITY;
<> 144:ef7eb2e8f9f7 232 p_config->orc = 0xFF;
<> 144:ef7eb2e8f9f7 233 p_config->bit_order = NRF_DRV_SPI_BIT_ORDER_MSB_FIRST;
<> 144:ef7eb2e8f9f7 234 }
<> 144:ef7eb2e8f9f7 235
<> 144:ef7eb2e8f9f7 236 static void prepare_slave_config(nrf_drv_spis_config_t *p_config,
<> 144:ef7eb2e8f9f7 237 spi_info_t const *p_spi_info)
<> 144:ef7eb2e8f9f7 238 {
<> 144:ef7eb2e8f9f7 239 p_config->sck_pin = p_spi_info->sck_pin;
<> 144:ef7eb2e8f9f7 240 p_config->mosi_pin = p_spi_info->mosi_pin;
<> 144:ef7eb2e8f9f7 241 p_config->miso_pin = p_spi_info->miso_pin;
<> 144:ef7eb2e8f9f7 242 p_config->csn_pin = p_spi_info->ss_pin;
<> 144:ef7eb2e8f9f7 243 p_config->mode = (nrf_drv_spis_mode_t)p_spi_info->spi_mode;
<> 144:ef7eb2e8f9f7 244
<> 150:02e0a0aed4ec 245 p_config->irq_priority = SPIS1_CONFIG_IRQ_PRIORITY;
<> 144:ef7eb2e8f9f7 246 p_config->orc = NRF_DRV_SPIS_DEFAULT_ORC;
<> 144:ef7eb2e8f9f7 247 p_config->def = NRF_DRV_SPIS_DEFAULT_DEF;
<> 144:ef7eb2e8f9f7 248 p_config->bit_order = NRF_DRV_SPIS_BIT_ORDER_MSB_FIRST;
<> 144:ef7eb2e8f9f7 249 p_config->csn_pullup = NRF_DRV_SPIS_DEFAULT_CSN_PULLUP;
<> 144:ef7eb2e8f9f7 250 p_config->miso_drive = NRF_DRV_SPIS_DEFAULT_MISO_DRIVE;
<> 144:ef7eb2e8f9f7 251 }
<> 144:ef7eb2e8f9f7 252
<> 144:ef7eb2e8f9f7 253 void spi_init(spi_t *obj,
<> 144:ef7eb2e8f9f7 254 PinName mosi, PinName miso, PinName sclk, PinName ssel)
<> 144:ef7eb2e8f9f7 255 {
<> 144:ef7eb2e8f9f7 256 int i;
<> 160:d5399cc887bb 257
<> 160:d5399cc887bb 258 // This block is only a workaround that allows to create SPI object several
<> 160:d5399cc887bb 259 // times, what would be otherwise impossible in the current implementation
<> 160:d5399cc887bb 260 // of mbed driver that does not call spi_free() from SPI destructor.
<> 160:d5399cc887bb 261 // Once this mbed's imperfection is corrected, this block should be removed.
<> 160:d5399cc887bb 262 for (i = 0; i < SPI_COUNT; ++i) {
<> 160:d5399cc887bb 263 spi_info_t *p_spi_info = &m_spi_info[i];
<> 160:d5399cc887bb 264 if (p_spi_info->initialized &&
<> 160:d5399cc887bb 265 p_spi_info->mosi_pin == (uint8_t)mosi &&
<> 160:d5399cc887bb 266 p_spi_info->miso_pin == (uint8_t)miso &&
<> 160:d5399cc887bb 267 p_spi_info->sck_pin == (uint8_t)sclk &&
<> 160:d5399cc887bb 268 p_spi_info->ss_pin == (uint8_t)ssel) {
<> 160:d5399cc887bb 269 // Reuse the already allocated SPI instance (instead of allocating
<> 160:d5399cc887bb 270 // a new one), if it appears to be initialized with exactly the same
<> 160:d5399cc887bb 271 // pin assignments.
<> 160:d5399cc887bb 272 SPI_IDX(obj) = i;
<> 160:d5399cc887bb 273 return;
<> 160:d5399cc887bb 274 }
<> 160:d5399cc887bb 275 }
<> 160:d5399cc887bb 276
<> 144:ef7eb2e8f9f7 277 for (i = 0; i < SPI_COUNT; ++i) {
<> 144:ef7eb2e8f9f7 278 spi_info_t *p_spi_info = &m_spi_info[i];
<> 144:ef7eb2e8f9f7 279 if (!p_spi_info->initialized) {
<> 144:ef7eb2e8f9f7 280 p_spi_info->sck_pin = (uint8_t)sclk;
<> 144:ef7eb2e8f9f7 281 p_spi_info->mosi_pin = (mosi != NC) ?
<> 144:ef7eb2e8f9f7 282 (uint8_t)mosi : NRF_DRV_SPI_PIN_NOT_USED;
<> 144:ef7eb2e8f9f7 283 p_spi_info->miso_pin = (miso != NC) ?
<> 144:ef7eb2e8f9f7 284 (uint8_t)miso : NRF_DRV_SPI_PIN_NOT_USED;
<> 144:ef7eb2e8f9f7 285 p_spi_info->ss_pin = (ssel != NC) ?
<> 144:ef7eb2e8f9f7 286 (uint8_t)ssel : NRF_DRV_SPI_PIN_NOT_USED;
<> 144:ef7eb2e8f9f7 287 p_spi_info->spi_mode = (uint8_t)NRF_DRV_SPI_MODE_0;
<> 144:ef7eb2e8f9f7 288 p_spi_info->frequency = NRF_DRV_SPI_FREQ_1M;
<> 144:ef7eb2e8f9f7 289
<> 160:d5399cc887bb 290 NVIC_SetVector(spi_handler_desc[i].IRQn, spi_handler_desc[i].vector);
<> 160:d5399cc887bb 291
<> 144:ef7eb2e8f9f7 292 // By default each SPI instance is initialized to work as a master.
<> 144:ef7eb2e8f9f7 293 // Should the slave mode be used, the instance will be reconfigured
<> 144:ef7eb2e8f9f7 294 // appropriately in 'spi_format'.
<> 144:ef7eb2e8f9f7 295 nrf_drv_spi_config_t config;
<> 144:ef7eb2e8f9f7 296 prepare_master_config(&config, p_spi_info);
<> 144:ef7eb2e8f9f7 297
<> 144:ef7eb2e8f9f7 298 nrf_drv_spi_t const *p_spi = &m_instances[i].master;
<> 144:ef7eb2e8f9f7 299 ret_code_t ret_code = nrf_drv_spi_init(p_spi,
<> 144:ef7eb2e8f9f7 300 &config, m_master_event_handlers[i]);
<> 144:ef7eb2e8f9f7 301 if (ret_code == NRF_SUCCESS) {
<> 144:ef7eb2e8f9f7 302 p_spi_info->initialized = true;
<> 144:ef7eb2e8f9f7 303 p_spi_info->master = true;
<> 144:ef7eb2e8f9f7 304 p_spi_info->flag.busy = false;
<> 144:ef7eb2e8f9f7 305 #if DEVICE_SPI_ASYNCH
<> 144:ef7eb2e8f9f7 306 p_spi_info->handler = 0;
<> 144:ef7eb2e8f9f7 307 #endif
<> 144:ef7eb2e8f9f7 308 SPI_IDX(obj) = i;
<> 144:ef7eb2e8f9f7 309
<> 144:ef7eb2e8f9f7 310 return;
<> 144:ef7eb2e8f9f7 311 }
<> 144:ef7eb2e8f9f7 312 }
<> 144:ef7eb2e8f9f7 313 }
<> 144:ef7eb2e8f9f7 314
<> 144:ef7eb2e8f9f7 315 // No available peripheral
<> 144:ef7eb2e8f9f7 316 error("No available SPI peripheral\r\n");
<> 144:ef7eb2e8f9f7 317 }
<> 144:ef7eb2e8f9f7 318
<> 144:ef7eb2e8f9f7 319 void spi_free(spi_t *obj)
<> 144:ef7eb2e8f9f7 320 {
<> 144:ef7eb2e8f9f7 321 spi_info_t *p_spi_info = SPI_INFO(obj);
<> 144:ef7eb2e8f9f7 322 if (p_spi_info->master) {
<> 144:ef7eb2e8f9f7 323 nrf_drv_spi_uninit(MASTER_INST(obj));
<> 144:ef7eb2e8f9f7 324 }
<> 144:ef7eb2e8f9f7 325 else {
<> 144:ef7eb2e8f9f7 326 nrf_drv_spis_uninit(SLAVE_INST(obj));
<> 144:ef7eb2e8f9f7 327 }
<> 144:ef7eb2e8f9f7 328 p_spi_info->initialized = false;
<> 144:ef7eb2e8f9f7 329 }
<> 144:ef7eb2e8f9f7 330
<> 144:ef7eb2e8f9f7 331 int spi_busy(spi_t *obj)
<> 144:ef7eb2e8f9f7 332 {
<> 144:ef7eb2e8f9f7 333 return (int)(SPI_INFO(obj)->flag.busy);
<> 144:ef7eb2e8f9f7 334 }
<> 144:ef7eb2e8f9f7 335
<> 144:ef7eb2e8f9f7 336 void spi_format(spi_t *obj, int bits, int mode, int slave)
<> 144:ef7eb2e8f9f7 337 {
<> 144:ef7eb2e8f9f7 338 if (bits != 8) {
<> 144:ef7eb2e8f9f7 339 error("Only 8-bits SPI is supported\r\n");
<> 144:ef7eb2e8f9f7 340 }
<> 144:ef7eb2e8f9f7 341 if (mode > 3) {
<> 144:ef7eb2e8f9f7 342 error("SPI format error\r\n");
<> 144:ef7eb2e8f9f7 343 }
<> 144:ef7eb2e8f9f7 344
<> 144:ef7eb2e8f9f7 345 spi_info_t *p_spi_info = SPI_INFO(obj);
<> 144:ef7eb2e8f9f7 346
<> 144:ef7eb2e8f9f7 347 if (slave)
<> 144:ef7eb2e8f9f7 348 {
<> 144:ef7eb2e8f9f7 349 nrf_drv_spis_mode_t spi_modes[4] = {
<> 144:ef7eb2e8f9f7 350 NRF_DRV_SPIS_MODE_0,
<> 144:ef7eb2e8f9f7 351 NRF_DRV_SPIS_MODE_1,
<> 144:ef7eb2e8f9f7 352 NRF_DRV_SPIS_MODE_2,
<> 144:ef7eb2e8f9f7 353 NRF_DRV_SPIS_MODE_3,
<> 144:ef7eb2e8f9f7 354 };
<> 144:ef7eb2e8f9f7 355 nrf_drv_spis_mode_t new_mode = spi_modes[mode];
<> 144:ef7eb2e8f9f7 356
<> 144:ef7eb2e8f9f7 357 // If the peripheral is currently working as a master, the SDK driver
<> 144:ef7eb2e8f9f7 358 // it uses needs to be switched from SPI to SPIS.
<> 144:ef7eb2e8f9f7 359 if (p_spi_info->master) {
<> 144:ef7eb2e8f9f7 360 nrf_drv_spi_uninit(MASTER_INST(obj));
<> 144:ef7eb2e8f9f7 361 }
<> 144:ef7eb2e8f9f7 362 // I the SPI mode has to be changed, the SDK's SPIS driver needs to be
<> 144:ef7eb2e8f9f7 363 // re-initialized (there is no other way to change its configuration).
<> 144:ef7eb2e8f9f7 364 else if (p_spi_info->spi_mode != (uint8_t)new_mode) {
<> 144:ef7eb2e8f9f7 365 nrf_drv_spis_uninit(SLAVE_INST(obj));
<> 144:ef7eb2e8f9f7 366 }
<> 144:ef7eb2e8f9f7 367 else {
<> 144:ef7eb2e8f9f7 368 return;
<> 144:ef7eb2e8f9f7 369 }
<> 144:ef7eb2e8f9f7 370
<> 144:ef7eb2e8f9f7 371 p_spi_info->spi_mode = (uint8_t)new_mode;
<> 144:ef7eb2e8f9f7 372 p_spi_info->master = false;
<> 144:ef7eb2e8f9f7 373 p_spi_info->flag.readable = false;
<> 144:ef7eb2e8f9f7 374
<> 144:ef7eb2e8f9f7 375 // Initialize SDK's SPIS driver with the new configuration.
<> 144:ef7eb2e8f9f7 376 nrf_drv_spis_config_t config;
<> 144:ef7eb2e8f9f7 377 prepare_slave_config(&config, p_spi_info);
<> 144:ef7eb2e8f9f7 378 (void)nrf_drv_spis_init(SLAVE_INST(obj), &config,
<> 144:ef7eb2e8f9f7 379 m_slave_event_handlers[SPI_IDX(obj)]);
<> 144:ef7eb2e8f9f7 380
<> 144:ef7eb2e8f9f7 381 // Prepare the slave for transfer.
<> 144:ef7eb2e8f9f7 382 p_spi_info->tx_buf = NRF_DRV_SPIS_DEFAULT_ORC;
<> 144:ef7eb2e8f9f7 383 nrf_drv_spis_buffers_set(SLAVE_INST(obj),
<> 144:ef7eb2e8f9f7 384 (uint8_t const *)&p_spi_info->tx_buf, 1,
<> 144:ef7eb2e8f9f7 385 (uint8_t *)&p_spi_info->rx_buf, 1);
<> 144:ef7eb2e8f9f7 386 }
<> 144:ef7eb2e8f9f7 387 else // master
<> 144:ef7eb2e8f9f7 388 {
<> 144:ef7eb2e8f9f7 389 nrf_drv_spi_mode_t spi_modes[4] = {
<> 144:ef7eb2e8f9f7 390 NRF_DRV_SPI_MODE_0,
<> 144:ef7eb2e8f9f7 391 NRF_DRV_SPI_MODE_1,
<> 144:ef7eb2e8f9f7 392 NRF_DRV_SPI_MODE_2,
<> 144:ef7eb2e8f9f7 393 NRF_DRV_SPI_MODE_3,
<> 144:ef7eb2e8f9f7 394 };
<> 144:ef7eb2e8f9f7 395 nrf_drv_spi_mode_t new_mode = spi_modes[mode];
<> 144:ef7eb2e8f9f7 396
<> 144:ef7eb2e8f9f7 397 // If the peripheral is currently working as a slave, the SDK driver
<> 144:ef7eb2e8f9f7 398 // it uses needs to be switched from SPIS to SPI.
<> 144:ef7eb2e8f9f7 399 if (!p_spi_info->master) {
<> 144:ef7eb2e8f9f7 400 nrf_drv_spis_uninit(SLAVE_INST(obj));
<> 144:ef7eb2e8f9f7 401 }
<> 144:ef7eb2e8f9f7 402 // I the SPI mode has to be changed, the SDK's SPI driver needs to be
<> 144:ef7eb2e8f9f7 403 // re-initialized (there is no other way to change its configuration).
<> 144:ef7eb2e8f9f7 404 else if (p_spi_info->spi_mode != (uint8_t)new_mode) {
<> 144:ef7eb2e8f9f7 405 nrf_drv_spi_uninit(MASTER_INST(obj));
<> 144:ef7eb2e8f9f7 406 }
<> 144:ef7eb2e8f9f7 407 else {
<> 144:ef7eb2e8f9f7 408 return;
<> 144:ef7eb2e8f9f7 409 }
<> 144:ef7eb2e8f9f7 410
<> 144:ef7eb2e8f9f7 411 p_spi_info->spi_mode = (uint8_t)new_mode;
<> 144:ef7eb2e8f9f7 412 p_spi_info->master = true;
<> 144:ef7eb2e8f9f7 413 p_spi_info->flag.busy = false;
<> 144:ef7eb2e8f9f7 414
<> 144:ef7eb2e8f9f7 415 // Initialize SDK's SPI driver with the new configuration.
<> 144:ef7eb2e8f9f7 416 nrf_drv_spi_config_t config;
<> 144:ef7eb2e8f9f7 417 prepare_master_config(&config, p_spi_info);
<> 144:ef7eb2e8f9f7 418 (void)nrf_drv_spi_init(MASTER_INST(obj), &config,
<> 144:ef7eb2e8f9f7 419 m_master_event_handlers[SPI_IDX(obj)]);
<> 144:ef7eb2e8f9f7 420 }
<> 144:ef7eb2e8f9f7 421 }
<> 144:ef7eb2e8f9f7 422
<> 144:ef7eb2e8f9f7 423 static nrf_drv_spi_frequency_t freq_translate(int hz)
<> 144:ef7eb2e8f9f7 424 {
<> 144:ef7eb2e8f9f7 425 nrf_drv_spi_frequency_t frequency;
<> 144:ef7eb2e8f9f7 426 if (hz<250000) { //125Kbps
<> 144:ef7eb2e8f9f7 427 frequency = NRF_DRV_SPI_FREQ_125K;
<> 144:ef7eb2e8f9f7 428 } else if (hz<500000) { //250Kbps
<> 144:ef7eb2e8f9f7 429 frequency = NRF_DRV_SPI_FREQ_250K;
<> 144:ef7eb2e8f9f7 430 } else if (hz<1000000) { //500Kbps
<> 144:ef7eb2e8f9f7 431 frequency = NRF_DRV_SPI_FREQ_500K;
<> 144:ef7eb2e8f9f7 432 } else if (hz<2000000) { //1Mbps
<> 144:ef7eb2e8f9f7 433 frequency = NRF_DRV_SPI_FREQ_1M;
<> 144:ef7eb2e8f9f7 434 } else if (hz<4000000) { //2Mbps
<> 144:ef7eb2e8f9f7 435 frequency = NRF_DRV_SPI_FREQ_2M;
<> 144:ef7eb2e8f9f7 436 } else if (hz<8000000) { //4Mbps
<> 144:ef7eb2e8f9f7 437 frequency = NRF_DRV_SPI_FREQ_4M;
<> 144:ef7eb2e8f9f7 438 } else { //8Mbps
<> 144:ef7eb2e8f9f7 439 frequency = NRF_DRV_SPI_FREQ_8M;
<> 144:ef7eb2e8f9f7 440 }
<> 144:ef7eb2e8f9f7 441 return frequency;
<> 144:ef7eb2e8f9f7 442 }
<> 144:ef7eb2e8f9f7 443
<> 144:ef7eb2e8f9f7 444 void spi_frequency(spi_t *obj, int hz)
<> 144:ef7eb2e8f9f7 445 {
<> 144:ef7eb2e8f9f7 446 spi_info_t *p_spi_info = SPI_INFO(obj);
<> 144:ef7eb2e8f9f7 447 nrf_drv_spi_frequency_t new_frequency = freq_translate(hz);
<> 144:ef7eb2e8f9f7 448
<> 144:ef7eb2e8f9f7 449 if (p_spi_info->master)
<> 144:ef7eb2e8f9f7 450 {
<> 144:ef7eb2e8f9f7 451 if (p_spi_info->frequency != new_frequency) {
<> 144:ef7eb2e8f9f7 452 p_spi_info->frequency = new_frequency;
<> 144:ef7eb2e8f9f7 453
<> 144:ef7eb2e8f9f7 454 nrf_drv_spi_config_t config;
<> 144:ef7eb2e8f9f7 455 prepare_master_config(&config, p_spi_info);
<> 144:ef7eb2e8f9f7 456
<> 144:ef7eb2e8f9f7 457 nrf_drv_spi_t const *p_spi = MASTER_INST(obj);
<> 144:ef7eb2e8f9f7 458 nrf_drv_spi_uninit(p_spi);
<> 144:ef7eb2e8f9f7 459 (void)nrf_drv_spi_init(p_spi, &config,
<> 144:ef7eb2e8f9f7 460 m_master_event_handlers[SPI_IDX(obj)]);
<> 144:ef7eb2e8f9f7 461 }
<> 144:ef7eb2e8f9f7 462 }
<> 144:ef7eb2e8f9f7 463 // There is no need to set anything in slaves when it comes to frequency,
<> 144:ef7eb2e8f9f7 464 // since slaves just synchronize with the clock provided by a master.
<> 144:ef7eb2e8f9f7 465 }
<> 144:ef7eb2e8f9f7 466
<> 144:ef7eb2e8f9f7 467 int spi_master_write(spi_t *obj, int value)
<> 144:ef7eb2e8f9f7 468 {
<> 144:ef7eb2e8f9f7 469 spi_info_t *p_spi_info = SPI_INFO(obj);
<> 144:ef7eb2e8f9f7 470
<> 144:ef7eb2e8f9f7 471 #if DEVICE_SPI_ASYNCH
<> 144:ef7eb2e8f9f7 472 while (p_spi_info->flag.busy) {
<> 144:ef7eb2e8f9f7 473 }
<> 144:ef7eb2e8f9f7 474 #endif
<> 144:ef7eb2e8f9f7 475
<> 144:ef7eb2e8f9f7 476 p_spi_info->tx_buf = value;
<> 144:ef7eb2e8f9f7 477 p_spi_info->flag.busy = true;
<> 144:ef7eb2e8f9f7 478 (void)nrf_drv_spi_transfer(MASTER_INST(obj),
<> 144:ef7eb2e8f9f7 479 (uint8_t const *)&p_spi_info->tx_buf, 1,
<> 144:ef7eb2e8f9f7 480 (uint8_t *)&p_spi_info->rx_buf, 1);
<> 144:ef7eb2e8f9f7 481 while (p_spi_info->flag.busy) {
<> 144:ef7eb2e8f9f7 482 }
<> 144:ef7eb2e8f9f7 483
<> 144:ef7eb2e8f9f7 484 return p_spi_info->rx_buf;
<> 144:ef7eb2e8f9f7 485 }
<> 144:ef7eb2e8f9f7 486
<> 144:ef7eb2e8f9f7 487 int spi_slave_receive(spi_t *obj)
<> 144:ef7eb2e8f9f7 488 {
<> 144:ef7eb2e8f9f7 489 spi_info_t *p_spi_info = SPI_INFO(obj);
<> 144:ef7eb2e8f9f7 490 MBED_ASSERT(!p_spi_info->master);
<> 144:ef7eb2e8f9f7 491 return p_spi_info->flag.readable;
<> 144:ef7eb2e8f9f7 492 ;
<> 144:ef7eb2e8f9f7 493 }
<> 144:ef7eb2e8f9f7 494
<> 144:ef7eb2e8f9f7 495 int spi_slave_read(spi_t *obj)
<> 144:ef7eb2e8f9f7 496 {
<> 144:ef7eb2e8f9f7 497 spi_info_t *p_spi_info = SPI_INFO(obj);
<> 144:ef7eb2e8f9f7 498 MBED_ASSERT(!p_spi_info->master);
<> 144:ef7eb2e8f9f7 499 while (!p_spi_info->flag.readable) {
<> 144:ef7eb2e8f9f7 500 }
<> 144:ef7eb2e8f9f7 501 p_spi_info->flag.readable = false;
<> 144:ef7eb2e8f9f7 502 return p_spi_info->rx_buf;
<> 144:ef7eb2e8f9f7 503 }
<> 144:ef7eb2e8f9f7 504
<> 144:ef7eb2e8f9f7 505 void spi_slave_write(spi_t *obj, int value)
<> 144:ef7eb2e8f9f7 506 {
<> 144:ef7eb2e8f9f7 507 spi_info_t *p_spi_info = SPI_INFO(obj);
<> 144:ef7eb2e8f9f7 508 MBED_ASSERT(!p_spi_info->master);
<> 144:ef7eb2e8f9f7 509
<> 144:ef7eb2e8f9f7 510 p_spi_info->tx_buf = (uint8_t)value;
<> 144:ef7eb2e8f9f7 511 }
<> 144:ef7eb2e8f9f7 512
<> 144:ef7eb2e8f9f7 513 #if DEVICE_SPI_ASYNCH
<> 144:ef7eb2e8f9f7 514
<> 144:ef7eb2e8f9f7 515 void spi_master_transfer(spi_t *obj,
<> 144:ef7eb2e8f9f7 516 const void *tx, size_t tx_length,
<> 144:ef7eb2e8f9f7 517 void *rx, size_t rx_length, uint8_t bit_width,
<> 144:ef7eb2e8f9f7 518 uint32_t handler, uint32_t event, DMAUsage hint)
<> 144:ef7eb2e8f9f7 519 {
<> 144:ef7eb2e8f9f7 520 spi_info_t *p_spi_info = SPI_INFO(obj);
<> 144:ef7eb2e8f9f7 521 MBED_ASSERT(p_spi_info->master);
<> 144:ef7eb2e8f9f7 522 (void)hint;
<> 144:ef7eb2e8f9f7 523 (void)bit_width;
<> 144:ef7eb2e8f9f7 524
<> 144:ef7eb2e8f9f7 525 p_spi_info->handler = handler;
<> 144:ef7eb2e8f9f7 526 p_spi_info->event = event;
<> 144:ef7eb2e8f9f7 527
<> 144:ef7eb2e8f9f7 528 p_spi_info->flag.busy = true;
<> 144:ef7eb2e8f9f7 529 (void)nrf_drv_spi_transfer(MASTER_INST(obj),
<> 144:ef7eb2e8f9f7 530 (uint8_t const *)tx, tx_length,
<> 144:ef7eb2e8f9f7 531 (uint8_t *)rx, rx_length);
<> 144:ef7eb2e8f9f7 532 }
<> 144:ef7eb2e8f9f7 533
<> 144:ef7eb2e8f9f7 534 uint32_t spi_irq_handler_asynch(spi_t *obj)
<> 144:ef7eb2e8f9f7 535 {
<> 144:ef7eb2e8f9f7 536 spi_info_t *p_spi_info = SPI_INFO(obj);
<> 144:ef7eb2e8f9f7 537 MBED_ASSERT(p_spi_info->master);
<> 144:ef7eb2e8f9f7 538 return p_spi_info->event & SPI_EVENT_COMPLETE;
<> 144:ef7eb2e8f9f7 539 }
<> 144:ef7eb2e8f9f7 540
<> 144:ef7eb2e8f9f7 541 uint8_t spi_active(spi_t *obj)
<> 144:ef7eb2e8f9f7 542 {
<> 144:ef7eb2e8f9f7 543 spi_info_t *p_spi_info = SPI_INFO(obj);
<> 144:ef7eb2e8f9f7 544 MBED_ASSERT(p_spi_info->master);
<> 144:ef7eb2e8f9f7 545 return p_spi_info->flag.busy;
<> 144:ef7eb2e8f9f7 546 }
<> 144:ef7eb2e8f9f7 547
<> 144:ef7eb2e8f9f7 548 void spi_abort_asynch(spi_t *obj)
<> 144:ef7eb2e8f9f7 549 {
<> 144:ef7eb2e8f9f7 550 MBED_ASSERT(SPI_INFO(obj)->master);
<> 144:ef7eb2e8f9f7 551 nrf_drv_spi_abort(MASTER_INST(obj));
<> 144:ef7eb2e8f9f7 552 }
<> 144:ef7eb2e8f9f7 553
<> 144:ef7eb2e8f9f7 554 #endif // DEVICE_SPI_ASYNCH
<> 144:ef7eb2e8f9f7 555
<> 144:ef7eb2e8f9f7 556 #endif // DEVICE_SPI