long
wlan_add_profile(unsigned long ulSecType,
unsigned char* ucSsid,
unsigned long ulSsidLen,
unsigned char *ucBssid,
unsigned long ulPriority,
unsigned long ulPairwiseCipher_Or_TxKeyLen,
unsigned long ulGroupCipher_TxKeyIndex,
unsigned long ulKeyMgmt,
unsigned char* ucPf_OrKey,
unsigned long ulPassPhraseLen)
{
unsigned short arg_len;
long ret;
unsigned char *ptr;
long i = 0;
unsigned char *args;
unsigned char bssid_zero[] = {0, 0, 0, 0, 0, 0};
ptr = tSLInformation.pucTxCommandBuffer;
args = (ptr + HEADERS_SIZE_CMD);
args = UINT32_TO_STREAM(args, ulSecType);
// Setup arguments in accordance with the security type
switch (ulSecType)
{
//OPEN
case WLAN_SEC_UNSEC:
{
args = UINT32_TO_STREAM(args, 0x00000014);
args = UINT32_TO_STREAM(args, ulSsidLen);
args = UINT16_TO_STREAM(args, 0);
if(ucBssid)
{
ARRAY_TO_STREAM(args, ucBssid, ETH_ALEN);
}
else
{
ARRAY_TO_STREAM(args, bssid_zero, ETH_ALEN);
}
args = UINT32_TO_STREAM(args, ulPriority);
ARRAY_TO_STREAM(args, ucSsid, ulSsidLen);
arg_len = WLAN_ADD_PROFILE_NOSEC_PARAM_LEN + ulSsidLen;
}
break;
//WEP
case WLAN_SEC_WEP:
{
args = UINT32_TO_STREAM(args, 0x00000020);
args = UINT32_TO_STREAM(args, ulSsidLen);
args = UINT16_TO_STREAM(args, 0);
if(ucBssid)
{
ARRAY_TO_STREAM(args, ucBssid, ETH_ALEN);
}
else
{
ARRAY_TO_STREAM(args, bssid_zero, ETH_ALEN);
}
args = UINT32_TO_STREAM(args, ulPriority);
args = UINT32_TO_STREAM(args, 0x0000000C + ulSsidLen);
args = UINT32_TO_STREAM(args, ulPairwiseCipher_Or_TxKeyLen);
args = UINT32_TO_STREAM(args, ulGroupCipher_TxKeyIndex);
ARRAY_TO_STREAM(args, ucSsid, ulSsidLen);
for(i = 0; i < 4; i++)
{
unsigned char *p = &ucPf_OrKey[i * ulPairwiseCipher_Or_TxKeyLen];
ARRAY_TO_STREAM(args, p, ulPairwiseCipher_Or_TxKeyLen);
}
arg_len = WLAN_ADD_PROFILE_WEP_PARAM_LEN + ulSsidLen +
ulPairwiseCipher_Or_TxKeyLen * 4;
}
break;
//WPA
//WPA2
case WLAN_SEC_WPA:
case WLAN_SEC_WPA2:
{
args = UINT32_TO_STREAM(args, 0x00000028);
args = UINT32_TO_STREAM(args, ulSsidLen);
args = UINT16_TO_STREAM(args, 0);
if(ucBssid)
{
ARRAY_TO_STREAM(args, ucBssid, ETH_ALEN);
}
else
{
ARRAY_TO_STREAM(args, bssid_zero, ETH_ALEN);
}
args = UINT32_TO_STREAM(args, ulPriority);
args = UINT32_TO_STREAM(args, ulPairwiseCipher_Or_TxKeyLen);
args = UINT32_TO_STREAM(args, ulGroupCipher_TxKeyIndex);
args = UINT32_TO_STREAM(args, ulKeyMgmt);
args = UINT32_TO_STREAM(args, 0x00000008 + ulSsidLen);
args = UINT32_TO_STREAM(args, ulPassPhraseLen);
ARRAY_TO_STREAM(args, ucSsid, ulSsidLen);
ARRAY_TO_STREAM(args, ucPf_OrKey, ulPassPhraseLen);
arg_len = WLAN_ADD_PROFILE_WPA_PARAM_LEN + ulSsidLen + ulPassPhraseLen;
}
break;
}
// Initiate a HCI command
hci_command_send(HCI_CMND_WLAN_IOCTL_ADD_PROFILE,
ptr, arg_len);
// Wait for command complete event
SimpleLinkWaitEvent(HCI_CMND_WLAN_IOCTL_ADD_PROFILE, &ret);
return(ret);
}
//*****************************************************************************
//
//! simple_link_send
//!
//! @param sd socket handle
//! @param buf write buffer
//! @param len buffer length
//! @param flags On this version, this parameter is not supported
//! @param to pointer to an address structure indicating destination
//! address
//! @param tolen destination address structure size
//!
//! @return Return the number of bytes transmitted, or -1 if an error
//! occurred, or -2 in case there are no free buffers available
//! (only when SEND_NON_BLOCKING is enabled)
//!
//! @brief This function is used to transmit a message to another
//! socket
//
//*****************************************************************************
int
simple_link_send(long sd, const void *buf, long len, long flags,
const sockaddr *to, long tolen, long opcode)
{
unsigned char uArgSize, addrlen;
unsigned char *ptr, *pDataPtr, *args;
unsigned long addr_offset;
int res;
tBsdReadReturnParams tSocketSendEvent;
// Check the bsd_arguments
if (0 != (res = HostFlowControlConsumeBuff(sd)))
{
return res;
}
//Update the number of sent packets
tSLInformation.NumberOfSentPackets++;
// Allocate a buffer and construct a packet and send it over spi
ptr = tSLInformation.pucTxCommandBuffer;
args = (ptr + HEADERS_SIZE_DATA);
// Update the offset of data and parameters according to the command
switch(opcode)
{
case HCI_CMND_SENDTO:
{
addr_offset = len + sizeof(len) + sizeof(len);
addrlen = 8;
uArgSize = SOCKET_SENDTO_PARAMS_LEN;
pDataPtr = ptr + HEADERS_SIZE_DATA + SOCKET_SENDTO_PARAMS_LEN;
break;
}
case HCI_CMND_SEND:
{
tolen = 0;
to = NULL;
uArgSize = HCI_CMND_SEND_ARG_LENGTH;
pDataPtr = ptr + HEADERS_SIZE_DATA + HCI_CMND_SEND_ARG_LENGTH;
break;
}
default:
{
break;
}
}
// Fill in temporary command buffer
args = UINT32_TO_STREAM(args, sd);
args = UINT32_TO_STREAM(args, uArgSize - sizeof(sd));
args = UINT32_TO_STREAM(args, len);
args = UINT32_TO_STREAM(args, flags);
if (opcode == HCI_CMND_SENDTO)
{
args = UINT32_TO_STREAM(args, addr_offset);
args = UINT32_TO_STREAM(args, addrlen);
}
// Copy the data received from user into the TX Buffer
ARRAY_TO_STREAM(pDataPtr, ((unsigned char *)buf), len);
// In case we are using SendTo, copy the to parameters
if (opcode == HCI_CMND_SENDTO)
{
ARRAY_TO_STREAM(pDataPtr, ((unsigned char *)to), tolen);
}
// Initiate a HCI command
hci_data_send(opcode, ptr, uArgSize, len,(unsigned char*)to, tolen);
if (opcode == HCI_CMND_SENDTO)
SimpleLinkWaitEvent(HCI_EVNT_SENDTO, &tSocketSendEvent);
else
SimpleLinkWaitEvent(HCI_EVNT_SEND, &tSocketSendEvent);
return (len);
}
/*******************************************************************************
**
** Function btusb_lite_hci_event_filter
**
** Description Filter HCI Events received from BT Controller.
**
** Returns status: <> 0 if the event must be send to user space (BSA)
** 0 if the event is handled
**
*******************************************************************************/
int btusb_lite_hci_event_filter(struct btusb *p_dev, UINT8 *p_data, int length)
{
#if 0
BT_HDR *p_msg;
UINT8 *p;
UINT16 size;
#endif
/* Check if HCI is over IPC */
if (btusb_lite_is_hci_over_ipc(p_dev) == 0)
{
/* If it is not, the event have to be sent through regular HCI */
return 1;
}
/* Check if the Event is a NumberOfCompletePacket Event */
if (btusb_lite_hci_nocp_event_hdlr(p_dev, p_data, length) == 0)
{
return 0; /* Do not Send this event to user space (we handled it) */
}
/* TODO: check if CSB VSE */
return 1;
#if 0
/* Add size of both UIPC Length and Event header */
size = length + sizeof(UINT16) + sizeof(UINT16);
/* Get a buffer from the pool */
p_msg = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + size);
if(unlikely(p_msg == NULL))
{
BTUSB_ERR("Unable to get GKI buffer\n");
return 0;
}
if (unlikely(dbgflags & BTUSB_GKI_CHK_MSG) &&
unlikely(GKI_buffer_status(p_msg) != BUF_STATUS_UNLINKED))
{
BTUSB_ERR("buffer != BUF_STATUS_UNLINKED 0x%p\n", p_msg);
return;
}
p_msg->offset = 0;
p_msg->event = 0;
p_msg->len = size;
p = (UINT8 *)(p_msg + 1) + p_msg->offset;
UINT16_TO_STREAM(p, length + sizeof(UINT16)); /* UIPC Length */
UINT16_TO_STREAM(p, BT_EVT_TO_BTU_HCI_EVT); /* UIPC Event */
UINT8_TO_STREAM(p, hci_event); /* Write back the HCI Event (we already read it) */
ARRAY_TO_STREAM(p, p_data, length - 1); /* Copy Event data */
/* Send message to User Space */
btusb_lite_ipc_sent_to_user(p_dev, p_msg);
return 0; /* Event handled by the Stack Lite. No need to send it to HCI */
#endif
}
int32_t cc3000_wlan::add_profile(uint32_t sec_type,
uint8_t* ssid,
uint32_t ssid_length,
uint8_t *b_ssid,
uint32_t priority,
uint32_t pairwise_cipher_or_tx_key_len,
uint32_t group_cipher_tx_key_index,
uint32_t key_mgmt,
uint8_t* pf_or_key,
uint32_t pass_phrase_len) {
uint16_t arg_len = 0x00;
int32_t ret;
uint8_t *ptr;
int32_t i = 0;
uint8_t *args;
uint8_t bssid_zero[] = {0, 0, 0, 0, 0, 0};
ptr = _simple_link.get_transmit_buffer();
args = (ptr + HEADERS_SIZE_CMD);
args = UINT32_TO_STREAM(args, sec_type);
// Setup arguments in accordance with the security type
switch (sec_type)
{
//OPEN
case WLAN_SEC_UNSEC:
{
args = UINT32_TO_STREAM(args, 0x00000014);
args = UINT32_TO_STREAM(args, ssid_length);
args = UINT16_TO_STREAM(args, 0);
if(b_ssid)
{
ARRAY_TO_STREAM(args, b_ssid, ETH_ALEN);
}
else
{
ARRAY_TO_STREAM(args, bssid_zero, ETH_ALEN);
}
args = UINT32_TO_STREAM(args, priority);
ARRAY_TO_STREAM(args, ssid, ssid_length);
arg_len = WLAN_ADD_PROFILE_NOSEC_PARAM_LEN + ssid_length;
}
break;
//WEP
case WLAN_SEC_WEP:
{
args = UINT32_TO_STREAM(args, 0x00000020);
args = UINT32_TO_STREAM(args, ssid_length);
args = UINT16_TO_STREAM(args, 0);
if(b_ssid)
{
ARRAY_TO_STREAM(args, b_ssid, ETH_ALEN);
}
else
{
ARRAY_TO_STREAM(args, bssid_zero, ETH_ALEN);
}
args = UINT32_TO_STREAM(args, priority);
args = UINT32_TO_STREAM(args, 0x0000000C + ssid_length);
args = UINT32_TO_STREAM(args, pairwise_cipher_or_tx_key_len);
args = UINT32_TO_STREAM(args, group_cipher_tx_key_index);
ARRAY_TO_STREAM(args, ssid, ssid_length);
for(i = 0; i < 4; i++)
{
uint8_t *p = &pf_or_key[i * pairwise_cipher_or_tx_key_len];
ARRAY_TO_STREAM(args, p, pairwise_cipher_or_tx_key_len);
}
arg_len = WLAN_ADD_PROFILE_WEP_PARAM_LEN + ssid_length +
pairwise_cipher_or_tx_key_len * 4;
}
break;
//WPA
//WPA2
case WLAN_SEC_WPA:
case WLAN_SEC_WPA2:
{
args = UINT32_TO_STREAM(args, 0x00000028);
args = UINT32_TO_STREAM(args, ssid_length);
args = UINT16_TO_STREAM(args, 0);
if(b_ssid)
{
ARRAY_TO_STREAM(args, b_ssid, ETH_ALEN);
}
else
{
ARRAY_TO_STREAM(args, bssid_zero, ETH_ALEN);
}
args = UINT32_TO_STREAM(args, priority);
args = UINT32_TO_STREAM(args, pairwise_cipher_or_tx_key_len);
args = UINT32_TO_STREAM(args, group_cipher_tx_key_index);
args = UINT32_TO_STREAM(args, key_mgmt);
args = UINT32_TO_STREAM(args, 0x00000008 + ssid_length);
args = UINT32_TO_STREAM(args, pass_phrase_len);
ARRAY_TO_STREAM(args, ssid, ssid_length);
ARRAY_TO_STREAM(args, pf_or_key, pass_phrase_len);
arg_len = WLAN_ADD_PROFILE_WPA_PARAM_LEN + ssid_length + pass_phrase_len;
}
break;
}
// Initiate a HCI command
_hci.command_send(HCI_CMND_WLAN_IOCTL_ADD_PROFILE, ptr, arg_len);
// Wait for command complete event
_event.simplelink_wait_event(HCI_CMND_WLAN_IOCTL_ADD_PROFILE, &ret);
return(ret);
}
//*****************************************************************************
//
//! simple_link_send
//!
//! @param sd socket handle
//! @param buf write buffer
//! @param len buffer length
//! @param flags On this version, this parameter is not supported
//! @param to pointer to an address structure indicating destination
//! address
//! @param tolen destination address structure size
//!
//! @return Return the number of bytes transmitted, or -1 if an error
//! occurred, or -2 in case there are no free buffers available
//!
//! @brief This function is used to transmit a message to another
//! socket
//
//*****************************************************************************
static int
simple_link_send(long sd, const void *buf, long len, long flags,
const sockaddr *to, long tolen, long opcode)
{
uint8_t uArgSize, addrlen;
uint8_t *pDataPtr, *args;
uint32_t addr_offset = 0;
int res;
tBsdReadReturnParams tSocketSendEvent;
uint16_t rx_opcode;
// Check the bsd_arguments
if ((res = consume_buf(sd)) != 0)
return res;
// Allocate a buffer and construct a packet and send it over spi
args = hci_get_data_buffer();
// Update the offset of data and parameters according to the command
switch(opcode) {
case HCI_CMND_SENDTO:
addr_offset = len + sizeof(len) + sizeof(len);
addrlen = 8;
uArgSize = SOCKET_SENDTO_PARAMS_LEN;
pDataPtr = args + SOCKET_SENDTO_PARAMS_LEN;
break;
case HCI_CMND_SEND:
tolen = 0;
to = NULL;
uArgSize = HCI_CMND_SEND_ARG_LENGTH;
pDataPtr = args + HCI_CMND_SEND_ARG_LENGTH;
break;
default:
return -1;
}
// Fill in temporary command buffer
args = UINT32_TO_STREAM(args, sd);
args = UINT32_TO_STREAM(args, uArgSize - sizeof(sd));
args = UINT32_TO_STREAM(args, len);
args = UINT32_TO_STREAM(args, flags);
if (opcode == HCI_CMND_SENDTO) {
args = UINT32_TO_STREAM(args, addr_offset);
args = UINT32_TO_STREAM(args, addrlen);
}
// Copy the data received from user into the TX Buffer
ARRAY_TO_STREAM(pDataPtr, ((uint8_t *)buf), len);
// In case we are using SendTo, copy the to parameters
if (opcode == HCI_CMND_SENDTO) {
ARRAY_TO_STREAM(pDataPtr, ((uint8_t *)to), tolen);
}
if (opcode == HCI_CMND_SENDTO)
rx_opcode = HCI_EVNT_SENDTO;
else
rx_opcode = HCI_EVNT_SEND;
// Initiate a HCI command
hci_data_send(opcode, uArgSize, len, (uint8_t*)to, tolen,
rx_opcode, &tSocketSendEvent);
return (len);
}
/*******************************************************************************
**
** Function nfc_hal_dm_set_config
**
** Description Send NCI config items to NFCC
**
** Returns tHAL_NFC_STATUS
**
*******************************************************************************/
tHAL_NFC_STATUS nfc_hal_dm_set_config (UINT8 tlv_size,
UINT8 *p_param_tlvs,
tNFC_HAL_NCI_CBACK *p_cback)
{
UINT8 *p_buff, *p;
UINT8 num_param = 0, param_len, rem_len, *p_tlv;
UINT16 cmd_len = NCI_MSG_HDR_SIZE + tlv_size + 1;
tHAL_NFC_STATUS status = HAL_NFC_STATUS_FAILED;
if ((tlv_size == 0)||(p_param_tlvs == NULL))
{
return status;
}
if ((p_buff = (UINT8 *) GKI_getbuf ((UINT16)(NCI_MSG_HDR_SIZE + tlv_size))) != NULL)
{
p = p_buff;
NCI_MSG_BLD_HDR0 (p, NCI_MT_CMD, NCI_GID_CORE);
NCI_MSG_BLD_HDR1 (p, NCI_MSG_CORE_SET_CONFIG);
UINT8_TO_STREAM (p, (UINT8) (tlv_size + 1));
rem_len = tlv_size;
p_tlv = p_param_tlvs;
while (rem_len > 1)
{
num_param++; /* number of params */
p_tlv ++; /* param type */
param_len = *p_tlv++; /* param length */
rem_len -= 2; /* param type and length */
if (rem_len >= param_len)
{
rem_len -= param_len;
p_tlv += param_len; /* next param_type */
if (rem_len == 0)
{
status = HAL_NFC_STATUS_OK;
break;
}
}
else
{
/* error found */
break;
}
}
if (status == HAL_NFC_STATUS_OK)
{
UINT8_TO_STREAM (p, num_param);
ARRAY_TO_STREAM (p, p_param_tlvs, tlv_size);
nfc_hal_dm_send_nci_cmd (p_buff, cmd_len, p_cback);
}
else
{
HAL_TRACE_ERROR0 ("nfc_hal_dm_set_config ():Bad TLV");
}
GKI_freebuf (p_buff);
}
return status;
}
/*******************************************************************************
** DIS Attributes Database Server Request callback
*******************************************************************************/
UINT8 dis_read_attr_value (UINT8 clcb_idx, UINT16 handle, tGATT_VALUE *p_value,
BOOLEAN is_long, tGATT_STATUS *p_status)
{
tDIS_DB_ENTRY *p_db_attr = dis_cb.dis_attr;
UINT8 *p = p_value->value, i, *pp;
UINT16 offset = p_value->offset;
UINT8 act = SRVC_ACT_RSP;
tGATT_STATUS st = GATT_NOT_FOUND;
UNUSED(clcb_idx);
for (i = 0; i < DIS_MAX_CHAR_NUM; i ++, p_db_attr ++)
{
if (handle == p_db_attr->handle)
{
if ((p_db_attr->uuid == GATT_UUID_PNP_ID || p_db_attr->uuid == GATT_UUID_SYSTEM_ID)&&
is_long == TRUE)
{
st = GATT_NOT_LONG;
break;
}
st = GATT_SUCCESS;
switch (p_db_attr->uuid)
{
case GATT_UUID_MANU_NAME:
case GATT_UUID_MODEL_NUMBER_STR:
case GATT_UUID_SERIAL_NUMBER_STR:
case GATT_UUID_FW_VERSION_STR:
case GATT_UUID_HW_VERSION_STR:
case GATT_UUID_SW_VERSION_STR:
case GATT_UUID_IEEE_DATA:
pp = dis_cb.dis_value.data_string[p_db_attr->uuid - GATT_UUID_MODEL_NUMBER_STR];
if (pp != NULL)
{
if (strlen ((char *)pp) > GATT_MAX_ATTR_LEN)
p_value->len = GATT_MAX_ATTR_LEN;
else
p_value->len = (UINT16)strlen ((char *)pp);
}
else
p_value->len = 0;
if (offset > p_value->len)
{
st = GATT_INVALID_OFFSET;
break;
}
else
{
p_value->len -= offset;
pp += offset;
ARRAY_TO_STREAM(p, pp, p_value->len);
GATT_TRACE_EVENT("GATT_UUID_MANU_NAME len=0x%04x", p_value->len);
}
break;
case GATT_UUID_SYSTEM_ID:
UINT64_TO_STREAM(p, dis_cb.dis_value.system_id); /* int_min */
p_value->len = DIS_SYSTEM_ID_SIZE;
break;
case GATT_UUID_PNP_ID:
UINT8_TO_STREAM(p, dis_cb.dis_value.pnp_id.vendor_id_src);
UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.vendor_id);
UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.product_id);
UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.product_version);
p_value->len = DIS_PNP_ID_SIZE;
break;
}
break;
}
}
*p_status = st;
return act;
}
