diff options
Diffstat (limited to 'os')
| -rw-r--r-- | os/hal/include/hal.h | 5 | ||||
| -rw-r--r-- | os/hal/include/hal_wspi.h | 361 | ||||
| -rw-r--r-- | os/hal/src/hal.c | 3 | ||||
| -rw-r--r-- | os/hal/src/hal_wspi.c | 392 |
4 files changed, 761 insertions, 0 deletions
diff --git a/os/hal/include/hal.h b/os/hal/include/hal.h index 6eb7ccfb8..b464fdcda 100644 --- a/os/hal/include/hal.h +++ b/os/hal/include/hal.h @@ -110,6 +110,10 @@ #define HAL_USE_WDG FALSE
#endif
+#if !defined(HAL_USE_WSPI)
+#define HAL_USE_WSPI FALSE
+#endif
+
/* Low Level HAL support.*/
#include "hal_lld.h"
@@ -146,6 +150,7 @@ #include "hal_uart.h"
#include "hal_usb.h"
#include "hal_wdg.h"
+#include "hal_wspi.h"
/*
* The ST driver is a special case, it is only included if the OSAL is
diff --git a/os/hal/include/hal_wspi.h b/os/hal/include/hal_wspi.h new file mode 100644 index 000000000..3d7a9a1aa --- /dev/null +++ b/os/hal/include/hal_wspi.h @@ -0,0 +1,361 @@ +/*
+ ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file hal_wspi.h
+ * @brief WSPI Driver macros and structures.
+ *
+ * @addtogroup WSPI
+ * @{
+ */
+
+#ifndef HAL_WSPI_H
+#define HAL_WSPI_H
+
+#if (HAL_USE_WSPI == TRUE) || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver constants. */
+/*===========================================================================*/
+
+/**
+ * @name Transfer options
+ * @note The Low Level Driver should undef those modes that are not
+ * supported. The LLD can also define additional modes or reorder
+ * the bit masks in a more convenient way for the underlying
+ * implementation. It is important however to maintain the same
+ * same for the same functionality.
+ * @{
+ */
+#define WSPI_CFG_INSTRUCTION_MODE_MASK (7LU << 0LU)
+#define WSPI_CFG_INSTRUCTION_MODE_NONE (0LU << 0LU)
+#define WSPI_CFG_INSTRUCTION_MODE_ONE_LINES (1LU << 0LU)
+#define WSPI_CFG_INSTRUCTION_MODE_TWO_LINES (2LU << 0LU)
+#define WSPI_CFG_INSTRUCTION_MODE_FOUR_LINES (3LU << 0LU)
+#define WSPI_CFG_INSTRUCTION_MODE_EIGHT_LINES (4LU << 0LU)
+
+#define WSPI_CFG_INSTRUCTION_DDR (1LU << 3LU)
+
+#define WSPI_CFG_INSTRUCTION_SIZE_MASK (3LU << 4LU)
+#define WSPI_CFG_INSTRUCTION_SIZE_8 (0LU << 4LU)
+#define WSPI_CFG_INSTRUCTION_SIZE_16 (1LU << 4LU)
+#define WSPI_CFG_INSTRUCTION_SIZE_24 (2LU << 4LU)
+#define WSPI_CFG_INSTRUCTION_SIZE_32 (3LU << 4LU)
+
+#define WSPI_CFG_ADDR_MODE_MASK (7LU << 8LU)
+#define WSPI_CFG_ADDR_MODE_NONE (0LU << 8LU)
+#define WSPI_CFG_ADDR_MODE_ONE_LINE (1LU << 8LU)
+#define WSPI_CFG_ADDR_MODE_TWO_LINES (2LU << 8LU)
+#define WSPI_CFG_ADDR_MODE_FOUR_LINES (3LU << 8LU)
+#define WSPI_CFG_ADDR_MODE_EIGHT_LINES (4LU << 8LU)
+
+#define WSPI_CFG_ADDR_DDR (1LU << 11LU)
+
+#define WSPI_CFG_ADDR_SIZE_MASK (3LU << 12LU)
+#define WSPI_CFG_ADDR_SIZE_8 (0LU << 12LU)
+#define WSPI_CFG_ADDR_SIZE_16 (1LU << 12LU)
+#define WSPI_CFG_ADDR_SIZE_24 (2LU << 12LU)
+#define WSPI_CFG_ADDR_SIZE_32 (3LU << 12LU)
+
+#define WSPI_CFG_ALT_MODE_MASK (7LU << 16LU)
+#define WSPI_CFG_ALT_MODE_NONE (0LU << 16LU)
+#define WSPI_CFG_ALT_MODE_ONE_LINE (1LU << 16LU)
+#define WSPI_CFG_ALT_MODE_TWO_LINES (2LU << 16LU)
+#define WSPI_CFG_ALT_MODE_FOUR_LINES (3LU << 16LU)
+#define WSPI_CFG_ALT_MODE_EIGHT_LINES (4LU << 16LU)
+
+#define WSPI_CFG_ALT_DDR (1LU << 19LU)
+
+#define WSPI_CFG_ALT_SIZE_MASK (3LU << 20LU)
+#define WSPI_CFG_ALT_SIZE_8 (0LU << 20LU)
+#define WSPI_CFG_ALT_SIZE_16 (1LU << 20LU)
+#define WSPI_CFG_ALT_SIZE_24 (2LU << 20LU)
+#define WSPI_CFG_ALT_SIZE_32 (3LU << 20LU)
+
+#define WSPI_CFG_DATA_MODE_MASK (7LU << 24LU)
+#define WSPI_CFG_DATA_MODE_NONE (0LU << 24LU)
+#define WSPI_CFG_DATA_MODE_ONE_LINE (1LU << 24LU)
+#define WSPI_CFG_DATA_MODE_TWO_LINES (2LU << 24LU)
+#define WSPI_CFG_DATA_MODE_FOUR_LINES (3LU << 24LU)
+#define WSPI_CFG_DATA_MODE_EIGHT_LINES (4LU << 24LU)
+
+#define WSPI_CFG_DATA_DDR (1LU << 27LU)
+
+#define WSPI_CFG_SIOO (1LU << 31LU)
+/** @} */
+
+/*===========================================================================*/
+/* Driver pre-compile time settings. */
+/*===========================================================================*/
+
+/**
+ * @name WSPI configuration options
+ * @{
+ */
+/**
+ * @brief Enables synchronous APIs.
+ * @note Disabling this option saves both code and data space.
+ */
+#if !defined(WSPI_USE_WAIT) || defined(__DOXYGEN__)
+#define WSPI_USE_WAIT TRUE
+#endif
+
+/**
+ * @brief Enables the @p wspiAcquireBus() and @p wspiReleaseBus() APIs.
+ * @note Disabling this option saves both code and data space.
+ */
+#if !defined(WSPI_USE_MUTUAL_EXCLUSION) || defined(__DOXYGEN__)
+#define WSPI_USE_MUTUAL_EXCLUSION TRUE
+#endif
+/** @} */
+
+/*===========================================================================*/
+/* Derived constants and error checks. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver data structures and types. */
+/*===========================================================================*/
+
+/**
+ * @brief Driver state machine possible states.
+ */
+typedef enum {
+ WSPI_UNINIT = 0, /**< Not initialized. */
+ WSPI_STOP = 1, /**< Stopped. */
+ WSPI_READY = 2, /**< Ready. */
+ WSPI_ACTIVE = 3, /**< Exchanging data. */
+ WSPI_COMPLETE = 4, /**< Asynchronous operation complete. */
+ WSPI_MEMMAP = 5 /**< In memory mapped mode. */
+} wspistate_t;
+
+/**
+ * @brief Type of a WSPI command descriptor.
+ */
+typedef struct {
+ /**
+ * @brief Transfer configuration field.
+ */
+ uint32_t cfg;
+ /**
+ * @brief Command phase data.
+ */
+ uint32_t cmd;
+ /**
+ * @brief Address phase data.
+ */
+ uint32_t addr;
+ /**
+ * @brief Alternate phase data.
+ */
+ uint32_t alt;
+ /**
+ * @brief Number of dummy cycles to be inserted.
+ */
+ uint32_t dummy;
+} wspi_command_t;
+
+#include "hal_wspi_lld.h"
+
+#if !defined(WSPI_SUPPORTS_MEMMAP)
+#error "low level does not define WSPI_SUPPORTS_MEMMAP"
+#endif
+
+/*===========================================================================*/
+/* Driver macros. */
+/*===========================================================================*/
+
+/**
+ * @name Macro Functions
+ * @{
+ */
+/**
+ * @brief Sends a command without data phase.
+ * @post At the end of the operation the configured callback is invoked.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ *
+ * @iclass
+ */
+#define wspiStartCommandI(wspip, cmdp) { \
+ osalDbgAssert(((cmdp)->cfg & WSPI_CFG_DATA_MODE_MASK) == \
+ WSPI_CFG_DATA_MODE_NONE, \
+ "data mode specified"); \
+ (wspip)->state = WSPI_ACTIVE; \
+ wspi_lld_command(wspip, cmdp); \
+}
+
+/**
+ * @brief Sends data over the WSPI bus.
+ * @details This asynchronous function starts a transmit operation.
+ * @post At the end of the operation the configured callback is invoked.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ * @param[in] n number of bytes to send or zero if no data phase
+ * @param[in] txbuf the pointer to the transmit buffer
+ *
+ * @iclass
+ */
+#define wspiStartSendI(wspip, cmdp, n, txbuf) { \
+ osalDbgAssert(((cmdp)->cfg & WSPI_CFG_DATA_MODE_MASK) != \
+ WSPI_CFG_DATA_MODE_NONE, \
+ "data mode required"); \
+ (wspip)->state = WSPI_ACTIVE; \
+ wspi_lld_send(wspip, cmdp, n, txbuf); \
+}
+
+/**
+ * @brief Receives data from the WSPI bus.
+ * @details This asynchronous function starts a receive operation.
+ * @post At the end of the operation the configured callback is invoked.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ * @param[in] n number of bytes to receive or zero if no data phase
+ * @param[out] rxbuf the pointer to the receive buffer
+ *
+ * @iclass
+ */
+#define wspiStartReceiveI(wspip, cmdp, n, rxbuf) { \
+ osalDbgAssert(((cmdp)->cfg & WSPI_CFG_DATA_MODE_MASK) != \
+ WSPI_CFG_DATA_MODE_NONE, \
+ "data mode required"); \
+ (wspip)->state = WSPI_ACTIVE; \
+ wspi_lld_receive(wspip, cmdp, n, rxbuf); \
+}
+
+#if (WSPI_SUPPORTS_MEMMAP == TRUE) || defined(__DOXYGEN__)
+/**
+ * @brief Maps in memory space a WSPI flash device.
+ * @pre The memory flash device must be initialized appropriately
+ * before mapping it in memory space.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ * @param[out] addrp pointer to the memory start address of the mapped
+ * flash or @p NULL
+ *
+ * @iclass
+ */
+#define wspiMapFlashI(wspip, cmdp, addrp) \
+ wspi_lld_map_flash(wspip, cmdp, addrp)
+
+/**
+ * @brief Maps in memory space a WSPI flash device.
+ * @post The memory flash device must be re-initialized for normal
+ * commands exchange.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ *
+ * @iclass
+ */
+#define wspiUnmapFlashI(wspip) \
+ wspi_lld_unmap_flash(wspip)
+#endif /* WSPI_SUPPORTS_MEMMAP == TRUE */
+/** @} */
+
+/**
+ * @name Low level driver helper macros
+ * @{
+ */
+#if (WSPI_USE_WAIT == TRUE) || defined(__DOXYGEN__)
+/**
+ * @brief Wakes up the waiting thread.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ *
+ * @notapi
+ */
+#define _wspi_wakeup_isr(wspip) { \
+ osalSysLockFromISR(); \
+ osalThreadResumeI(&(wspip)->thread, MSG_OK); \
+ osalSysUnlockFromISR(); \
+}
+#else /* !WSPI_USE_WAIT */
+#define _wspi_wakeup_isr(wspip)
+#endif /* !WSPI_USE_WAIT */
+
+/**
+ * @brief Common ISR code.
+ * @details This code handles the portable part of the ISR code:
+ * - Callback invocation.
+ * - Waiting thread wakeup, if any.
+ * - Driver state transitions.
+ * .
+ * @note This macro is meant to be used in the low level drivers
+ * implementation only.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ *
+ * @notapi
+ */
+#define _wspi_isr_code(wspip) { \
+ if ((wspip)->config->end_cb) { \
+ (wspip)->state = WSPI_COMPLETE; \
+ (wspip)->config->end_cb(wspip); \
+ if ((wspip)->state == WSPI_COMPLETE) \
+ (wspip)->state = WSPI_READY; \
+ } \
+ else \
+ (wspip)->state = WSPI_READY; \
+ _wspi_wakeup_isr(wspip); \
+}
+/** @} */
+
+/*===========================================================================*/
+/* External declarations. */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+ void wspiInit(void);
+ void wspiObjectInit(WSPIDriver *wspip);
+ void wspiStart(WSPIDriver *wspip, const WSPIConfig *config);
+ void wspiStop(WSPIDriver *wspip);
+ void wspiStartCommand(WSPIDriver *wspip, const wspi_command_t *cmdp);
+ void wspiStartSend(WSPIDriver *wspip, const wspi_command_t *cmdp,
+ size_t n, const uint8_t *txbuf);
+ void wspiStartReceive(WSPIDriver *wspip, const wspi_command_t *cmdp,
+ size_t n, uint8_t *rxbuf);
+#if WSPI_USE_WAIT == TRUE
+ void wspiCommand(WSPIDriver *wspip, const wspi_command_t *cmdp);
+ void wspiSend(WSPIDriver *wspip, const wspi_command_t *cmdp,
+ size_t n, const uint8_t *txbuf);
+ void wspiReceive(WSPIDriver *wspip, const wspi_command_t *cmdp,
+ size_t n, uint8_t *rxbuf);
+#endif
+#if WSPI_SUPPORTS_MEMMAP == TRUE
+void wspiMapFlash(WSPIDriver *wspip,
+ const wspi_command_t *cmdp,
+ uint8_t **addrp);
+void wspiUnmapFlash(WSPIDriver *wspip);
+#endif
+#if WSPI_USE_MUTUAL_EXCLUSION == TRUE
+ void wspiAcquireBus(WSPIDriver *wspip);
+ void wspiReleaseBus(WSPIDriver *wspip);
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HAL_USE_WSPI == TRUE */
+
+#endif /* HAL_WSPI_H */
+
+/** @} */
diff --git a/os/hal/src/hal.c b/os/hal/src/hal.c index 1bfa7550f..42b926619 100644 --- a/os/hal/src/hal.c +++ b/os/hal/src/hal.c @@ -131,6 +131,9 @@ void halInit(void) { #if (HAL_USE_WDG == TRUE) || defined(__DOXYGEN__)
wdgInit();
#endif
+#if (HAL_USE_WSPI == TRUE) || defined(__DOXYGEN__)
+ wspiInit();
+#endif
/* Community driver overlay initialization.*/
#if defined(HAL_USE_COMMUNITY) || defined(__DOXYGEN__)
diff --git a/os/hal/src/hal_wspi.c b/os/hal/src/hal_wspi.c new file mode 100644 index 000000000..10a0aec24 --- /dev/null +++ b/os/hal/src/hal_wspi.c @@ -0,0 +1,392 @@ +/*
+ ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file hal_wspi.c
+ * @brief WSPI Driver code.
+ *
+ * @addtogroup WSPI
+ * @{
+ */
+
+#include "hal.h"
+
+#if (HAL_USE_WSPI == TRUE) || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver local definitions. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver exported variables. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver local variables and types. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver local functions. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver exported functions. */
+/*===========================================================================*/
+
+/**
+ * @brief WSPI Driver initialization.
+ * @note This function is implicitly invoked by @p halInit(), there is
+ * no need to explicitly initialize the driver.
+ *
+ * @init
+ */
+void wspiInit(void) {
+
+ wspi_lld_init();
+}
+
+/**
+ * @brief Initializes the standard part of a @p WSPIDriver structure.
+ *
+ * @param[out] wspip pointer to the @p WSPIDriver object
+ *
+ * @init
+ */
+void wspiObjectInit(WSPIDriver *wspip) {
+
+ wspip->state = WSPI_STOP;
+ wspip->config = NULL;
+#if WSPI_USE_WAIT == TRUE
+ wspip->thread = NULL;
+#endif
+#if WSPI_USE_MUTUAL_EXCLUSION == TRUE
+ osalMutexObjectInit(&wspip->mutex);
+#endif
+#if defined(WSPI_DRIVER_EXT_INIT_HOOK)
+ WSPI_DRIVER_EXT_INIT_HOOK(wspip);
+#endif
+}
+
+/**
+ * @brief Configures and activates the WSPI peripheral.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] config pointer to the @p WSPIConfig object
+ *
+ * @api
+ */
+void wspiStart(WSPIDriver *wspip, const WSPIConfig *config) {
+
+ osalDbgCheck((wspip != NULL) && (config != NULL));
+
+ osalSysLock();
+
+ osalDbgAssert((wspip->state == WSPI_STOP) || (wspip->state == WSPI_READY),
+ "invalid state");
+
+ wspip->config = config;
+ wspi_lld_start(wspip);
+ wspip->state = WSPI_READY;
+
+ osalSysUnlock();
+}
+
+/**
+ * @brief Deactivates the WSPI peripheral.
+ * @note Deactivating the peripheral also enforces a release of the slave
+ * select line.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ *
+ * @api
+ */
+void wspiStop(WSPIDriver *wspip) {
+
+ osalDbgCheck(wspip != NULL);
+
+ osalSysLock();
+
+ osalDbgAssert((wspip->state == WSPI_STOP) || (wspip->state == WSPI_READY),
+ "invalid state");
+
+ wspi_lld_stop(wspip);
+ wspip->config = NULL;
+ wspip->state = WSPI_STOP;
+
+ osalSysUnlock();
+}
+
+/**
+ * @brief Sends a command without data phase.
+ * @post At the end of the operation the configured callback is invoked.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ *
+ * @api
+ */
+void wspiStartCommand(WSPIDriver *wspip, const wspi_command_t *cmdp) {
+
+ osalDbgCheck((wspip != NULL) && (cmdp != NULL));
+
+ osalSysLock();
+
+ osalDbgAssert(wspip->state == WSPI_READY, "not ready");
+
+ wspiStartCommandI(wspip, cmdp);
+
+ osalSysUnlock();
+}
+
+/**
+ * @brief Sends a command with data over the WSPI bus.
+ * @post At the end of the operation the configured callback is invoked.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ * @param[in] n number of bytes to send
+ * @param[in] txbuf the pointer to the transmit buffer
+ *
+ * @api
+ */
+void wspiStartSend(WSPIDriver *wspip, const wspi_command_t *cmdp,
+ size_t n, const uint8_t *txbuf) {
+
+ osalDbgCheck((wspip != NULL) && (cmdp != NULL));
+ osalDbgCheck((n > 0U) && (txbuf != NULL));
+
+ osalSysLock();
+
+ osalDbgAssert(wspip->state == WSPI_READY, "not ready");
+
+ wspiStartSendI(wspip, cmdp, n, txbuf);
+
+ osalSysUnlock();
+}
+
+/**
+ * @brief Sends a command then receives data over the WSPI bus.
+ * @post At the end of the operation the configured callback is invoked.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ * @param[in] n number of bytes to send
+ * @param[out] rxbuf the pointer to the receive buffer
+ *
+ * @api
+ */
+void wspiStartReceive(WSPIDriver *wspip, const wspi_command_t *cmdp,
+ size_t n, uint8_t *rxbuf) {
+
+ osalDbgCheck((wspip != NULL) && (cmdp != NULL));
+ osalDbgCheck((n > 0U) && (rxbuf != NULL));
+
+ osalSysLock();
+
+ osalDbgAssert(wspip->state == WSPI_READY, "not ready");
+
+ wspiStartReceiveI(wspip, cmdp, n, rxbuf);
+
+ osalSysUnlock();
+}
+
+#if (WSPI_USE_WAIT == TRUE) || defined(__DOXYGEN__)
+/**
+ * @brief Sends a command without data phase.
+ * @pre In order to use this function the option @p WSPI_USE_WAIT must be
+ * enabled.
+ * @pre In order to use this function the driver must have been configured
+ * without callbacks (@p end_cb = @p NULL).
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ *
+ * @api
+ */
+void wspiCommand(WSPIDriver *wspip, const wspi_command_t *cmdp) {
+
+ osalDbgCheck((wspip != NULL) && (cmdp != NULL));
+ osalDbgCheck((cmdp->cfg & WSPI_CFG_DATA_MODE_MASK) == WSPI_CFG_DATA_MODE_NONE);
+
+ osalSysLock();
+
+ osalDbgAssert(wspip->state == WSPI_READY, "not ready");
+ osalDbgAssert(wspip->config->end_cb == NULL, "has callback");
+
+ wspiStartCommandI(wspip, cmdp);
+ (void) osalThreadSuspendS(&wspip->thread);
+
+ osalSysUnlock();
+}
+
+/**
+ * @brief Sends a command with data over the WSPI bus.
+ * @pre In order to use this function the option @p WSPI_USE_WAIT must be
+ * enabled.
+ * @pre In order to use this function the driver must have been configured
+ * without callbacks (@p end_cb = @p NULL).
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ * @param[in] n number of bytes to send
+ * @param[in] txbuf the pointer to the transmit buffer
+ *
+ * @api
+ */
+void wspiSend(WSPIDriver *wspip, const wspi_command_t *cmdp,
+ size_t n, const uint8_t *txbuf) {
+
+ osalDbgCheck((wspip != NULL) && (cmdp != NULL));
+ osalDbgCheck((n > 0U) && (txbuf != NULL));
+ osalDbgCheck((cmdp->cfg & WSPI_CFG_DATA_MODE_MASK) != WSPI_CFG_DATA_MODE_NONE);
+
+ osalSysLock();
+
+ osalDbgAssert(wspip->state == WSPI_READY, "not ready");
+ osalDbgAssert(wspip->config->end_cb == NULL, "has callback");
+
+ wspiStartSendI(wspip, cmdp, n, txbuf);
+ (void) osalThreadSuspendS(&wspip->thread);
+
+ osalSysUnlock();
+}
+
+/**
+ * @brief Sends a command then receives data over the WSPI bus.
+ * @pre In order to use this function the option @p WSPI_USE_WAIT must be
+ * enabled.
+ * @pre In order to use this function the driver must have been configured
+ * without callbacks (@p end_cb = @p NULL).
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ * @param[in] n number of bytes to send
+ * @param[out] rxbuf the pointer to the receive buffer
+ *
+ * @api
+ */
+void wspiReceive(WSPIDriver *wspip, const wspi_command_t *cmdp,
+ size_t n, uint8_t *rxbuf) {
+
+ osalDbgCheck((wspip != NULL) && (cmdp != NULL));
+ osalDbgCheck((n > 0U) && (rxbuf != NULL));
+ osalDbgCheck((cmdp->cfg & WSPI_CFG_DATA_MODE_MASK) != WSPI_CFG_DATA_MODE_NONE);
+
+ osalSysLock();
+
+ osalDbgAssert(wspip->state == WSPI_READY, "not ready");
+ osalDbgAssert(wspip->config->end_cb == NULL, "has callback");
+
+ wspiStartReceiveI(wspip, cmdp, n, rxbuf);
+ (void) osalThreadSuspendS(&wspip->thread);
+
+ osalSysUnlock();
+}
+#endif /* WSPI_USE_WAIT == TRUE */
+
+#if (WSPI_SUPPORTS_MEMMAP == TRUE) || defined(__DOXYGEN__)
+/**
+ * @brief Maps in memory space a WSPI flash device.
+ * @pre The memory flash device must be initialized appropriately
+ * before mapping it in memory space.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ * @param[in] cmdp pointer to the command descriptor
+ * @param[out] addrp pointer to the memory start address of the mapped
+ * flash or @p NULL
+ *
+ * @api
+ */
+void wspiMapFlash(WSPIDriver *wspip,
+ const wspi_command_t *cmdp,
+ uint8_t **addrp) {
+
+ osalDbgCheck((wspip != NULL) && (cmdp != NULL));
+ osalDbgCheck((cmdp->cfg & WSPI_CFG_DATA_MODE_MASK) != WSPI_CFG_DATA_MODE_NONE);
+
+ osalSysLock();
+
+ osalDbgAssert(wspip->state == WSPI_READY, "not ready");
+
+ wspiMapFlashI(wspip, cmdp, addrp);
+ wspip->state = WSPI_MEMMAP;
+
+ osalSysUnlock();
+}
+
+/**
+ * @brief Unmaps from memory space a WSPI flash device.
+ * @post The memory flash device must be re-initialized for normal
+ * commands exchange.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ *
+ * @api
+ */
+void wspiUnmapFlash(WSPIDriver *wspip) {
+
+ osalDbgCheck(wspip != NULL);
+
+ osalSysLock();
+
+ osalDbgAssert(wspip->state == WSPI_MEMMAP, "not ready");
+
+ wspiUnmapFlashI(wspip);
+ wspip->state = WSPI_READY;
+
+ osalSysUnlock();
+}
+#endif /* WSPI_SUPPORTS_MEMMAP == TRUE */
+
+#if (WSPI_USE_MUTUAL_EXCLUSION == TRUE) || defined(__DOXYGEN__)
+/**
+ * @brief Gains exclusive access to the WSPI bus.
+ * @details This function tries to gain ownership to the WSPI bus, if the bus
+ * is already being used then the invoking thread is queued.
+ * @pre In order to use this function the option @p WSPI_USE_MUTUAL_EXCLUSION
+ * must be enabled.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ *
+ * @api
+ */
+void wspiAcquireBus(WSPIDriver *wspip) {
+
+ osalDbgCheck(wspip != NULL);
+
+ osalMutexLock(&wspip->mutex);
+}
+
+/**
+ * @brief Releases exclusive access to the WSPI bus.
+ * @pre In order to use this function the option @p WSPI_USE_MUTUAL_EXCLUSION
+ * must be enabled.
+ *
+ * @param[in] wspip pointer to the @p WSPIDriver object
+ *
+ * @api
+ */
+void wspiReleaseBus(WSPIDriver *wspip) {
+
+ osalDbgCheck(wspip != NULL);
+
+ osalMutexUnlock(&wspip->mutex);
+}
+#endif /* WSPI_USE_MUTUAL_EXCLUSION == TRUE */
+
+#endif /* HAL_USE_WSPI == TRUE */
+
+/** @} */
|