OrgApache/incubator-nuttx
OrgApache
/
incubator-nuttx
mirror of https://github.com/apache/incubator-nuttx.git
1
0
Fork 0
Code Issues Releases Wiki Activity
incubator-nuttx/drivers/wireless/cc3000/hci.c

249 lines
8.3 KiB
C
Raw Blame History

/****************************************************************************
* hci.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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <debug.h>
#include <string.h>
#include <nuttx/wireless/cc3000/cc3000_common.h>
#include <nuttx/wireless/cc3000/hci.h>
#include "cc3000drv.h"
#include <nuttx/wireless/cc3000/evnt_handler.h>
#include <nuttx/wireless/cc3000/wlan.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define SL_PATCH_PORTION_SIZE (1000)
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: hci_command_send
*
* Description:
* Initiate an HCI command.
*
* Input Parameters:
* usOpcode command operation code
* pucBuff pointer to the command's arguments buffer
* ucArgsLength length of the arguments
*
* Returned Value:
* Zero
*
****************************************************************************/
uint16_t hci_command_send(uint16_t usOpcode, uint8_t *pucBuff,
uint8_t ucArgsLength)
{
uint8_t *stream;
stream = (pucBuff + SPI_HEADER_SIZE);
nllvdbg("Send 0x%x\n", usOpcode);
UINT8_TO_STREAM(stream, HCI_TYPE_CMND);
stream = UINT16_TO_STREAM(stream, usOpcode);
UINT8_TO_STREAM(stream, ucArgsLength);
/* Update the opcode of the event we will be waiting for */
cc3000_write(pucBuff, ucArgsLength + SIMPLE_LINK_HCI_CMND_HEADER_SIZE);
nllvdbg("Send of 0x%x Completed\n", usOpcode);
return 0;
}
/****************************************************************************
* Name: hci_data_send
*
* Description:
*
*
* Input Parameters:
* usOpcode command operation code
* ucArgs pointer to the command's arguments buffer
* usArgsLength length of the arguments
* ucTail pointer to the data buffer
* usTailLength buffer length
*
* Returned Value:
* None
*
****************************************************************************/
long hci_data_send(uint8_t ucOpcode, uint8_t *ucArgs, uint16_t usArgsLength,
uint16_t usDataLength, const uint8_t *ucTail,
uint16_t usTailLength)
{
uint8_t *stream;
stream = ((ucArgs) + SPI_HEADER_SIZE);
UINT8_TO_STREAM(stream, HCI_TYPE_DATA);
UINT8_TO_STREAM(stream, ucOpcode);
UINT8_TO_STREAM(stream, usArgsLength);
stream = UINT16_TO_STREAM(stream, usArgsLength + usDataLength + usTailLength);
/* Send the packet over the SPI */
cc3000_write(ucArgs,
SIMPLE_LINK_HCI_DATA_HEADER_SIZE + usArgsLength +
usDataLength + usTailLength);
return ESUCCESS;
}
/****************************************************************************
* Name: hci_data_command_send
*
* Description:
* Prepeare HCI header and initiate an HCI data write operation
*
* Input Parameters:
* usOpcode command operation code
* pucBuff pointer to the data buffer
* ucArgsLength arguments length
* ucDataLength data length
*
* Returned Value:
* None
*
****************************************************************************/
void hci_data_command_send(uint16_t usOpcode, uint8_t *pucBuff,
uint8_t ucArgsLength, uint16_t ucDataLength)
{
uint8_t *stream = (pucBuff + SPI_HEADER_SIZE);
UINT8_TO_STREAM(stream, HCI_TYPE_DATA);
UINT8_TO_STREAM(stream, usOpcode);
UINT8_TO_STREAM(stream, ucArgsLength);
stream = UINT16_TO_STREAM(stream, ucArgsLength + ucDataLength);
/* Send the command over SPI on data channel */
cc3000_write(pucBuff,
ucArgsLength + ucDataLength +
SIMPLE_LINK_HCI_DATA_CMND_HEADER_SIZE);
}
/****************************************************************************
* Name: hci_patch_send
*
* Description:
* Prepeare HCI header and initiate an HCI patch write operation
*
* Input Parameters:
* usOpcode command operation code
* pucBuff pointer to the command's arguments buffer
* patch pointer to patch content buffer
* usDataLength data length
*
* Returned Value:
* None
*
****************************************************************************/
void hci_patch_send(uint8_t ucOpcode, uint8_t *pucBuff, char *patch,
uint16_t usDataLength)
{
uint8_t *data_ptr = (pucBuff + SPI_HEADER_SIZE);
uint16_t usTransLength;
uint8_t *stream = (pucBuff + SPI_HEADER_SIZE);
UINT8_TO_STREAM(stream, HCI_TYPE_PATCH);
UINT8_TO_STREAM(stream, ucOpcode);
stream = UINT16_TO_STREAM(stream,
usDataLength + SIMPLE_LINK_HCI_PATCH_HEADER_SIZE);
if (usDataLength <= SL_PATCH_PORTION_SIZE)
{
UINT16_TO_STREAM(stream, usDataLength);
stream = UINT16_TO_STREAM(stream, usDataLength);
memcpy((pucBuff + SPI_HEADER_SIZE) + HCI_PATCH_HEADER_SIZE, patch,
usDataLength);
/* Update the opcode of the event we will be waiting for */
cc3000_write(pucBuff, usDataLength + HCI_PATCH_HEADER_SIZE);
}
else
{
usTransLength = (usDataLength/SL_PATCH_PORTION_SIZE);
UINT16_TO_STREAM(stream,
usDataLength + SIMPLE_LINK_HCI_PATCH_HEADER_SIZE +
usTransLength*SIMPLE_LINK_HCI_PATCH_HEADER_SIZE);
stream = UINT16_TO_STREAM(stream, SL_PATCH_PORTION_SIZE);
memcpy(pucBuff + SPI_HEADER_SIZE + HCI_PATCH_HEADER_SIZE, patch,
SL_PATCH_PORTION_SIZE);
usDataLength -= SL_PATCH_PORTION_SIZE;
patch += SL_PATCH_PORTION_SIZE;
/* Update the opcode of the event we will be waiting for */
cc3000_write(pucBuff, SL_PATCH_PORTION_SIZE + HCI_PATCH_HEADER_SIZE);
while (usDataLength)
{
if (usDataLength <= SL_PATCH_PORTION_SIZE)
{
usTransLength = usDataLength;
usDataLength = 0;
}
else
{
usTransLength = SL_PATCH_PORTION_SIZE;
usDataLength -= usTransLength;
}
*(uint16_t *)data_ptr = usTransLength;
memcpy(data_ptr + SIMPLE_LINK_HCI_PATCH_HEADER_SIZE, patch,
usTransLength);
patch += usTransLength;
/* Update the opcode of the event we will be waiting for */
cc3000_write((uint8_t *)data_ptr, usTransLength + sizeof(usTransLength));
}
}
}
Reference in New Issue View Git Blame Copy Permalink