/* | |
* cc_pal.h - CC32xx Host Driver Implementation | |
* | |
* Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/ | |
* | |
* | |
* Redistribution and use in source and binary forms, with or without | |
* modification, are permitted provided that the following conditions | |
* are met: | |
* | |
* Redistributions of source code must retain the above copyright | |
* notice, this list of conditions and the following disclaimer. | |
* | |
* Redistributions in binary form must reproduce the above copyright | |
* notice, this list of conditions and the following disclaimer in the | |
* documentation and/or other materials provided with the | |
* distribution. | |
* | |
* Neither the name of Texas Instruments Incorporated nor the names of | |
* its contributors may be used to endorse or promote products derived | |
* from this software without specific prior written permission. | |
* | |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
* | |
*/ | |
/****************************************************************************** | |
* cc_pal.h | |
* | |
* SimpleLink Wi-Fi abstraction file for CC32xx | |
******************************************************************************/ | |
#ifndef __CC31xx_PAL_H__ | |
#define __CC31xx_PAL_H__ | |
#ifdef __cplusplus | |
extern "C" { | |
#endif | |
#include <ti/drivers/dpl/ClockP.h> | |
#if defined(SL_PLATFORM_MULTI_THREADED) | |
/* Use Zephyr posix headers */ | |
#include <posix/pthread.h> | |
#include <posix/semaphore.h> | |
#include <posix/unistd.h> | |
#else //SL_PLATFORM_MULTI_THREADED | |
#include <ti/drivers/dpl/SemaphoreP.h> | |
#include <ti/drivers/dpl/MutexP.h> | |
#endif | |
#define MAX_QUEUE_SIZE (4) | |
#define OS_WAIT_FOREVER (0xFFFFFFFF) | |
#define OS_NO_WAIT (0) | |
#define OS_OK (0) | |
#define Semaphore_OK (0) | |
#define Semaphore_FAILURE (-1) | |
#define Mutex_OK (0) | |
#define Mutex_FAILURE (-1) | |
/*! | |
\brief type definition for the SPI channel file descriptor | |
\note On each porting or platform the type could be whatever is needed - integer, pointer to structure etc. | |
*/ | |
typedef int Fd_t; | |
/*! | |
\brief type definition for the host interrupt handler | |
\param pValue - pointer to any memory strcuture. The value of this pointer is given on | |
registration of a new interrupt handler | |
\note | |
*/ | |
typedef void (*SL_P_EVENT_HANDLER)(void); | |
#define P_EVENT_HANDLER SL_P_EVENT_HANDLER | |
/*! | |
\brief type definition for the host spawn function | |
\param pValue - pointer to any memory strcuture. The value of this pointer is given on | |
invoking the spawn function. | |
\note | |
*/ | |
typedef signed short (*P_OS_SPAWN_ENTRY)(void* pValue); | |
typedef struct | |
{ | |
P_OS_SPAWN_ENTRY pEntry; | |
void* pValue; | |
}tSimpleLinkSpawnMsg; | |
/*! | |
\brief open spi communication port to be used for communicating with a SimpleLink device | |
Given an interface name and option flags, this function opens the spi communication port | |
and creates a file descriptor. This file descriptor can be used afterwards to read and | |
write data from and to this specific spi channel. | |
The SPI speed, clock polarity, clock phase, chip select and all other attributes are all | |
set to hardcoded values in this function. | |
\param ifName - points to the interface name/path. The interface name is an | |
optional attributes that the SimpleLink driver receives | |
on opening the device. in systems that the spi channel is | |
not implemented as part of the os device drivers, this | |
parameter could be NULL. | |
\param flags - option flags | |
\return upon successful completion, the function shall open the spi channel and return | |
a non-negative integer representing the file descriptor. | |
Otherwise, -1 shall be returned | |
\sa spi_Close , spi_Read , spi_Write | |
\note | |
\warning | |
*/ | |
Fd_t spi_Open(char *ifName, unsigned long flags); | |
/*! | |
\brief closes an opened SPI communication port | |
\param fd - file descriptor of an opened SPI channel | |
\return upon successful completion, the function shall return 0. | |
Otherwise, -1 shall be returned | |
\sa spi_Open | |
\note | |
\warning | |
*/ | |
int spi_Close(Fd_t fd); | |
/*! | |
\brief attempts to read up to len bytes from SPI channel into a buffer starting at pBuff. | |
\param fd - file descriptor of an opened SPI channel | |
\param pBuff - points to first location to start writing the data | |
\param len - number of bytes to read from the SPI channel | |
\return upon successful completion, the function shall return 0. | |
Otherwise, -1 shall be returned | |
\sa spi_Open , spi_Write | |
\note | |
\warning | |
*/ | |
int spi_Read(Fd_t fd, unsigned char *pBuff, int len); | |
/*! | |
\brief attempts to write up to len bytes to the SPI channel | |
\param fd - file descriptor of an opened SPI channel | |
\param pBuff - points to first location to start getting the data from | |
\param len - number of bytes to write to the SPI channel | |
\return upon successful completion, the function shall return 0. | |
Otherwise, -1 shall be returned | |
\sa spi_Open , spi_Read | |
\note This function could be implemented as zero copy and return only upon successful completion | |
of writing the whole buffer, but in cases that memory allocation is not too tight, the | |
function could copy the data to internal buffer, return back and complete the write in | |
parallel to other activities as long as the other SPI activities would be blocked untill | |
the entire buffer write would be completed | |
\warning | |
*/ | |
int spi_Write(Fd_t fd, unsigned char *pBuff, int len); | |
/*! | |
\brief register an interrupt handler for the host IRQ | |
\param InterruptHdl - pointer to interrupt handler function | |
\param pValue - pointer to a memory strcuture that is passed to the interrupt handler. | |
\return upon successful registration, the function shall return 0. | |
Otherwise, -1 shall be returned | |
\sa | |
\note If there is already registered interrupt handler, the function should overwrite the old handler | |
with the new one | |
\warning | |
*/ | |
int NwpRegisterInterruptHandler(P_EVENT_HANDLER InterruptHdl , void* pValue); | |
/*! | |
\brief Masks host IRQ | |
\sa NwpUnMaskInterrupt | |
\warning | |
*/ | |
void NwpMaskInterrupt(); | |
/*! | |
\brief Unmasks host IRQ | |
\sa NwpMaskInterrupt | |
\warning | |
*/ | |
void NwpUnMaskInterrupt(); | |
/*! | |
\brief Preamble to the enabling the Network Processor. | |
Placeholder to implement any pre-process operations | |
before enabling networking operations. | |
\sa sl_DeviceEnable | |
\note belongs to \ref ported_sec | |
*/ | |
void NwpPowerOnPreamble(void); | |
/*! | |
\brief Disable the Network Processor | |
\sa sl_DeviceEnable | |
\note belongs to \ref ported_sec | |
*/ | |
void NwpPowerOff(void); | |
/*! | |
\brief Enable the Network Processor | |
\sa sl_DeviceDisable | |
\note belongs to \ref ported_sec | |
*/ | |
void NwpPowerOn(void); | |
#if defined(SL_PLATFORM_MULTI_THREADED) | |
/*! | |
\brief Time wait for a semaphore handle, using the driver porting layer of the core SDK. | |
\param pSemHandle - pointer to a memory structure that would contain the handle. | |
\param timeout - specify the time to wait for the signal | |
\return The function shall return 0. | |
\note belongs to \ref ported_sec | |
*/ | |
int Semaphore_pend_handle(sem_t* pSemHandle, uint32_t timeout); | |
/*! | |
\brief Creates a mutex object handle, using the driver porting layer of the core SDK. | |
\param pMutexHandle - pointer to a memory structure that would contain the handle. | |
\return upon successful creation, the function shall return 0. | |
Otherwise, -1 shall be returned | |
\note belongs to \ref ported_sec | |
*/ | |
int Mutex_create_handle(pthread_mutex_t* pMutexHandle); | |
/*! | |
\brief Deletes a mutex object handle, using the driver porting layer of the core SDK. | |
\param pMutexHandle - pointer to a memory structure that would contain the handle. | |
\return the function shall return 0. | |
\note belongs to \ref ported_sec | |
*/ | |
int MutexP_delete_handle(pthread_mutex_t* pMutexHandle); | |
#else | |
/*! | |
\brief Creates a semaphore handle, using the driver porting layer of the core SDK. | |
\param pSemHandle - pointer to a memory structure that would contain the handle. | |
\return upon successful creation, the function shall return 0. | |
Otherwise, -1 shall be returned | |
\note belongs to \ref ported_sec | |
*/ | |
int SemaphoreP_create_handle(SemaphoreP_Handle* pSemHandle); | |
/*! | |
\brief Deletes a semaphore handle, using the driver porting layer of the core SDK. | |
\param pSemHandle - pointer to a memory structure that would contain the handle. | |
\return The function shall return 0. | |
\note belongs to \ref ported_sec | |
*/ | |
int SemaphoreP_delete_handle(SemaphoreP_Handle* pSemHandle); | |
/*! | |
\brief Post (signal) a semaphore handle, using the driver porting layer of the core SDK. | |
\param pSemHandle - pointer to a memory structure that would contain the handle. | |
\return The function shall return 0. | |
\note belongs to \ref ported_sec | |
*/ | |
int SemaphoreP_post_handle(SemaphoreP_Handle* pSemHandle); | |
/*! | |
\brief Creates a mutex object handle, using the driver porting layer of the core SDK. | |
\param pMutexHandle - pointer to a memory structure that would contain the handle. | |
\return upon successful creation, the function shall return 0. | |
Otherwise, -1 shall be returned | |
\note belongs to \ref ported_sec | |
*/ | |
int Mutex_create_handle(MutexP_Handle* pMutexHandle); | |
/*! | |
\brief Deletes a mutex object handle, using the driver porting layer of the core SDK. | |
\param pMutexHandle - pointer to a memory structure that would contain the handle. | |
\return the function shall return 0. | |
\note belongs to \ref ported_sec | |
*/ | |
int MutexP_delete_handle(MutexP_Handle* pMutexHandle); | |
/*! | |
\brief Unlocks a mutex object. | |
\param pMutexHandle - pointer to a memory structure that contains the object. | |
\return upon successful unlocking, the function shall return 0. | |
\note belongs to \ref ported_sec | |
*/ | |
int Mutex_unlock(MutexP_Handle pMutexHandle); | |
/*! | |
\brief Locks a mutex object. | |
\param pMutexHandle - pointer to a memory structure that contains the object. | |
\return upon successful locking, the function shall return 0. | |
\note belongs to \ref ported_sec | |
\warning The lock will block until the mutex is available. | |
*/ | |
int Mutex_lock(MutexP_Handle pMutexHandle); | |
#endif | |
/*! | |
\brief Take a time stamp value. | |
\return 32-bit value of the systick counter. | |
\sa | |
\warning | |
*/ | |
unsigned long TimerGetCurrentTimestamp(); | |
/*! | |
\brief | |
\return | |
\sa | |
\warning | |
*/ | |
void NwpWaitForShutDownInd(); | |
#ifdef __cplusplus | |
} | |
#endif // __cplusplus | |
#endif | |