wwd_result_t wwd_wifi_stop_ap( void )
{
uint32_t* data;
wiced_buffer_t buffer;
wiced_buffer_t response;
wwd_result_t result;
wwd_result_t result2;
/* Query bss state (does it exist? if so is it UP?) */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 4, IOVAR_STR_BSS );
CHECK_IOCTL_BUFFER( data );
*data = wwd_get_bss_index( WWD_AP_INTERFACE );
result = wwd_sdpcm_send_iovar( SDPCM_GET, buffer, &response, WWD_STA_INTERFACE );
if ( result == WWD_WLAN_NOTFOUND )
{
/* AP interface does not exist - i.e. it is down */
wwd_wifi_ap_is_up = WICED_FALSE;
return WWD_SUCCESS;
}
CHECK_RETURN( result );
data = (uint32_t*) host_buffer_get_current_piece_data_pointer( response );
if ( data[0] != (uint32_t) BSS_UP )
{
/* AP interface indicates it is not up - i.e. it is down */
host_buffer_release( response, WWD_NETWORK_RX );
wwd_wifi_ap_is_up = WICED_FALSE;
return WWD_SUCCESS;
}
host_buffer_release( response, WWD_NETWORK_RX );
/* set BSS down */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 8, IOVAR_STR_BSS );
CHECK_IOCTL_BUFFER( data );
data[0] = wwd_get_bss_index( WWD_AP_INTERFACE );
data[1] = (uint32_t) BSS_DOWN;
CHECK_RETURN( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, WWD_STA_INTERFACE ) );
/* Wait until AP is brought down */
result = host_rtos_get_semaphore( &wwd_wifi_sleep_flag, (uint32_t) 10000, WICED_FALSE );
result2 = host_rtos_deinit_semaphore( &wwd_wifi_sleep_flag );
if ( result != WWD_SUCCESS )
{
return result;
}
if ( result2 != WWD_SUCCESS )
{
return result2;
}
CHECK_RETURN( wwd_management_set_event_handler( apsta_events, NULL, NULL, WWD_AP_INTERFACE ) );
wwd_wifi_ap_is_up = WICED_FALSE;
return WWD_SUCCESS;
}
int
wl_ioctl(void *wl, int cmd, void *buf, int len, bool set)
{
wwd_result_t ret;
wiced_buffer_t internalPacket;
wiced_buffer_t response_buffer;
UNUSED_PARAMETER(wl);
// Set Wireless Security Type
void* ioctl_data = wwd_sdpcm_get_ioctl_buffer( &internalPacket, len );
if (ioctl_data == NULL)
{
return WLAN_ENUM_OFFSET - WWD_WLAN_NOMEM;
}
memcpy( ioctl_data, buf, len );
ret = wwd_sdpcm_send_ioctl( (set==TRUE)?SDPCM_SET:SDPCM_GET, cmd, internalPacket, &response_buffer, (wwd_interface_t) ifnum );
if (ret == WWD_SUCCESS)
{
if (set!=TRUE)
{
memcpy( buf, host_buffer_get_current_piece_data_pointer( response_buffer ), MIN( host_buffer_get_current_piece_size( response_buffer ), len ) );
}
host_buffer_release(response_buffer, WWD_NETWORK_RX);
}
else
{
ret = WLAN_ENUM_OFFSET - ret;
}
return ret; /*( ret == WICED_SUCCESS)?0:IOCTL_ERROR;*/
}
/** Sends the first queued packet
*
* Checks the queue to determine if there is any packets waiting
* to be sent. If there are, then it sends the first one.
*
* This function is normally used by the WWD Thread, but can be
* called periodically by systems which have no RTOS to ensure
* packets get sent.
*
* @return 1 : packet was sent
* 0 : no packet sent
*/
int8_t wwd_thread_send_one_packet( void ) /*@modifies internalState @*/
{
wiced_buffer_t tmp_buf_hnd = NULL;
wwd_result_t result;
if ( wwd_sdpcm_get_packet_to_send( &tmp_buf_hnd ) != WWD_SUCCESS )
{
/*@-mustfreeonly@*/ /* Failed to get a packet */
return 0;
/*@+mustfreeonly@*/
}
/* Ensure the wlan backplane bus is up */
result = wwd_ensure_wlan_bus_is_up();
if ( result != WWD_SUCCESS )
{
wiced_assert("Could not bring bus back up", 0 != 0 );
host_buffer_release( tmp_buf_hnd, WWD_NETWORK_TX );
return 0;
}
WWD_LOG(("Wcd:> Sending pkt 0x%08lX\n", (unsigned long)tmp_buf_hnd ));
if ( wwd_bus_send_buffer( tmp_buf_hnd ) != WWD_SUCCESS )
{
WWD_STATS_INCREMENT_VARIABLE( tx_fail );
return 0;
}
WWD_STATS_INCREMENT_VARIABLE( tx_total );
return (int8_t) 1;
}
wwd_result_t wwd_wifi_get_random( void* data_buffer, uint16_t buffer_length )
{
wiced_buffer_t buffer;
uint8_t* tmp_buffer_ptr;
wiced_buffer_t response;
wwd_result_t ret = WWD_PENDING;
static uint16_t pseudo_random = 0;
static uint16_t random_seed = 0;
/* Seed the pseudo random number generator. */
if ( ( pseudo_random == 0 ) || ( random_seed == 0 ) )
{
if ( random_seed == 0 )
{
if ( wwd_sdpcm_get_ioctl_buffer( &buffer, (uint16_t) 2 ) != NULL ) /* Do not need to put anything in buffer hence void cast */
{
ret = wwd_sdpcm_send_ioctl( SDPCM_GET, WLC_GET_RANDOM_BYTES, buffer, &response, WWD_STA_INTERFACE );
}
if ( ret == WWD_SUCCESS )
{
uint8_t* data = (uint8_t*) host_buffer_get_current_piece_data_pointer( response );
memcpy( &random_seed, data, (size_t) 2 );
host_buffer_release( response, WWD_NETWORK_RX );
}
}
if ( pseudo_random == 0 )
{
pseudo_random = (uint16_t)host_rtos_get_time();
}
if ( random_seed != 0 )
{
pseudo_random = (uint16_t)(pseudo_random * random_seed);
}
}
tmp_buffer_ptr = (uint8_t*) data_buffer;
while( buffer_length != 0 )
{
pseudo_random = (uint16_t)((pseudo_random * 32719 + 3) % 32749);
*tmp_buffer_ptr = ((uint8_t*)&pseudo_random)[0];
buffer_length--;
tmp_buffer_ptr++;
if ( buffer_length > 0 )
{
*tmp_buffer_ptr = ((uint8_t*)&pseudo_random)[1];
buffer_length--;
tmp_buffer_ptr++;
}
}
/*@+branchstate@*/
return WWD_SUCCESS;
}
wwd_result_t wwd_process_clm_data(void)
{
wwd_result_t ret = WWD_SUCCESS;
uint32_t clm_blob_size;
uint32_t datalen;
unsigned int size2alloc, data_offset;
unsigned char *chunk_buf;
uint16_t dl_flag = DL_BEGIN;
unsigned int cumulative_len = 0;
unsigned int chunk_len;
uint32_t size_read;
/* clm file size is the initial datalen value which is decremented */
clm_blob_size = resource_get_size( &wifi_firmware_clm_blob );
datalen = clm_blob_size;
data_offset = offsetof(wl_dload_data_t, data);
size2alloc = data_offset + MAX_CHUNK_LEN;
if ((chunk_buf = (unsigned char *)malloc(size2alloc)) != NULL) {
memset(chunk_buf, 0, size2alloc);
do {
if (datalen >= MAX_CHUNK_LEN)
chunk_len = MAX_CHUNK_LEN;
else
chunk_len = datalen;
// check size_read is full value also and resource read return
if ((ret = resource_read(&wifi_firmware_clm_blob, cumulative_len, chunk_len, &size_read, chunk_buf + data_offset)) != WWD_SUCCESS) {
break;
}
if (size_read != chunk_len) {
wiced_assert("During CLM download, resource_read() returned less of the file than should be available\n", 1 == 0);
ret = WWD_CLM_BLOB_DLOAD_ERROR;
break;
}
cumulative_len += chunk_len;
if (datalen - chunk_len == 0)
dl_flag |= DL_END;
ret = wwd_download2dongle(WWD_STA_INTERFACE, IOVAR_STR_CLMLOAD, dl_flag, DL_TYPE_CLM,
chunk_buf, data_offset + chunk_len);
dl_flag &= (uint16_t)~DL_BEGIN;
datalen = datalen - chunk_len;
} while ((datalen > 0) && (ret == WWD_SUCCESS));
free(chunk_buf);
if ( ret != WWD_SUCCESS )
{
wwd_result_t ret_clmload_status;
wiced_buffer_t buffer;
wiced_buffer_t response;
void *data;
WPRINT_WWD_DEBUG(("clmload (%ld byte file) failed with return %d; ", clm_blob_size, ret));
data = (int*)wwd_sdpcm_get_iovar_buffer( &buffer, 4, IOVAR_STR_CLMLOAD_STATUS );
CHECK_IOCTL_BUFFER( data );
ret_clmload_status = wwd_sdpcm_send_iovar( SDPCM_GET, buffer, &response, WWD_STA_INTERFACE );
if ( ret_clmload_status != WWD_SUCCESS )
{
WPRINT_WWD_DEBUG(("clmload_status failed with return %d\n", ret_clmload_status));
}
else
{
uint32_t *clmload_status = (uint32_t *)host_buffer_get_current_piece_data_pointer( response );
if ( clmload_status != NULL )
{
WPRINT_WWD_DEBUG(("clmload_status is %lu\n", *clmload_status));
host_buffer_release( response, WWD_NETWORK_RX );
}
}
}
} else {
ret = WWD_MALLOC_FAILURE;
}
return ret;
}
static wwd_result_t internal_ap_init( wiced_ssid_t* ssid, wiced_security_t auth_type, const uint8_t* security_key, uint8_t key_length, uint8_t channel )
{
wiced_bool_t wait_for_interface = WICED_FALSE;
wwd_result_t result;
wiced_buffer_t response;
wiced_buffer_t buffer;
uint32_t* data;
uint32_t bss_index = WWD_AP_INTERFACE;
#ifdef WICED_WIFI_SOFT_AP_WEP_SUPPORT_ENABLED
uint32_t* auth;
uint16_t length;
#endif
if ( ( ( auth_type == WICED_SECURITY_WPA_TKIP_PSK ) || ( auth_type == WICED_SECURITY_WPA2_AES_PSK ) || ( auth_type == WICED_SECURITY_WPA2_MIXED_PSK ) ) &&
( ( key_length < (uint8_t) 8 ) || ( key_length > (uint8_t) 64 ) ) )
{
WPRINT_APP_INFO(( "Error: WPA security key length must be between 8 and 64\n" ));
return WWD_WPA_KEYLEN_BAD;
}
#ifdef WICED_WIFI_SOFT_AP_WEP_SUPPORT_ENABLED
else if( (( auth_type == WICED_SECURITY_WEP_PSK ) || ( auth_type == WICED_SECURITY_WEP_SHARED )) &&
(( key_length != FORMATTED_ASCII_WEP40_KEY_LENGTH ) && ( key_length != FORMATTED_ASCII_WEP104_KEY_LENGTH )) )
{
WPRINT_APP_INFO(( "Error: WEP security Key length must be either 5 / 13 bytes\n" ));
return WWD_WEP_KEYLEN_BAD;
}
#endif
if ( ( wwd_wifi_p2p_go_is_up == WICED_TRUE ) || ( wwd_wifi_ap_is_up == WICED_TRUE ) )
{
WPRINT_APP_INFO(( "Error: Soft AP or Wi-Fi Direct group owner already up\n" ));
return WWD_AP_ALREADY_UP;
}
/* Query bss state (does it exist? if so is it UP?) */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 4, IOVAR_STR_BSS );
CHECK_IOCTL_BUFFER( data );
*data = (uint32_t) bss_index;
if ( wwd_sdpcm_send_iovar( SDPCM_GET, buffer, &response, WWD_STA_INTERFACE ) != WWD_SUCCESS )
{
/* Note: We don't need to release the response packet since the iovar failed */
wait_for_interface = WICED_TRUE;
}
else
{
/* Check if the BSS is already UP, if so return */
uint32_t* data2 = (uint32_t*) host_buffer_get_current_piece_data_pointer( response );
if ( *data2 == (uint32_t) BSS_UP )
{
host_buffer_release( response, WWD_NETWORK_RX );
wwd_wifi_ap_is_up = WICED_TRUE;
return WWD_SUCCESS;
}
else
{
host_buffer_release( response, WWD_NETWORK_RX );
}
}
CHECK_RETURN( host_rtos_init_semaphore( &wwd_wifi_sleep_flag ) );
/* Register for interested events */
CHECK_RETURN_WITH_SEMAPHORE( wwd_management_set_event_handler( apsta_events, wwd_handle_apsta_event, NULL, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
/* Check if we need to wait for interface to be created */
if ( wait_for_interface == WICED_TRUE )
{
CHECK_RETURN_WITH_SEMAPHORE( host_rtos_get_semaphore( &wwd_wifi_sleep_flag, (uint32_t) 10000, WICED_FALSE ), &wwd_wifi_sleep_flag );
}
if ( wwd_wifi_set_block_ack_window_size( WWD_AP_INTERFACE ) != WWD_SUCCESS )
{
return WWD_SET_BLOCK_ACK_WINDOW_FAIL;
}
/* Set the SSID */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 40, "bsscfg:" IOVAR_STR_SSID );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
data[0] = bss_index; /* Set the bsscfg index */
data[1] = ssid->length; /* Set the ssid length */
memcpy( &data[2], (uint8_t*) ssid->value, ssid->length );
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, WWD_STA_INTERFACE ), &wwd_wifi_sleep_flag );
/* Set the channel */
data = (uint32_t*) wwd_sdpcm_get_ioctl_buffer( &buffer, (uint16_t) 4 );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
*data = channel;
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_SET_CHANNEL, buffer, 0, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
#ifdef WICED_WIFI_SOFT_AP_WEP_SUPPORT_ENABLED
if ( ( auth_type == WICED_SECURITY_WEP_PSK ) || ( auth_type == WICED_SECURITY_WEP_SHARED ) )
{
for ( length = 0; length < key_length; length = (uint16_t) ( length + 2 + security_key[ 1 ] ) )
{
const wiced_wep_key_t* in_key = (const wiced_wep_key_t*) &security_key[ length ];
wl_wsec_key_t* out_key = (wl_wsec_key_t*) wwd_sdpcm_get_ioctl_buffer( &buffer, sizeof(wl_wsec_key_t) );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( out_key, &wwd_wifi_sleep_flag );
memset( out_key, 0, sizeof(wl_wsec_key_t) );
out_key->index = in_key->index;
out_key->len = in_key->length;
memcpy( out_key->data, in_key->data, in_key->length );
switch ( in_key->length )
{
case WEP40_KEY_LENGTH:
out_key->algo = (uint32_t) CRYPTO_ALGO_WEP1;
break;
case WEP104_KEY_LENGTH:
out_key->algo = (uint32_t) CRYPTO_ALGO_WEP128;
break;
default:
host_buffer_release( buffer, WWD_NETWORK_TX );
return WWD_INVALID_KEY;
}
/* Set the first entry as primary key by default */
if ( length == 0 )
{
out_key->flags |= WL_PRIMARY_KEY;
}
out_key->index = htod32(out_key->index);
out_key->len = htod32(out_key->len);
out_key->algo = htod32(out_key->algo);
out_key->flags = htod32(out_key->flags);
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_SET_KEY, buffer, NULL, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
}
/* Set authentication type */
auth = (uint32_t*) wwd_sdpcm_get_ioctl_buffer( &buffer, (uint16_t) 4 );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( auth, &wwd_wifi_sleep_flag );
if ( auth_type == WICED_SECURITY_WEP_SHARED )
{
*auth = WEP_SHARED_KEY_AUTHENTICATION; /* 1 = Shared Key authentication */
}
else
{
*auth = WEP_OPEN_SYSTEM_AUTHENTICATION; /* 0 = Open System authentication */
}
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_SET_AUTH, buffer, 0, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
}
#endif
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 8, "bsscfg:" IOVAR_STR_WSEC );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
data[0] = bss_index;
if ((auth_type & WPS_ENABLED) != 0)
{
data[1] = (uint32_t) ( ( auth_type & ( ~WPS_ENABLED ) ) | SES_OW_ENABLED );
}
else
{
data[1] = (uint32_t) auth_type;
}
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, WWD_STA_INTERFACE ), &wwd_wifi_sleep_flag );
if ( ( auth_type != WICED_SECURITY_OPEN ) && ( auth_type != WICED_SECURITY_WEP_PSK ) && ( auth_type != WICED_SECURITY_WEP_SHARED ) )
{
wsec_pmk_t* psk;
/* Set the wpa auth */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 8, "bsscfg:" IOVAR_STR_WPA_AUTH );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
data[0] = bss_index;
data[1] = (uint32_t) (auth_type == WICED_SECURITY_WPA_TKIP_PSK) ? ( WPA_AUTH_PSK ) : ( WPA2_AUTH_PSK | WPA_AUTH_PSK );
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, WWD_STA_INTERFACE ), &wwd_wifi_sleep_flag );
/* Set the passphrase */
psk = (wsec_pmk_t*) wwd_sdpcm_get_ioctl_buffer( &buffer, sizeof(wsec_pmk_t) );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( psk, &wwd_wifi_sleep_flag );
memcpy( psk->key, security_key, key_length );
psk->key_len = key_length;
psk->flags = (uint16_t) WSEC_PASSPHRASE;
host_rtos_delay_milliseconds( 1 ); /* Delay required to allow radio firmware to be ready to receive PMK and avoid intermittent failure */
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_SET_WSEC_PMK, buffer, 0, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
}
/* Set the GMode */
data = (uint32_t*) wwd_sdpcm_get_ioctl_buffer( &buffer, (uint16_t) 4 );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
*data = (uint32_t) GMODE_AUTO;
result = wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_SET_GMODE, buffer, 0, WWD_AP_INTERFACE );
if ( ( result != WWD_SUCCESS ) && ( result != WWD_WLAN_ASSOCIATED ) )
{
wiced_assert("start_ap: Failed to set GMode\n", 0 == 1 );
(void) host_rtos_deinit_semaphore( &wwd_wifi_sleep_flag );
return result;
}
/* Set the multicast transmission rate to 11 Mbps rather than the default 1 Mbps */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 4, IOVAR_STR_2G_MULTICAST_RATE );
CHECK_IOCTL_BUFFER( data );
*data = (uint32_t) RATE_SETTING_11_MBPS;
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, NULL, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
/* Set DTIM period */
data = (uint32_t*) wwd_sdpcm_get_ioctl_buffer( &buffer, (uint16_t) 4 );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
*data = (uint32_t) WICED_DEFAULT_SOFT_AP_DTIM_PERIOD;
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_SET_DTIMPRD, buffer, 0, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
#ifdef WICED_DISABLE_SSID_BROADCAST
/* Make the AP "hidden" */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 4, IOVAR_STR_CLOSEDNET );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
data[0] = (uint32_t) 1;
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
#endif
#ifdef WICED_WIFI_ISOLATE_AP_CLIENTS
result = wwd_wifi_enable_ap_isolate( WWD_AP_INTERFACE, WICED_TRUE );
wiced_assert("start_ap: Failed to disable intra BSS routing\r\n", result == WWD_SUCCESS );
#endif /* WICED_WIFI_ISOLATE_AP_CLIENTS */
return WWD_SUCCESS;
}
static wwd_result_t internal_ap_init( wiced_ssid_t* ssid, wiced_security_t auth_type, const uint8_t* security_key, uint8_t key_length, uint8_t channel )
{
wiced_bool_t wait_for_interface = WICED_FALSE;
wwd_result_t result;
wiced_buffer_t response;
wiced_buffer_t buffer;
uint32_t* data;
if ( auth_type == WICED_SECURITY_WEP_PSK )
{
return WWD_WEP_NOT_ALLOWED;
}
if ( ( ( auth_type == WICED_SECURITY_WPA_TKIP_PSK ) || ( auth_type == WICED_SECURITY_WPA2_AES_PSK ) || ( auth_type == WICED_SECURITY_WPA2_MIXED_PSK ) ) &&
( ( key_length < (uint8_t) 8 ) || ( key_length > (uint8_t) 64 ) ) )
{
return WWD_WPA_KEYLEN_BAD;
}
if ( wwd_wifi_set_block_ack_window_size( WWD_AP_INTERFACE ) != WWD_SUCCESS )
{
return WWD_SET_BLOCK_ACK_WINDOW_FAIL;
}
/* Query bss state (does it exist? if so is it UP?) */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 4, IOVAR_STR_BSS );
CHECK_IOCTL_BUFFER( data );
*data = (uint32_t) CHIP_AP_INTERFACE;
if ( wwd_sdpcm_send_iovar( SDPCM_GET, buffer, &response, WWD_STA_INTERFACE ) != WWD_SUCCESS )
{
/* Note: We don't need to release the response packet since the iovar failed */
wait_for_interface = WICED_TRUE;
}
else
{
/* Check if the BSS is already UP, if so return */
uint32_t* data2 = (uint32_t*) host_buffer_get_current_piece_data_pointer( response );
if ( *data2 == (uint32_t) BSS_UP )
{
host_buffer_release( response, WWD_NETWORK_RX );
wwd_wifi_ap_is_up = WICED_TRUE;
return WWD_SUCCESS;
}
else
{
host_buffer_release( response, WWD_NETWORK_RX );
}
}
CHECK_RETURN( host_rtos_init_semaphore( &wwd_wifi_sleep_flag ) );
/* Register for interested events */
CHECK_RETURN_WITH_SEMAPHORE( wwd_management_set_event_handler( apsta_events, wwd_handle_apsta_event, NULL, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
/* Set the SSID */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 40, IOVAR_STR_BSSCFG_SSID );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
data[0] = (uint32_t) CHIP_AP_INTERFACE; /* Set the bsscfg index */
data[1] = ssid->length; /* Set the ssid length */
memcpy( &data[2], (uint8_t*) ssid->value, ssid->length );
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, WWD_STA_INTERFACE ), &wwd_wifi_sleep_flag );
/* Check if we need to wait for interface to be created */
if ( wait_for_interface == WICED_TRUE )
{
CHECK_RETURN_WITH_SEMAPHORE( host_rtos_get_semaphore( &wwd_wifi_sleep_flag, (uint32_t) 10000, WICED_FALSE ), &wwd_wifi_sleep_flag );
}
/* Set the channel */
data = (uint32_t*) wwd_sdpcm_get_ioctl_buffer( &buffer, (uint16_t) 4 );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
*data = channel;
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_SET_CHANNEL, buffer, 0, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 8, IOVAR_STR_BSSCFG_WSEC );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
data[0] = (uint32_t) CHIP_AP_INTERFACE;
if ((auth_type & WPS_ENABLED) != 0)
{
data[1] = (uint32_t) ( ( auth_type & ( ~WPS_ENABLED ) ) | SES_OW_ENABLED );
}
else
{
data[1] = (uint32_t) auth_type;
}
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, WWD_STA_INTERFACE ), &wwd_wifi_sleep_flag );
if ( auth_type != WICED_SECURITY_OPEN )
{
wsec_pmk_t* psk;
/* Set the wpa auth */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 8, IOVAR_STR_BSSCFG_WPA_AUTH );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
data[0] = (uint32_t) CHIP_AP_INTERFACE;
data[1] = (uint32_t) (auth_type == WICED_SECURITY_WPA_TKIP_PSK) ? ( WPA_AUTH_PSK ) : ( WPA2_AUTH_PSK | WPA_AUTH_PSK );
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, WWD_STA_INTERFACE ), &wwd_wifi_sleep_flag );
/* Set the passphrase */
psk = (wsec_pmk_t*) wwd_sdpcm_get_ioctl_buffer( &buffer, sizeof(wsec_pmk_t) );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( psk, &wwd_wifi_sleep_flag );
memcpy( psk->key, security_key, key_length );
psk->key_len = key_length;
psk->flags = (uint16_t) WSEC_PASSPHRASE;
host_rtos_delay_milliseconds( 1 ); /* Delay required to allow radio firmware to be ready to receive PMK and avoid intermittent failure */
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_SET_WSEC_PMK, buffer, 0, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
}
/* Set the GMode */
data = wwd_sdpcm_get_ioctl_buffer( &buffer, (uint16_t) 4 );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
*data = (uint32_t) GMODE_AUTO;
result = wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_SET_GMODE, buffer, 0, WWD_AP_INTERFACE );
if ( ( result != WWD_SUCCESS ) && ( result != WWD_WLAN_ASSOCIATED ) )
{
wiced_assert("start_ap: Failed to set GMode\n", 0 == 1 );
(void) host_rtos_deinit_semaphore( &wwd_wifi_sleep_flag );
return result;
}
/* Set the multicast transmission rate to 11 Mbps rather than the default 1 Mbps */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 4, IOVAR_STR_2G_MULTICAST_RATE );
CHECK_IOCTL_BUFFER( data );
*data = (uint32_t) RATE_SETTING_11_MBPS;
result = wwd_sdpcm_send_iovar( SDPCM_SET, buffer, NULL, WWD_AP_INTERFACE );
wiced_assert("start_ap: Failed to set multicast transmission rate\r\n", result == WWD_SUCCESS );
/* Set DTIM period */
data = wwd_sdpcm_get_ioctl_buffer( &buffer, (uint16_t) 4 );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
*data = (uint32_t) WICED_DEFAULT_SOFT_AP_DTIM_PERIOD;
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_SET_DTIMPRD, buffer, 0, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
#ifdef WICED_DISABLE_SSID_BROADCAST
/* Make the AP "hidden" */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 4, IOVAR_STR_CLOSEDNET );
CHECK_IOCTL_BUFFER_WITH_SEMAPHORE( data, &wwd_wifi_sleep_flag );
data[0] = (uint32_t) 1;
CHECK_RETURN_WITH_SEMAPHORE( wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, WWD_AP_INTERFACE ), &wwd_wifi_sleep_flag );
#endif
return WWD_SUCCESS;
}
void besl_p2p_test( p2p_workspace_t* workspace )
{
wiced_buffer_t buffer;
wiced_result_t result;
uint32_t* data;
wiced_mac_t my_mac;
REFERENCE_DEBUG_ONLY_VARIABLE(result);
wiced_wifi_get_mac_address( &my_mac );
my_mac.octet[0] |= 0x2;
wl_p2p_if_t* p2p_if = wwd_sdpcm_get_iovar_buffer( &buffer, sizeof(wl_p2p_if_t), IOVAR_STR_P2P_IFADD );
p2p_if->interface_type = P2P_GROUP_OWNER_MODE;
memcpy( &p2p_if->mac_address, &my_mac, sizeof(besl_mac_t) );
result = wwd_sdpcm_send_iovar( SDPCM_SET, buffer, NULL, WICED_STA_INTERFACE );
wiced_assert("", result == WICED_SUCCESS);
/* Enable discovery */
data = wwd_sdpcm_get_iovar_buffer( &buffer, 4, IOVAR_STR_P2P_DISC );
*data = 1;
result = wwd_sdpcm_send_iovar( SDPCM_SET, buffer, NULL, WICED_STA_INTERFACE );
wiced_assert("", result == WICED_SUCCESS);
wiced_buffer_t response;
wwd_sdpcm_get_iovar_buffer( &buffer, 4, IOVAR_STR_P2P_DEV );
result = wwd_sdpcm_send_iovar( SDPCM_GET, buffer, &response, WICED_STA_INTERFACE );
wiced_assert("", result == WICED_SUCCESS);
workspace->p2p_interface = BESL_READ_32(host_buffer_get_current_piece_data_pointer(response));
host_buffer_release( response, WICED_NETWORK_RX );
BESL_DEBUG( ("interface = %lu\n", workspace->p2p_interface) );
data = wiced_get_ioctl_buffer( &buffer, 4 );
*data = 1;
result = wiced_send_ioctl( SDPCM_SET, WLC_SET_CHANNEL, buffer, NULL, workspace->p2p_interface );
wiced_assert("", result == WICED_SUCCESS);
/* Set WSEC */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 8, IOVAR_STR_BSSCFG_WSEC );
data[0] = (uint32_t) workspace->p2p_interface;
data[1] = WICED_SECURITY_WPA2_AES_PSK;
result = wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, SDPCM_STA_INTERFACE );
wiced_assert("", result == WICED_SUCCESS);
wsec_pmk_t* psk;
/* Set the wpa auth */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 8, IOVAR_STR_BSSCFG_WPA_AUTH );
data[0] = (uint32_t) workspace->p2p_interface;
data[1] = (uint32_t) WPA2_AUTH_PSK;
result = wwd_sdpcm_send_iovar( SDPCM_SET, buffer, 0, SDPCM_STA_INTERFACE );
wiced_assert("", result == WICED_SUCCESS );
/* Set the passphrase */
psk = (wsec_pmk_t*) wiced_get_ioctl_buffer( &buffer, sizeof(wsec_pmk_t) );
memcpy( psk->key, "YOUR_AP_PASSPHRASE", 18 );
psk->key_len = 18;
psk->flags = (uint16_t) WSEC_PASSPHRASE;
host_rtos_delay_milliseconds( 1 ); /* Delay required to allow radio firmware to be ready to receive PMK and avoid intermittent failure */
result = wiced_send_ioctl( SDPCM_SET, WLC_SET_WSEC_PMK, buffer, 0, workspace->p2p_interface );
wiced_assert("", result == WICED_SUCCESS );
wlc_ssid_t* p2p_ssid = wwd_sdpcm_get_iovar_buffer( &buffer, sizeof(wl_p2p_if_t), IOVAR_STR_P2P_SSID );
p2p_ssid->SSID_len = 9;
memcpy( p2p_ssid->SSID, "DIRECT-ww", 9 );
result = wwd_sdpcm_send_iovar( SDPCM_SET, buffer, NULL, WICED_STA_INTERFACE );
wiced_assert("", result == WICED_SUCCESS);
/* Bring up P2P interface */
wiced_get_ioctl_buffer( &buffer, 0 );
result = wiced_send_ioctl( SDPCM_SET, WLC_UP, buffer, NULL, workspace->p2p_interface );
wiced_assert("", result == WICED_SUCCESS);
p2p_set_discovery_state( P2P_DISCOVERY_STATE_LISTEN );
}
besl_result_t besl_p2p_init( p2p_workspace_t* workspace, const besl_p2p_device_detail_t* device_details )
{
wiced_buffer_t buffer;
wiced_buffer_t response;
uint32_t* data;
wwd_result_t result;
REFERENCE_DEBUG_ONLY_VARIABLE(result);
memset(workspace, 0, sizeof(p2p_workspace_t));
workspace->p2p_capability = 0x0000;
workspace->p2p_name = device_details->device_name;
workspace->group_owner_intent = 1;
/* Turn off all the other Wi-Fi interfaces */
wiced_network_down(WICED_STA_INTERFACE);
wiced_network_down(WICED_AP_INTERFACE);
/* Query the AP interface to ensure that it is up */
data = (uint32_t*) wwd_sdpcm_get_iovar_buffer( &buffer, (uint16_t) 36, IOVAR_STR_BSSCFG_SSID );
memset(data, 0, 36);
data[0] = (uint32_t) CHIP_AP_INTERFACE;
wwd_sdpcm_send_iovar( SDPCM_SET, buffer, NULL, WWD_STA_INTERFACE );
/* Enable discovery */
data = wwd_sdpcm_get_iovar_buffer(&buffer, 4, IOVAR_STR_P2P_DISC );
*data = 1;
result = wwd_sdpcm_send_iovar(SDPCM_SET, buffer, NULL, WICED_STA_INTERFACE);
wiced_assert("", result == WWD_SUCCESS);
/* Find what interface is the P2P device */
wwd_sdpcm_get_iovar_buffer(&buffer, 4, IOVAR_STR_P2P_DEV );
result = wwd_sdpcm_send_iovar(SDPCM_GET, buffer, &response, WICED_STA_INTERFACE);
wiced_assert("", result == WWD_SUCCESS);
workspace->p2p_interface = BESL_READ_32(host_buffer_get_current_piece_data_pointer(response));
host_buffer_release(response, WWD_NETWORK_RX);
/* Get the P2P interface MAC address */
besl_host_get_mac_address(&workspace->device_info.mac_address, workspace->p2p_interface);
/* Set the standard interface MAC address to be the same as the P2P interface */
besl_host_set_mac_address(&workspace->device_info.mac_address, WICED_STA_INTERFACE);
besl_host_set_mac_address(&workspace->device_info.mac_address, WICED_AP_INTERFACE);
/* Get the standard MAC address to confirm */
besl_host_get_mac_address(&workspace->intended_mac_address, WICED_STA_INTERFACE);
BESL_INFO( ("STA MAC: %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", workspace->intended_mac_address.octet[0],
workspace->intended_mac_address.octet[1],
workspace->intended_mac_address.octet[2],
workspace->intended_mac_address.octet[3],
workspace->intended_mac_address.octet[4],
workspace->intended_mac_address.octet[5]) );
/* Set the device details */
workspace->wps_device_details = &device_details->wps_device_details;
/* Allow the P2P library to initialize */
p2p_init(workspace, workspace->p2p_name);
/* Bring up P2P interface */
wwd_sdpcm_get_ioctl_buffer( &buffer, 0 );
result = wwd_sdpcm_send_ioctl( SDPCM_SET, WLC_UP, buffer, NULL, workspace->p2p_interface);
wiced_assert("", result == WWD_SUCCESS);
/* Set wsec to any non-zero value in the discovery bsscfg to ensure our P2P probe responses have the privacy bit set in the 802.11 WPA IE.
* Some peer devices may not initiate WPS with us if this bit is not set. */
data = wwd_sdpcm_get_iovar_buffer(&buffer, 8, IOVAR_STR_BSSCFG_WSEC );
data[0] = workspace->p2p_interface;
data[1] = WICED_SECURITY_WPA2_AES_PSK;
result = wwd_sdpcm_send_iovar(SDPCM_SET, buffer, NULL, WICED_STA_INTERFACE);
wiced_assert("", result == WWD_SUCCESS);
workspace->p2p_current_state = P2P_STATE_DISCOVERING;
/* Add P2P event handler */
result = wwd_management_set_event_handler( p2p_events, p2p_event_handler, workspace, workspace->p2p_interface );
wiced_assert("", result == WWD_SUCCESS);
/* Create the message queue */
host_rtos_init_queue(&p2p_message_queue, p2p_message_queue_buffer, sizeof(p2p_message_queue_buffer), sizeof(p2p_message_t));
/* Create the pending outgoing packet queue */
host_rtos_init_queue(&p2p_outgoing_packet_queue, p2p_outgoing_packet_queue_buffer, sizeof(p2p_outgoing_packet_queue_buffer), sizeof(p2p_message_t));
/* Create the P2P thread */
host_rtos_create_thread_with_arg( &p2p_thread, p2p_thread_main, "p2p", p2p_thread_stack, sizeof(p2p_thread_stack), RTOS_HIGHER_PRIORTIY_THAN(RTOS_DEFAULT_THREAD_PRIORITY), (uint32_t)workspace );
return BESL_SUCCESS;
}