void host_platform_power_wifi( wiced_bool_t power_enabled )
{
if ( power_enabled == WICED_FALSE )
{
/* Enable WLAN SRAM */
platform_pmu_wifi_sram_on( );
platform_pmu_wifi_allowed_to_sleep( );
platform_pmu_wifi_off( );
/* delay 100 ms */
host_rtos_delay_milliseconds( 100 );
}
else
{
/* Enable WLAN SRAM */
platform_pmu_wifi_sram_on( );
/* Power and wake up WLAN core */
platform_pmu_wifi_on( );
platform_pmu_wifi_wake_up( );
/* Disable WLAN SRAM. This is okay because apps core holds WLAN up */
platform_pmu_wifi_sram_off( );
}
}
int main( void )
{
wiced_mac_t dest_mac = { {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} };
char* payload_ptr = 0;
wwd_result_t result;
NoOS_setup_timing( );
WPRINT_APP_INFO(("\nPlatform " PLATFORM " initialised\n"));
/* Initialise Wiced */
WPRINT_APP_INFO(("Starting Wiced v" WICED_VERSION "\n"));
nons_buffer_init_t pkt_buff_init = { pkt_buffer, sizeof( pkt_buffer ) };
while ( WWD_SUCCESS != ( result = wwd_management_init( COUNTRY, &pkt_buff_init ) ) )
{
WPRINT_APP_INFO(("Error %d while starting WICED!\n", result));
}
/* Get MAC address - this needs to be done before joining a network, so that */
/* we can check the address of any incoming packets against our MAC */
wwd_wifi_get_mac_address( &my_mac, WWD_STA_INTERFACE );
/* Attempt to join the Wi-Fi network */
WPRINT_APP_INFO(("Joining : " AP_SSID "\n"));
while ( wwd_wifi_join( &ap_ssid, AP_SEC, (uint8_t*) AP_PASS, sizeof( AP_PASS ) - 1, NULL ) != WWD_SUCCESS )
{
WPRINT_APP_INFO(("Failed to join : " AP_SSID " .. retrying\n"));
}
WPRINT_APP_INFO(("Successfully joined : " AP_SSID "\n"));
if ( PKT_TARGET_IP != 0xFFFFFFFF ) /* Check if the target has a broadcast address */
{
/* Send an ARP request to resolve the destination IP address into a MAC address */
resolve_dest_mac( PKT_TARGET_IP, &dest_mac );
}
/* Loop forever, repeatedly sending the UDP packet */
while ( 1 )
{
int i;
/* Setup the packet buffer with the canned packet contents. */
payload_ptr = setup_canned_packet( pkt_buffer, sizeof( pkt_buffer ), my_ip_addr, &my_mac, PKT_TARGET_IP, &dest_mac, LOCAL_UDP_PORT, PKT_TARGET_UDP_PORT );
/* Copy the payload into the packet */
memcpy( payload_ptr, PAYLOAD, sizeof( PAYLOAD ) - 1 );
WPRINT_APP_INFO(("Sending Hello!\n"));
send_canned_packet( pkt_buffer, sizeof( PAYLOAD ) - 1 );
for ( i = 0; i < 10; i++ )
{
host_rtos_delay_milliseconds( 100 );
/* Poll for packets to receive (which will be dropped) - 802.11 device will run out of memory if packets are not read out of it */
while ( wwd_thread_poll_all( ) != 0 )
{ }
}
}
}
wwd_result_t host_platform_sdio_enumerate( void )
{
wwd_result_t result;
uint32_t loop_count;
uint32_t data = 0;
loop_count = 0;
do
{
/* Send CMD0 to set it to idle state */
host_platform_sdio_transfer( BUS_WRITE, SDIO_CMD_0, SDIO_BYTE_MODE, SDIO_1B_BLOCK, 0, 0, 0, NO_RESPONSE, NULL );
/* CMD5. */
host_platform_sdio_transfer( BUS_READ, SDIO_CMD_5, SDIO_BYTE_MODE, SDIO_1B_BLOCK, 0, 0, 0, NO_RESPONSE, NULL );
/* Send CMD3 to get RCA. */
result = host_platform_sdio_transfer( BUS_READ, SDIO_CMD_3, SDIO_BYTE_MODE, SDIO_1B_BLOCK, 0, 0, 0, RESPONSE_NEEDED, &data );
loop_count++;
if ( loop_count >= (uint32_t) SDIO_ENUMERATION_TIMEOUT_MS )
{
return WICED_TIMEOUT;
}
} while ( ( result != WWD_SUCCESS ) && ( host_rtos_delay_milliseconds( (uint32_t) 1 ), ( 1 == 1 ) ) );
/* If you're stuck here, check the platform matches your hardware */
/* Send CMD7 with the returned RCA to select the card */
host_platform_sdio_transfer( BUS_WRITE, SDIO_CMD_7, SDIO_BYTE_MODE, SDIO_1B_BLOCK, data, 0, 0, RESPONSE_NEEDED, NULL );
return WICED_SUCCESS;
}
/* Checks if a factory reset is requested */
wiced_bool_t platform_check_factory_reset( void )
{
uint32_t factory_reset_counter = 0;
int led_state = 0;
while ( ( 0 == platform_gpio_input_get( &platform_gpio_pins[ WICED_BUTTON1 ] ) )
&& ( ( factory_reset_counter += PLATFORM_FACTORY_RESET_CHECK_PERIOD ) <= PLATFORM_FACTORY_RESET_TIMEOUT )
&& ( WICED_SUCCESS == (wiced_result_t)host_rtos_delay_milliseconds( PLATFORM_FACTORY_RESET_CHECK_PERIOD ) )
)
{
/* Factory reset button is being pressed. */
/* User Must press it for 5 seconds to ensure it was not accidental */
/* Toggle LED every 100ms */
if ( led_state == 0 )
{
platform_gpio_output_high( &platform_gpio_pins[ WICED_LED1 ] );
led_state = 1;
}
else
{
platform_gpio_output_low( &platform_gpio_pins[ WICED_LED1 ] );
led_state = 0;
}
if ( factory_reset_counter == 5000 )
{
return WICED_TRUE;
}
}
return WICED_FALSE;
}
/**
* Blocks the current thread until the indicated thread is complete
*
* @param thread : handle of the thread to terminate
*
* @returns WWD_SUCCESS on success, WICED_ERROR otherwise
*/
wwd_result_t host_rtos_join_thread( host_thread_type_t* thread )
{
while ( ( thread->tx_thread_state != TX_COMPLETED ) && ( thread->tx_thread_state != TX_TERMINATED ) )
{
host_rtos_delay_milliseconds( 10 );
}
return WWD_SUCCESS;
}
wwd_result_t wwd_ensure_wlan_bus_is_up( void )
{
/* Ensure HT clock is up */
if ( bus_is_up == WICED_TRUE )
{
return WWD_SUCCESS;
}
if ( save_restore_enable == WICED_FALSE )
{
uint8_t csr = 0;
uint32_t attempts = (uint32_t) WLAN_BUS_UP_ATTEMPTS;
VERIFY_RESULT( wwd_bus_write_register_value( BACKPLANE_FUNCTION, (uint32_t) SDIO_CHIP_CLOCK_CSR, (uint8_t) 1, (uint32_t) SBSDIO_HT_AVAIL_REQ ) );
do
{
VERIFY_RESULT( wwd_bus_read_register_value( BACKPLANE_FUNCTION, (uint32_t) SDIO_CHIP_CLOCK_CSR, (uint8_t) 1, &csr ) );
--attempts;
}
while ( ( ( csr & SBSDIO_HT_AVAIL ) == 0 ) &&
( attempts != 0 ) &&
( host_rtos_delay_milliseconds( (uint32_t) 1 ), 1==1 ) );
if (attempts == 0)
{
return WWD_SDIO_BUS_UP_FAIL;
}
else
{
bus_is_up = WICED_TRUE;
return WWD_SUCCESS;
}
}
else
{
if ( wwd_kso_enable( WICED_TRUE ) == WWD_SUCCESS )
{
bus_is_up = WICED_TRUE;
return WWD_SUCCESS;
}
else
{
return WWD_SDIO_BUS_UP_FAIL;
}
}
}
uint32_t platform_get_factory_reset_button_time ( uint32_t max_time )
{
uint32_t button_press_timer = 0;
int led_state = 0;
/* Initialise input */
platform_gpio_init( &platform_gpio_pins[ PLATFORM_FACTORY_RESET_BUTTON_GPIO ], INPUT_PULL_UP );
while ( (PLATFORM_FACTORY_RESET_PRESSED_STATE == platform_gpio_input_get(&platform_gpio_pins[ PLATFORM_FACTORY_RESET_BUTTON_GPIO ])) )
{
/* How long is the "Factory Reset" button being pressed. */
host_rtos_delay_milliseconds( PLATFORM_FACTORY_RESET_CHECK_PERIOD );
/* Toggle LED every PLATFORM_FACTORY_RESET_CHECK_PERIOD */
if ( led_state == 0 )
{
platform_gpio_output_high( &platform_gpio_pins[ PLATFORM_FACTORY_RESET_LED_GPIO ] );
led_state = 1;
}
else
{
platform_gpio_output_low( &platform_gpio_pins[ PLATFORM_FACTORY_RESET_LED_GPIO ] );
led_state = 0;
}
button_press_timer += PLATFORM_FACTORY_RESET_CHECK_PERIOD;
if ((max_time > 0) && (button_press_timer >= max_time))
{
break;
}
}
/* turn off the LED */
if (PLATFORM_FACTORY_RESET_LED_ON_STATE == 1)
{
platform_gpio_output_low( &platform_gpio_pins[ PLATFORM_FACTORY_RESET_LED_GPIO ] );
}
else
{
platform_gpio_output_high( &platform_gpio_pins[ PLATFORM_FACTORY_RESET_LED_GPIO ] );
}
return button_press_timer;
}
void boot_wlan( void )
{
#ifdef MFG_TEST_ALTERNATE_WLAN_DOWNLOAD
external_write_wifi_firmware_and_nvram_image( );
#else
/* Load wlan firmware from sflash */
wwd_bus_write_wifi_firmware_image();
/* Load nvram from sflash */
wwd_bus_write_wifi_nvram_image( );
#endif /* ifdef MFG_TEST_ALTERNATE_WLAN_DOWNLOAD */
/* init wlan uart */
init_wlan_uart();
/* Reset ARM core */
reset_wlan_core( );
host_rtos_delay_milliseconds( 200 );
}
void
rwl_sleep(int delay)
{
host_rtos_delay_milliseconds( delay );
}
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 wwd_kso_enable (wiced_bool_t enable)
{
uint8_t write_value = 0;
uint8_t read_value = 0;
uint8_t compare_value;
uint8_t bmask;
uint32_t attempts = ( uint32_t ) MAX_KSO_ATTEMPTS;
wwd_result_t result;
if ( enable == WICED_TRUE )
{
write_value |= SBSDIO_SLPCSR_KEEP_SDIO_ON;
}
/* 1st KSO write goes to AOS wake up core if device is asleep */
/* Possibly device might not respond to this cmd. So, don't check return value here */
/* 2 Sequential writes to KSO bit are required for SR module to wakeup */
wwd_bus_write_register_value( BACKPLANE_FUNCTION, (uint32_t) SDIO_SLEEP_CSR, (uint8_t) 1, write_value );
wwd_bus_write_register_value( BACKPLANE_FUNCTION, (uint32_t) SDIO_SLEEP_CSR, (uint8_t) 1, write_value );
if ( enable == WICED_TRUE )
{
/* device WAKEUP through KSO:
* write bit 0 & read back until
* both bits 0(kso bit) & 1 (dev on status) are set
*/
compare_value = SBSDIO_SLPCSR_KEEP_SDIO_ON | SBSDIO_SLPCSR_DEVICE_ON;
bmask = compare_value;
}
else
{
/* Put device to sleep, turn off KSO */
compare_value = 0;
/* Check for bit0 only, bit1(devon status) may not get cleared right away */
bmask = SBSDIO_SLPCSR_KEEP_SDIO_ON;
}
do
{
/* Reliable KSO bit set/clr:
* Sdiod sleep write access appears to be in sync with PMU 32khz clk
* just one write attempt may fail,(same is with read ?)
* in any case, read it back until it matches written value
*/
result = wwd_bus_read_register_value( BACKPLANE_FUNCTION, (uint32_t) SDIO_SLEEP_CSR, (uint8_t) 1, &read_value );
if ( ( ( read_value & bmask ) == compare_value ) && ( result == WWD_SUCCESS ) )
{
break;
}
host_rtos_delay_milliseconds( (uint32_t) KSO_WAIT_MS );
wwd_bus_write_register_value( BACKPLANE_FUNCTION, (uint32_t) SDIO_SLEEP_CSR, (uint8_t) 1, write_value );
attempts--;
} while ( attempts != 0 );
if ( attempts == 0 )
{
return WWD_SDIO_BUS_UP_FAIL;
}
else
{
return WWD_SUCCESS;
}
}
/**
* Start tracing scheduler activity.
*/
void gpio_trace_start_trace( trace_flush_function_t flush_f )
{
/* We don't need a flush function because GPIO tracing does not use "any" memory */
UNUSED_PARAMETER( flush_f );
/* Setup the GPIO pins and construct the bit list. */
gpio_trace_init( );
/* Print out the GPIO->Bit mapping. */
Bit_List *curr = least_significant_bit;
unsigned int i = 0;
while ( curr != NULL )
{
#if TRACE_OUTPUT_TYPE == TRACE_OUTPUT_TYPE_ENCODED
#define _GPIO_TRACE_START_TRACE_TEXT "Bit"
#elif TRACE_OUTPUT_TYPE == TRACE_OUTPUT_TYPE_ONEBIT
#define _GPIO_TRACE_START_TRACE_TEXT "Task"
#endif /* #if TRACE_OUTPUT_TYPE == TRACE_OUTPUT_TYPE_ENCODED */
printf( _GPIO_TRACE_START_TRACE_TEXT " %d => Pin %d\r\n", i, breakout_pins_get_pin_number( curr->settings ) );
curr = curr->next;
i++;
}
printf( "\r\n" );
print_tasks( );
#if 0 /* TEST SEQUENCE */
/* Count the number of GPIO pins available */
int num_pins = 0;
curr = least_significant_bit;
while ( curr != NULL )
{
num_pins++;
curr = curr->next;
}
printf( "\r\n" );
printf( "Testing in 3 seconds..." );
host_rtos_delay_milliseconds( 1000 );
printf( "\rTesting in 2 seconds..." );
host_rtos_delay_milliseconds( 1000 );
printf( "\rTesting in 1 second... " );
host_rtos_delay_milliseconds( 1000 );
printf( "\rTesting... " );
#if TRACE_OUTPUT_TYPE == TRACE_OUTPUT_TYPE_ENCODED
#include <math.h>
const int max_value = (int) pow( (double) 2, (double) num_pins );
#elif TRACE_OUTPUT_TYPE == TRACE_OUTPUT_TYPE_ONEBIT
const int max_value = num_pins;
#endif /* #if TRACE_OUTPUT_TYPE == TRACE_OUTPUT_TYPE_ENCODED */
for ( i = 0; i < max_value; i++ )
{
gpio_encode_value( i );
host_rtos_delay_milliseconds( 1 );
}
gpio_encode_value( all_off );
printf( "\rTesting... DONE! \r\n" );
#endif /* 0 */
/* Flash GPIO pins to indicate start of trace */
TRACE_START_SEQUENCE( );
} /* gpio_trace_start_trace */
wiced_result_t wiced_supplicant_start_tls( supplicant_workspace_t* supplicant, wiced_tls_endpoint_type_t type, wiced_tls_certificate_verification_t verification )
{
host_rtos_delay_milliseconds( 10 );
return wiced_generic_start_tls_with_ciphers( (wiced_tls_simple_context_t*)supplicant->tls_context, supplicant, type, verification, my_ciphers, TLS_EAP_TRANSPORT );
}
wiced_result_t wiced_rtos_delay_milliseconds( uint32_t milliseconds )
{
return host_rtos_delay_milliseconds( milliseconds );
}
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 );
}
static besl_result_t p2p_run_as_go( p2p_workspace_t* workspace, wps_agent_t* wps_registrar )
{
uint32_t* data;
wwd_result_t result;
besl_wps_credential_t credential;
wiced_buffer_t buffer;
uint8_t passphrase_buffer[32];
uint8_t a;
REFERENCE_DEBUG_ONLY_VARIABLE(result);
host_rtos_delay_milliseconds( 500 );
/* Limit the rates used on the P2P soft AP */
data = wwd_sdpcm_get_iovar_buffer( &buffer, 4, IOVAR_STR_BSS_RATESET );
data[0] = 1;
result = wwd_sdpcm_send_iovar( SDPCM_SET, buffer, NULL, WICED_AP_INTERFACE );
wiced_assert("", result == WWD_SUCCESS);
/* Prepare the AP credentials */
credential.security = WICED_SECURITY_WPA2_AES_PSK;
credential.ssid.length = workspace->group_candidate.ssid.length;
memcpy( credential.ssid.value, workspace->group_candidate.ssid.value, credential.ssid.length );
credential.passphrase_length = 64;
besl_host_random_bytes(passphrase_buffer, 32);
for ( a = 0; a < 32; ++a )
{
credential.passphrase[2*a] = nibble_to_hexchar(passphrase_buffer[a] >> 4);
credential.passphrase[2*a + 1] = nibble_to_hexchar(passphrase_buffer[a] & 0x0F);
}
/* Start the AP */
wwd_wifi_start_ap( &workspace->group_candidate.ssid, WICED_SECURITY_WPA2_AES_PSK | WPS_ENABLED, credential.passphrase, credential.passphrase_length, 1 );
workspace->p2p_interface = WICED_AP_INTERFACE;
memcpy( &workspace->device_info.mac_address, &workspace->intended_mac_address, sizeof(besl_mac_t) );
wl_p2p_if_t* p2p_if = wwd_sdpcm_get_iovar_buffer( &buffer, sizeof(wl_p2p_if_t), IOVAR_STR_P2P_IFUPD );
p2p_if->interface_type = P2P_GROUP_OWNER_MODE;
memcpy( &p2p_if->mac_address, &workspace->intended_mac_address, sizeof(besl_mac_t) );
result = wwd_sdpcm_send_iovar( SDPCM_SET, buffer, NULL, WICED_STA_INTERFACE );
wiced_assert("", result == WWD_SUCCESS);
p2p_write_probe_response_ie( workspace );
p2p_write_beacon_ie( workspace );
/* Bring up IP layer on AP interface */
wiced_ip_up( WICED_AP_INTERFACE, WICED_USE_INTERNAL_DHCP_SERVER, &p2p_ip_settings );
besl_wps_init( wps_registrar, workspace->wps_device_details, WPS_REGISTRAR_AGENT, WICED_AP_INTERFACE );
/* Init WPS */
wps_internal_init( wps_registrar, WICED_AP_INTERFACE, WPS_PBC_MODE, "00000000", &credential, 1 );
/* Run WPS state machine in P2P thread */
wiced_wps_thread_main( (uint32_t) wps_registrar );
if ( wps_registrar->wps_result == WPS_COMPLETE )
{
workspace->p2p_result = BESL_SUCCESS;
}
else
{
workspace->p2p_result = wps_registrar->wps_result;
}
return BESL_SUCCESS;
}
static besl_result_t p2p_run_as_client( p2p_workspace_t* workspace, wps_agent_t* wps_enrollee )
{
wwd_result_t result;
wl_escan_result_t p2p_group_ap;
besl_wps_credential_t credential;
uint8_t a;
/* Start WPS */
memset( &p2p_group_ap, 0, sizeof(p2p_group_ap) );
/* Add the P2P association request IE to the STA interface */
workspace->p2p_interface = WICED_STA_INTERFACE;
memcpy(&workspace->device_info.mac_address, &workspace->intended_mac_address, sizeof(besl_mac_t));
p2p_write_association_request_ie( workspace );
host_rtos_delay_milliseconds(1500);
besl_wps_init( wps_enrollee, workspace->wps_device_details, WPS_ENROLLEE_AGENT, WICED_STA_INTERFACE);
/* NOTE: For some reason packet being received on the P2P interface are sent up with an interface of 0 (WICED_STA_INTERFACE) */
wps_internal_init(wps_enrollee, WICED_STA_INTERFACE, WPS_PBC_MODE, "00000000", &credential, 1);
/* Create the AP details */
p2p_group_ap.bss_info[0].chanspec = WL_CHANSPEC_BAND_2G | workspace->group_candidate.channel;
p2p_group_ap.bss_info[0].SSID_len = (uint8_t)workspace->group_candidate.ssid.length;
memcpy(&p2p_group_ap.bss_info[0].BSSID, &workspace->group_candidate.bssid, sizeof(besl_mac_t));
memcpy(p2p_group_ap.bss_info[0].SSID, workspace->group_candidate.ssid.value, p2p_group_ap.bss_info[0].SSID_len);
/* Add a few copies to the WPS workspace so it will automatically join the designated AP */
wps_host_store_ap(wps_enrollee->wps_host_workspace, &p2p_group_ap );
wps_host_store_ap(wps_enrollee->wps_host_workspace, &p2p_group_ap );
wps_host_store_ap(wps_enrollee->wps_host_workspace, &p2p_group_ap );
wps_host_store_ap(wps_enrollee->wps_host_workspace, &p2p_group_ap );
/* Run the WPS state machine in the P2P thread */
wiced_wps_thread_main((uint32_t)wps_enrollee);
/* Clean up WPS objects*/
BESL_INFO( ("WPS complete\n") );
besl_wps_deinit( wps_enrollee );
wiced_scan_result_t wps_ap;
wps_ap.channel = workspace->group_candidate.channel;
wps_ap.SSID.length = (uint8_t)workspace->group_candidate.ssid.length;
wps_ap.security = credential.security;
wps_ap.band = WICED_802_11_BAND_2_4GHZ;
wps_ap.bss_type = WICED_BSS_TYPE_INFRASTRUCTURE;
memcpy(&wps_ap.BSSID, &workspace->group_candidate.bssid, sizeof(besl_mac_t));
memcpy(wps_ap.SSID.value, workspace->group_candidate.ssid.value, wps_ap.SSID.length);
/* Try a few times to join the AP with the credentials we've just received */
result = WWD_PENDING;
for ( a = 0; a < 3 && result != WWD_SUCCESS; ++a )
{
result = wwd_wifi_join_specific( &wps_ap, credential.passphrase, credential.passphrase_length, NULL, WWD_STA_INTERFACE );
}
if ( result == WWD_SUCCESS )
{
BESL_INFO( ("P2P complete\n") );
wiced_ip_up(workspace->p2p_interface, WICED_USE_EXTERNAL_DHCP_SERVER, NULL);
workspace->p2p_result = BESL_SUCCESS;
return BESL_SUCCESS;
}
else
{
BESL_INFO( ("P2P couldn't join AP\n") );
workspace->p2p_result = BESL_ERROR_JOIN_FAILED;
return BESL_ERROR_JOIN_FAILED;
}
}
int usleep(useconds_t usec) {
return host_rtos_delay_milliseconds( usec / 1000 );
}
wiced_result_t wiced_generic_start_tls_with_ciphers( wiced_tls_simple_context_t* tls_context, void* referee, wiced_tls_endpoint_type_t type, wiced_tls_certificate_verification_t verification, const cipher_suite_t* cipher_list[], tls_transport_protocol_t transport_protocol )
{
microrng_state rngstate;
int prev_state;
uint64_t start_time;
tls_result_t result;
/* Initialize the session data */
if ( transport_protocol != TLS_EAP_TRANSPORT )
{
memset( &tls_context->session, 0, sizeof(wiced_tls_session_t) );
}
memset( &tls_context->context, 0, sizeof(wiced_tls_context_t) );
/* Prepare session and entropy */
tls_context->session.age = MAX_TLS_SESSION_AGE;
wwd_wifi_get_random( &rngstate.entropy, 4 );
/* Initialize session context */ /* TODO: Ideally this should be done once for a socket */
if ( ssl_init( &tls_context->context ) != 0 )
{
wiced_assert("Error initialising SSL", 0!=0 );
return WICED_TLS_INIT_FAIL;
}
tls_context->context.transport_protocol = transport_protocol;
microrng_init( &rngstate );
ssl_set_endpoint( &tls_context->context, type );
ssl_set_rng ( &tls_context->context, microrng_rand, &rngstate );
tls_context->context.receive_context = referee;
tls_context->context.send_context = referee;
tls_context->context.get_session = tls_get_session;
tls_context->context.set_session = tls_set_session;
tls_context->context.ciphers = cipher_list;
ssl_set_session ( &tls_context->context, SESSION_CAN_BE_RESUMED, 1000000, &tls_context->session );
/* Assert if user has not created correct TLS context for the TLS endpoint type */
wiced_assert("TLS servers must have an advanced TLS context", !((type == WICED_TLS_AS_SERVER) && (tls_context->context_type != WICED_TLS_ADVANCED_CONTEXT)));
if ( root_ca_certificates != NULL )
{
ssl_set_ca_chain( &tls_context->context, root_ca_certificates, tls_context->context.peer_cn );
ssl_set_authmode( &tls_context->context, verification );
}
else
{
ssl_set_authmode( &tls_context->context, SSL_VERIFY_NONE );
}
if ( tls_context->context_type == WICED_TLS_ADVANCED_CONTEXT )
{
wiced_tls_advanced_context_t* advanced_context = (wiced_tls_advanced_context_t*)tls_context;
ssl_set_own_cert( &advanced_context->context, &advanced_context->certificate, &advanced_context->key );
ssl_set_dh_param( &tls_context->context, diffie_hellman_prime_P, sizeof( diffie_hellman_prime_P ), diffie_hellman_prime_G, sizeof( diffie_hellman_prime_G ) );
}
prev_state = 0;
start_time = tls_host_get_time_ms();
do
{
uint64_t curr_time;
if (type == WICED_TLS_AS_SERVER)
{
result = ssl_handshake_server_async( &tls_context->context );
if ( result != TLS_SUCCESS )
{
WPRINT_SECURITY_INFO(( "Error with TLS server handshake\n" ));
goto exit_with_inited_context;
}
}
else
{
result = ssl_handshake_client_async( &tls_context->context );
if ( result != TLS_SUCCESS )
{
WPRINT_SECURITY_INFO(( "Error with TLS client handshake %u\n", (unsigned int)result ));
goto exit_with_inited_context;
}
}
/* break out if stuck */
curr_time = tls_host_get_time_ms();
if ( curr_time - start_time > MAX_HANDSHAKE_WAIT )
{
WPRINT_SECURITY_INFO(( "Timeout in SSL handshake\n" ));
result = TLS_HANDSHAKE_TIMEOUT;
goto exit_with_inited_context;
}
/* if no state change then wait on client */
if ( prev_state == tls_context->context.state )
{
host_rtos_delay_milliseconds( 10 );
}
else /* otherwise process next state with no delay */
{
prev_state = tls_context->context.state;
}
} while ( tls_context->context.state != SSL_HANDSHAKE_OVER );
return WICED_SUCCESS;
exit_with_inited_context:
ssl_close_notify( &tls_context->context );
ssl_free(&tls_context->context);
return (wiced_result_t) result;
}
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;
}
