//***************************************************************************** // //! simple_link_recv //! //! @param sd socket handle //! @param buf read buffer //! @param len buffer length //! @param flags indicates blocking or non-blocking operation //! @param from pointer to an address structure indicating source address //! @param fromlen source address structure size //! //! @return Return the number of bytes received, or -1 if an error //! occurred //! //! @brief Read data from socket //! Return the length of the message on successful completion. //! If a message is too long to fit in the supplied buffer, //! excess bytes may be discarded depending on the type of //! socket the message is received from // //***************************************************************************** int simple_link_recv(long sd, void *buf, long len, long flags, sockaddr *from, socklen_t *fromlen, long opcode) { unsigned char *ptr, *args; tBsdReadReturnParams tSocketReadEvent; ptr = tSLInformation.pucTxCommandBuffer; args = (ptr + HEADERS_SIZE_CMD); // Fill in HCI packet structure args = UINT32_TO_STREAM(args, sd); args = UINT32_TO_STREAM(args, len); args = UINT32_TO_STREAM(args, flags); // Generate the read command, and wait for the hci_command_send(opcode, ptr, SOCKET_RECV_FROM_PARAMS_LEN); // Since we are in blocking state - wait for event complete SimpleLinkWaitEvent(opcode, &tSocketReadEvent); // In case the number of bytes is more then zero - read data if (tSocketReadEvent.iNumberOfBytes > 0) { // Wait for the data in a synchronous way. Here we assume that the bug is // big enough to store also parameters of receive from too.... SimpleLinkWaitData((unsigned char *)buf, (unsigned char *)from, (unsigned char *)fromlen); } errno = tSocketReadEvent.iNumberOfBytes; return(tSocketReadEvent.iNumberOfBytes); }
/***************************************************************************** * * nvmem.c - CC3000 Host Driver Implementation. * Copyright (C) 2011 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. * *****************************************************************************/ //***************************************************************************** // //! \addtogroup nvmem_api //! @{ // //***************************************************************************** #include <stdint.h> #include <stdbool.h> #include <string.h> #include "evnt_handler.h" #include "socket.h" #include "nvmem.h" #include "hci.h" //***************************************************************************** // // Prototypes for the structures for APIs. // //***************************************************************************** #define NVMEM_READ_PARAMS_LEN (12) #define NVMEM_CREATE_PARAMS_LEN (8) #define NVMEM_WRITE_PARAMS_LEN (16) #ifndef __ENABLE_MULTITHREADED_SUPPORT__ #define c_nvmem_write nvmem_write #define c_nvmem_read nvmem_read #endif /* __ENABLE_MULTITHREADED_SUPPORT__ */ //***************************************************************************** // //! nvmem_read //! //! @param ulFileId nvmem file id:\n //! NVMEM_NVS_FILEID, NVMEM_NVS_SHADOW_FILEID, //! NVMEM_WLAN_CONFIG_FILEID, NVMEM_WLAN_CONFIG_SHADOW_FILEID, //! NVMEM_WLAN_DRIVER_SP_FILEID, NVMEM_WLAN_FW_SP_FILEID, //! NVMEM_MAC_FILEID, NVMEM_FRONTEND_VARS_FILEID, //! NVMEM_IP_CONFIG_FILEID, NVMEM_IP_CONFIG_SHADOW_FILEID, //! NVMEM_BOOTLOADER_SP_FILEID, NVMEM_RM_FILEID, //! and user files 12-15. //! @param ulLength number of bytes to read //! @param ulOffset ulOffset in file from where to read //! @param buff output buffer pointer //! //! @return number of bytes read, otherwise error. //! //! @brief Reads data from the file referred by the ulFileId parameter. //! Reads data from file ulOffset till length. Err if the file can't //! be used, is invalid, or if the read is out of bounds. //! //***************************************************************************** #ifdef __ENABLE_MULTITHREADED_SUPPORT__ signed long c_nvmem_read(unsigned long ulFileId, unsigned long ulLength, unsigned long ulOffset, unsigned char *buff) #else /* __ENABLE_MULTITHREADED_SUPPORT__ */ signed long nvmem_read(unsigned long ulFileId, unsigned long ulLength, unsigned long ulOffset, unsigned char *buff) #endif /* __ENABLE_MULTITHREADED_SUPPORT__ */ { unsigned char ucStatus = 0xFF; unsigned char *ptr; unsigned char *args; ptr = tSLInformation.pucTxCommandBuffer; args = (ptr + HEADERS_SIZE_CMD); // Fill in HCI packet structure args = UINT32_TO_STREAM(args, ulFileId); args = UINT32_TO_STREAM(args, ulLength); args = UINT32_TO_STREAM(args, ulOffset); // Initiate a HCI command hci_command_send(HCI_CMND_NVMEM_READ, ptr, NVMEM_READ_PARAMS_LEN); SimpleLinkWaitEvent(HCI_CMND_NVMEM_READ, &ucStatus); // In case there is data - read it - even if an error code is returned // Note: It is the user responsibility to ignore the data in case of an error code // Wait for the data in a synchronous way. Here we assume that the buffer is // big enough to store also parameters of nvmem SimpleLinkWaitData(buff, 0, 0); return(ucStatus); }
/***************************************************************************** * \brief Read data from nvmem * * Reads data from the file referred by the ulFileId parameter. * Reads data from file ulOffset till len. Err if the file can't * be used, is invalid, or if the read is out of bounds. * * * \param[in] ulFileId nvmem file id:\n * NVMEM_NVS_FILEID, NVMEM_NVS_SHADOW_FILEID, * NVMEM_WLAN_CONFIG_FILEID, NVMEM_WLAN_CONFIG_SHADOW_FILEID, * NVMEM_WLAN_DRIVER_SP_FILEID, NVMEM_WLAN_FW_SP_FILEID, * NVMEM_MAC_FILEID, NVMEM_FRONTEND_VARS_FILEID, * NVMEM_IP_CONFIG_FILEID, NVMEM_IP_CONFIG_SHADOW_FILEID, * NVMEM_BOOTLOADER_SP_FILEID or NVMEM_RM_FILEID. * \param[in] ulLength number of bytes to read * \param[in] ulOffset ulOffset in file from where to read * \param[out] buff output buffer pointer * * \return number of bytes read. * * \sa * \note * \warning * *****************************************************************************/ signed long nvmem_read(unsigned long ulFileId, unsigned long ulLength, unsigned long ulOffset, unsigned char *buff) { unsigned char ucStatus = 0xFF; unsigned char *ptr; unsigned char *args; ptr = tSLInformation.pucTxCommandBuffer; args = (ptr + HEADERS_SIZE_CMD); // // Fill in HCI packet structure // args = UINT32_TO_STREAM(args, ulFileId); args = UINT32_TO_STREAM(args, ulLength); args = UINT32_TO_STREAM(args, ulOffset); // // Initiate a HCI command // hci_command_send(HCI_CMND_NVMEM_READ, ptr, NVMEM_READ_PARAMS_LEN); SimpleLinkWaitEvent(HCI_CMND_NVMEM_READ, &ucStatus); // // In case there is a data - read it // if (ucStatus == 0) { // // Wait for the data in a synchronous way. Here we assume that the buffer is big enough // to store also parameters of nvmem // SimpleLinkWaitData(buff, 0, 0); } return(ucStatus); }
signed long nvmem_read(unsigned long ulFileId, unsigned long ulLength, unsigned long ulOffset, uint8_t *buff) { uint8_t ucStatus = 0xff; uint8_t *ptr; uint8_t *args; cc3000_lib_lock(); ptr = tSLInformation.pucTxCommandBuffer; args = (ptr + HEADERS_SIZE_CMD); /* Fill in HCI packet structure */ args = UINT32_TO_STREAM(args, ulFileId); args = UINT32_TO_STREAM(args, ulLength); args = UINT32_TO_STREAM(args, ulOffset); /* Initiate a HCI command */ hci_command_send(HCI_CMND_NVMEM_READ, ptr, NVMEM_READ_PARAMS_LEN); SimpleLinkWaitEvent(HCI_CMND_NVMEM_READ, &ucStatus); /* In case there is data - read it - even if an error code is returned * Note: It is the user responsibility to ignore the data in case of an * error code */ /* Wait for the data in a synchronous way. Here we assume that the buffer is * big enough to store also parameters of nvmem */ SimpleLinkWaitData(buff, 0, &ucStatus); cc3000_lib_unlock(); return ucStatus; }