/* to this function. */
int BTPSAPI HCITR_COMWrite(unsigned int HCITransportID, unsigned int Length, unsigned char *Buffer)
{
int ret_val;
int Count;
/* Check to make sure that the specified Transport ID is valid and */
/* the output buffer appears to be valid as well. */
if((HCITransportID == TRANSPORT_ID) && (HCITransportOpen) && (Length) && (Buffer))
{
/* Delay and poll until there is enough room in the Tx Buffer (in */
/* the UartContext structure) to hold the data we are trying to */
/* transmit. */
while(UartContext.TxBytesFree < Length)
BTPS_Delay(10);
/* Process all of the data. */
while(Length)
{
/* The data may have to be copied in 2 phases. Calculate the */
/* number of character that can be placed in the buffer before */
/* the buffer must be wrapped. */
Count = (UartContext.TxBufferSize-UartContext.TxInIndex);
Count = (Count > Length)?Length:Count;
BTPS_MemCopy(&(UartContext.TxBuffer[UartContext.TxInIndex]), Buffer, Count);
/* Update the number of free bytes in the buffer. Since this */
/* count can also be updated in the interrupt routine, we will */
/* have have to update this with interrupts disabled. */
MAP_IntDisable(UartContext.IntBase);
UartContext.TxBytesFree -= Count;
MAP_IntEnable(UartContext.IntBase);
/* Adjust the count and index values. */
Buffer += Count;
Length -= Count;
UartContext.TxInIndex += Count;
if(UartContext.TxInIndex >= UartContext.TxBufferSize)
UartContext.TxInIndex = 0;
}
/* Check to see if we need to prime the transmitter. */
if(!(HWREG(UartContext.Base + UART_O_IM) & UART_IM_TXIM))
{
/* Now that the data is in the input buffer, check to see if we*/
/* need to enable the interrupt to start the TX Transfer. */
HWREG(UartContext.Base + UART_O_IM) |= UART_IM_TXIM;
/* Start sending data to the Uart Transmit. */
MAP_IntDisable(UartContext.IntBase);
TxInterrupt();
MAP_IntEnable(UartContext.IntBase);
}
ret_val = 0;
}
else
ret_val = HCITR_ERROR_WRITING_TO_PORT;
return(ret_val);
}
/* character in the stream into the final parameter to this function.*/
static void LoadTransmitBuffer(unsigned int Length, unsigned char *Buffer)
{
unsigned int Count;
/* If the UART is suspended, resume it. */
if(UartContext.SuspendState == hssSuspended)
{
DISABLE_INTERRUPTS();
#ifdef __DISABLE_SMCLK__
/* Request that the SMCLK stay active. */
/* * NOTE * Since we are executing code the SMCLK is currently */
/* active, however what this function calls does is */
/* enable SMCLK requests, so that when LPM3 is next */
/* entered the UART may request that the clock stays */
/* active. */
HAL_EnableSMCLK(HAL_PERIPHERAL_BLUETOOTH_UART);
#endif
/* Flag that the UART clock has been resumed. */
UartContext.SuspendState = hssNormal;
UartContext.Flags &= ~UART_CONTEXT_FLAG_UART_SUSPENDED;
FLOW_ON();
ENABLE_INTERRUPTS();
/* Add a delay while the SMCLK stabilizes. */
__delay_cycles(2500);
}
/* Process all of the data. */
while(Length)
{
/* Loop until space becomes available in the Tx Buffer */
while (UartContext.TxBytesFree <= 0)
;
/* The data may have to be copied in 2 phases. Calculate the */
/* number of character that can be placed in the buffer before the*/
/* buffer must be wrapped. */
Count = UartContext.TxBufferSize-UartContext.TxInIndex;
/* Make sure we dont copy over data waiting to be sent. */
Count = (UartContext.TxBytesFree < Count)?(UartContext.TxBytesFree):(Count);
/* Next make sure we arent trying to copy greater than what we are*/
/* given. */
Count = (Count > Length)?Length:Count;
BTPS_MemCopy(&(UartContext.TxBuffer[UartContext.TxInIndex]), Buffer, Count);
/* Update the number of free bytes in the buffer. Since this */
/* count can also be updated in the interrupt routine, we will */
/* have have to update this with interrupts disabled. */
DISABLE_INTERRUPTS();
UartContext.TxBytesFree -= Count;
ENABLE_INTERRUPTS();
/* Adjust the count and index values. */
Buffer += Count;
Length -= Count;
UartContext.TxInIndex += Count;
if(UartContext.TxInIndex >= UartContext.TxBufferSize)
UartContext.TxInIndex = 0;
/* Check to see if we need to prime the transmitter. The Tx */
/* Interrupt will flag that that it is disabled if thinks that */
/* TxBytesFree == TxBufferSize, re-enable if it is necessary. */
if((UartContext.Flags & (UART_CONTEXT_FLAG_TRANSMIT_ENABLED | UART_CONTEXT_FLAG_TX_FLOW_ENABLED | UART_CONTEXT_FLAG_TX_PRIMED)) == (UART_CONTEXT_FLAG_TRANSMIT_ENABLED | UART_CONTEXT_FLAG_TX_FLOW_ENABLED))
{
/* Start sending data to the Uart Transmit FIFO. */
DISABLE_INTERRUPTS();
/* Enable the transmit interrupt. */
UARTIntEnableTransmit(UartContext.UartBase);
/* Prime the transmitter. */
TxTransmit();
ENABLE_INTERRUPTS();
}
}
}
int Bluetooth::pinCodeResponse(const char *pinCode)
{
int Result;
int ret_val;
PIN_Code_t PINCode;
GAP_Authentication_Information_t GAP_Authentication_Information;
/* First, check that valid Bluetooth Stack ID exists. */
if(bluetoothStackID)
{
/* First, check to see if there is an on-going Pairing operation */
/* active. */
if(!COMPARE_BD_ADDR(CurrentRemoteBD_ADDR, NullADDR))
{
/* Make sure that all of the parameters required for this */
/* function appear to be at least semi-valid. */
if((BTPS_StringLength(pinCode) > 0) && (BTPS_StringLength(pinCode) <= sizeof(PIN_Code_t)))
{
/* Parameters appear to be valid, go ahead and convert the */
/* input parameter into a PIN Code. */
/* Initialize the PIN code. */
ASSIGN_PIN_CODE(PINCode, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
BTPS_MemCopy(&PINCode, pinCode, BTPS_StringLength(pinCode));
/* Populate the response structure. */
GAP_Authentication_Information.GAP_Authentication_Type = atPINCode;
GAP_Authentication_Information.Authentication_Data_Length = (Byte_t)(BTPS_StringLength(pinCode));
GAP_Authentication_Information.Authentication_Data.PIN_Code = PINCode;
/* Submit the Authentication Response. */
Result = GAP_Authentication_Response(bluetoothStackID, CurrentRemoteBD_ADDR, &GAP_Authentication_Information);
/* Check the return value for the submitted command for */
/* success. */
if(!Result)
{
/* Flag success to the caller. */
ret_val = 0;
}
else
{
/* Inform the user that the Authentication Response was */
/* not successful. */
ret_val = -1;
}
/* Flag that there is no longer a current Authentication */
/* procedure in progress. */
ASSIGN_BD_ADDR(CurrentRemoteBD_ADDR, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
}
else
{
ret_val = -1;
}
}
else
{
/* There is not currently an on-going authentication operation,*/
/* inform the user of this error condition. */
ret_val = -1;
}
}
else
{
/* No valid Bluetooth Stack ID exists. */
ret_val = -1;
}
return(ret_val);
}