void twc_init(two_way_channel_t* twc, int fdA, int fdB, size_t buffer_size)
{
twc->fdA = fdA;
twc->fdB = fdB;
sm_init(&twc->sm_A2B, fdA, fdB, buffer_size);
sm_init(&twc->sm_B2A, fdB, fdA, buffer_size);
}
static void le_counter_setup(void){
// register for HCI events
hci_event_callback_registration.callback = &packet_handler;
hci_add_event_handler(&hci_event_callback_registration);
l2cap_init();
// setup le device db
le_device_db_init();
// setup SM: Display only
sm_init();
// setup ATT server
att_server_init(profile_data, att_read_callback, att_write_callback);
att_server_register_packet_handler(packet_handler);
// setup advertisements
uint16_t adv_int_min = 0x0030;
uint16_t adv_int_max = 0x0030;
uint8_t adv_type = 0;
bd_addr_t null_addr;
memset(null_addr, 0, 6);
gap_advertisements_set_params(adv_int_min, adv_int_max, adv_type, 0, null_addr, 0x07, 0x00);
gap_advertisements_set_data(adv_data_len, (uint8_t*) adv_data);
gap_advertisements_enable(1);
// set one-shot timer
heartbeat.process = &heartbeat_handler;
btstack_run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
btstack_run_loop_add_timer(&heartbeat);
}
static void
init_display (GdkDisplay *dpy,
XfceRc *rc,
gboolean disable_tcp)
{
const gchar *engine;
gint n;
xfce_rc_set_group (rc, "Splash Screen");
engine = xfce_rc_read_entry (rc, "Engine", NULL);
splash_screen = xfsm_splash_screen_new (dpy, engine);
xfsm_splash_screen_next (splash_screen, _("Loading desktop settings"));
gdk_flush ();
xfce_rc_set_group (rc, "General");
sm_init (rc, disable_tcp);
/* start a MCS manager process per screen (FIXME: parallel to loading logo) */
for (n = 0; n < gdk_display_get_n_screens (dpy); ++n)
{
mcs_client_check_manager (gdk_x11_display_get_xdisplay (dpy), n,
"xfce-mcs-manager");
}
/* gtk resource files may have changed */
gtk_rc_reparse_all ();
}
int btstack_main(int argc, const char * argv[]){
int arg = 1;
cmdline_addr_found = 0;
while (arg < argc) {
if(!strcmp(argv[arg], "-a") || !strcmp(argv[arg], "--address")){
arg++;
cmdline_addr_found = sscanf_bd_addr(argv[arg], cmdline_addr);
arg++;
if (!cmdline_addr_found) exit(1);
continue;
}
usage(argv[0]);
return 0;
}
hci_event_callback_registration.callback = &hci_event_handler;
hci_add_event_handler(&hci_event_callback_registration);
l2cap_init();
gatt_client_init();
sm_init();
sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int btstack_main(int argc, const char * argv[]){
// set up l2cap_le
l2cap_init();
// setup le device db
le_device_db_init();
// setup SM: Display only
sm_init();
sm_set_io_capabilities(IO_CAPABILITY_DISPLAY_ONLY);
sm_set_authentication_requirements( SM_AUTHREQ_BONDING | SM_AUTHREQ_MITM_PROTECTION);
// setup ATT server
att_server_init(profile_data, NULL, att_write_callback);
att_server_register_packet_handler(app_packet_handler);
printf("Run...\n\r");
// turn on!
hci_power_control(HCI_POWER_ON);
// LED_PORT_OUT &= ~LED_2;
return 0;
}
void setup(void){
/// GET STARTED with BTstack ///
btstack_memory_init();
run_loop_init(RUN_LOOP_POSIX);
// use logger: format HCI_DUMP_PACKETLOGGER, HCI_DUMP_BLUEZ or HCI_DUMP_STDOUT
hci_dump_open("/tmp/gatt_browser.pklg", HCI_DUMP_PACKETLOGGER);
// init HCI
remote_device_db_t * remote_db = (remote_device_db_t *) &remote_device_db_memory;
bt_control_t * control = NULL;
#ifndef HAVE_UART_CC2564
hci_transport_t * transport = hci_transport_usb_instance();
#else
hci_transport_t * transport = hci_transport_h4_instance();
control = bt_control_cc256x_instance();
// config.device_name = "/dev/tty.usbserial-A600eIDu"; // 5438
config.device_name = "/dev/tty.usbserial-A800cGd0"; // 5529
config.baudrate_init = 115200;
config.baudrate_main = 0;
config.flowcontrol = 1;
#endif
hci_init(transport, &config, control, remote_db);
l2cap_init();
l2cap_register_packet_handler(&handle_hci_event);
gatt_client_init();
gatt_client_register_packet_handler(&handle_gatt_client_event);
sm_init();
sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
}
void ble_init(void){
advertisements_enabled = 0;
// setup central device db
central_device_db_init();
sm_init();
// gap_random_address_set_update_period(300000);
// gap_random_address_set_mode(GAP_RANDOM_ADDRESS_RESOLVABLE);
sm_set_authentication_requirements( SM_AUTHREQ_BONDING | SM_AUTHREQ_MITM_PROTECTION);
sm_set_request_security(1);
//strcpy(gap_device_name, "BTstack");
sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
// sm_register_oob_data_callback(get_oob_data_callback);
// sm_set_encryption_key_size_range(7, 16);
// sm_test_set_irk(test_irk);
//gap_random_address_set_update_period(300000);
//gap_random_address_set_mode(GAP_RANDOM_ADDRESS_RESOLVABLE);
// setup ATT server
att_server_init(profile_data, att_read_callback, att_write_callback);
att_server_register_packet_handler(app_packet_handler);
}
int btstack_main(int argc, const char * argv[]){
int arg = 1;
cmdline_addr_found = 0;
while (arg < argc) {
if(!strcmp(argv[arg], "-a") || !strcmp(argv[arg], "--address")){
arg++;
cmdline_addr_found = sscan_bd_addr((uint8_t *)argv[arg], cmdline_addr);
arg++;
continue;
}
usage(argv[0]);
return 0;
}
l2cap_init();
l2cap_register_packet_handler(&handle_hci_event);
gatt_client_init();
gc_id = gatt_client_register_packet_handler(&handle_gatt_client_event);
sm_init();
sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
// turn on!
hci_power_control(HCI_POWER_ON);
// go!
run_loop_execute();
// happy compiler!
return 0;
}
int btstack_main(void)
{
// register for HCI events
hci_event_callback_registration.callback = &packet_handler;
hci_add_event_handler(&hci_event_callback_registration);
l2cap_init();
rfcomm_init();
rfcomm_register_service(packet_handler, RFCOMM_SERVER_CHANNEL, 0xffff);
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
spp_create_sdp_record(spp_service_buffer, 0x10001, RFCOMM_SERVER_CHANNEL, "SPP Counter");
sdp_register_service(spp_service_buffer);
printf("SDP service record size: %u\n", de_get_len(spp_service_buffer));
gap_set_local_name("SPP and LE Counter 00:00:00:00:00:00");
gap_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
gap_discoverable_control(1);
// setup le device db
le_device_db_init();
// setup SM: Display only
sm_init();
// setup ATT server
att_server_init(profile_data, att_read_callback, att_write_callback);
att_server_register_packet_handler(packet_handler);
// set one-shot timer
heartbeat.process = &heartbeat_handler;
btstack_run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
btstack_run_loop_add_timer(&heartbeat);
// setup advertisements
uint16_t adv_int_min = 0x0030;
uint16_t adv_int_max = 0x0030;
uint8_t adv_type = 0;
bd_addr_t null_addr;
memset(null_addr, 0, 6);
gap_advertisements_set_params(adv_int_min, adv_int_max, adv_type, 0, null_addr, 0x07, 0x00);
gap_advertisements_set_data(adv_data_len, (uint8_t*) adv_data);
gap_advertisements_enable(1);
// beat once
beat();
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
static void sm_peripheral_setup(void){
// register for HCI events
hci_event_callback_registration.callback = &packet_handler;
hci_add_event_handler(&hci_event_callback_registration);
l2cap_init();
// setup le device db
le_device_db_init();
// setup SM: Display only
sm_init();
sm_event_callback_registration.callback = &packet_handler;
sm_add_event_handler(&sm_event_callback_registration);
/**
* Choose ONE of the following configurations
*/
// LE Legacy Pairing, Just Works
sm_set_io_capabilities(IO_CAPABILITY_DISPLAY_YES_NO);
sm_set_authentication_requirements(0);
// LE Legacy Pairing, Passkey entry initiator enter, responder (us) displays
// sm_set_io_capabilities(IO_CAPABILITY_DISPLAY_ONLY);
// sm_set_authentication_requirements(SM_AUTHREQ_MITM_PROTECTION);
#ifdef ENABLE_LE_SECURE_CONNECTIONS
// LE Secure Connetions, Just Works
// sm_set_io_capabilities(IO_CAPABILITY_DISPLAY_YES_NO);
// sm_set_authentication_requirements(SM_AUTHREQ_SECURE_CONNECTION);
// LE Secure Connections, Numeric Comparison
// sm_set_io_capabilities(IO_CAPABILITY_DISPLAY_YES_NO);
// sm_set_authentication_requirements(SM_AUTHREQ_SECURE_CONNECTION|SM_AUTHREQ_MITM_PROTECTION);
// LE Legacy Pairing, Passkey entry initiator enter, responder (us) displays
// sm_set_io_capabilities(IO_CAPABILITY_DISPLAY_ONLY);
// sm_set_authentication_requirements(SM_AUTHREQ_SECURE_CONNECTION|SM_AUTHREQ_MITM_PROTECTION);
#endif
// setup ATT server
att_server_init(profile_data, NULL, NULL);
att_server_register_packet_handler(packet_handler);
// setup advertisements
uint16_t adv_int_min = 0x0030;
uint16_t adv_int_max = 0x0030;
uint8_t adv_type = 0;
bd_addr_t null_addr;
memset(null_addr, 0, 6);
gap_advertisements_set_params(adv_int_min, adv_int_max, adv_type, 0, null_addr, 0x07, 0x00);
gap_advertisements_set_data(adv_data_len, (uint8_t*) adv_data);
gap_advertisements_enable(1);
}
void tapioca_start_and_join(void) {
int rv;
struct peer* p;
rv = sm_init(lp_config, base);
assert(rv >= 0);
rv = cproxy_init(paxos_config, base);
assert(rv >= 0);
cproxy_submit_join(NodeType, LocalIpAddress, LocalPort);
event_base_dispatch(base);
}
void tapioca_start(int recovery) {
int rv;
rv = sm_init(lp_config, base);
assert(rv >= 0);
rv = cproxy_init(paxos_config, base);
assert(rv >= 0);
if (recovery)
sm_recovery();
event_base_dispatch(base);
}
/* Init Opus encoder, return it on success. Print error to stdout, release wave resource and return NULL on error. */
OpusSM* init_opus(WAVE* wave) {
OpusSM* sm = sm_init(wave->header.SampleRate, wave->header.NumChannels);
if (sm_error(sm) != SM_OK) {
fprintf(stderr, "Opus encoder returned error on opus_encoder_create(). Error code: %d\n", sm_error(sm));
sm = sm_destroy(sm);
return NULL;
}
return sm;
}
/**
* Add a single sequence-to-unicode path to the state machine.
*/
static int sm_add(STATE_MACHINE* sm, char* seq, const wchar_t* unicode, char flag)
{
STATE_MACHINE* sm_found = sm_search_shallow(sm, seq[0]);
/* Empty sequence */
if(seq[0] == '\0') {
if(wcslen(sm->output)) {
size_t i;
fprintf(stderr, "Unicode sequence ");
for(i = 0; i < wcslen(sm->output); i++) fprintf(stderr, "%04X ", (int)sm->output[i]);
fprintf(stderr, " already defined, overriding with ");
for(i = 0; i < wcslen(unicode); i++) fprintf(stderr, "%04X ", (int)unicode[i]);
fprintf(stderr, "\n");
}
wcscpy(sm->output, unicode);
sm->flag = flag;
return 0;
}
/* The key doesn't exist yet */
if(!sm_found) {
int index = (int)sm->next_size;
SM_WITH_KEY* next = &sm->next[index];
/* Add the key */
next->key = seq[0];
next->state = malloc(sizeof(STATE_MACHINE));
if(!next->state) {
perror("sm_add");
return 1;
}
sm_init(next->state);
/* Increase store for next time, if necessary */
if(++(sm->next_size) >= sm->next_maxsize) {
if(sm_dblspace(sm)) {
fprintf(stderr, "Memory expansion failure\n");
return 1;
}
}
sm_found = next->state;
}
/* Recurse */
sm_add(sm_found, seq+1, unicode, flag);
/* Sort the states */
sm_sort_shallow(sm);
return 0;
}
static int
setup(void **state) {
sm_ctx_t *ctx = NULL;
sr_logger_init("sm_test");
sr_log_stderr(SR_LL_DBG);
sm_init(NULL, NULL, &ctx);
*state = ctx;
return 0;
}
INT32 FsInit(void)
{
INT32 i;
for (i = 0; i < MAX_DRIVE; i++) {
fs_struct[i].mounted = FALSE;
fs_struct[i].sb = NULL;
sm_init(&(fs_struct[i].v_sem));
}
return(ffsInit());
}
/**
* Initialize the character map table.
*/
static int charmap_init(CHARMAP* cm)
{
int error_code = 0;
int i = 0;
memset(cm, 0, sizeof(CHARMAP));
for(i = 0; i < MAX_SECTIONS; i++) {
error_code += sm_init(&cm->sections[i]);
}
return error_code;
}
static void plugin_init(OhmPlugin *plugin)
{
OHM_DEBUG_INIT(playback);
client_init(plugin);
media_init(plugin);
pbreq_init(plugin);
sm_init(plugin);
dbusif_init(plugin);
dresif_init(plugin);
fsif_init(plugin);
timestamp_init();
}
int btstack_main(void)
{
hci_discoverable_control(1);
l2cap_init();
l2cap_register_packet_handler(packet_handler);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_internal(NULL, RFCOMM_SERVER_CHANNEL, 0xffff);
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
/* LISTING_PAUSE */
#ifdef EMBEDDED
/* LISTING_RESUME */
service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
sdp_create_spp_service( (uint8_t*) &service_record_item->service_record, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service buffer size: %u\n", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
/* LISTING_PAUSE */
#else
sdp_create_spp_service( spp_service_buffer, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service record size: %u\n", de_get_len(spp_service_buffer));
sdp_register_service_internal(NULL, spp_service_buffer);
#endif
/* LISTING_RESUME */
hci_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
// setup le device db
le_device_db_init();
// setup SM: Display only
sm_init();
// setup ATT server
att_server_init(profile_data, att_read_callback, att_write_callback);
att_dump_attributes();
// set one-shot timer
heartbeat.process = &heartbeat_handler;
run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
run_loop_add_timer(&heartbeat);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
static void main_init_sec_mon(size_t pos, uint32_t nsec_entry)
{
struct sm_nsec_ctx *nsec_ctx;
assert(nsec_entry != NSEC_ENTRY_INVALID);
/* Initialize secure monitor */
sm_init(GET_STACK(stack_sm[pos]));
nsec_ctx = sm_get_nsec_ctx();
nsec_ctx->mon_lr = nsec_entry;
nsec_ctx->mon_spsr = CPSR_MODE_SVC | CPSR_I;
sm_set_entry_vector(thread_vector_table);
}
static void gatt_client_setup(void){
// register for HCI events
hci_event_callback_registration.callback = &handle_hci_event;
hci_add_event_handler(&hci_event_callback_registration);
// Initialize L2CAP and register HCI event handler
l2cap_init();
// Initialize GATT client
gatt_client_init();
// Optinoally, Setup security manager
sm_init();
sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
}
int btstack_main(int argc, const char * argv[]){
printf("BTstack LE Peripheral starting up...\n");
// set up l2cap_le
l2cap_init();
// setup le device db
le_device_db_init();
// setup SM: Display only
sm_init();
sm_set_io_capabilities(IO_CAPABILITY_DISPLAY_ONLY);
sm_set_authentication_requirements( SM_AUTHREQ_BONDING | SM_AUTHREQ_MITM_PROTECTION);
// setup ATT server
att_server_init(profile_data, att_read_callback, att_write_callback);
att_write_queue_init();
att_attributes_init();
att_server_register_packet_handler(app_packet_handler);
att_dump_attributes();
btstack_stdin_setup(stdin_process);
gap_random_address_set_update_period(300000);
gap_random_address_set_mode(GAP_RANDOM_ADDRESS_RESOLVABLE);
strcpy(gap_device_name, "BTstack");
sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
sm_io_capabilities = "IO_CAPABILITY_NO_INPUT_NO_OUTPUT";
sm_set_authentication_requirements(0);
sm_register_oob_data_callback(get_oob_data_callback);
sm_set_encryption_key_size_range(sm_min_key_size, 16);
sm_test_set_irk(test_irk);
// set one-shot timer
heartbeat.process = &heartbeat_handler;
run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
run_loop_add_timer(&heartbeat);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
void setup(void){
/// GET STARTED with BTstack ///
btstack_memory_init();
run_loop_init(RUN_LOOP_POSIX);
// use logger: format HCI_DUMP_PACKETLOGGER, HCI_DUMP_BLUEZ or HCI_DUMP_STDOUT
hci_dump_open("/tmp/hci_dump.pklg", HCI_DUMP_PACKETLOGGER);
// init HCI
#ifdef HAVE_UART_CSR
hci_transport_t * transport = hci_transport_h4_instance();
hci_uart_config_t * config = &hci_uart_config;
bt_control_t * control = bt_control_csr_instance();
#elif defined(HAVE_UART_CC256x)
hci_transport_t * transport = hci_transport_h4_instance();
hci_uart_config_t * config = &hci_uart_config;
bt_control_t * control = bt_control_cc256x_instance();
#else
hci_transport_t * transport = hci_transport_usb_instance();
hci_uart_config_t * config = NULL;
bt_control_t * control = NULL;
#endif
remote_device_db_t * remote_db = (remote_device_db_t *) &remote_device_db_memory;
hci_init(transport, config, control, remote_db);
// set up l2cap_le
l2cap_init();
// setup central device db
central_device_db_init();
// setup SM: Display only
sm_init();
sm_set_io_capabilities(IO_CAPABILITY_DISPLAY_ONLY);
sm_set_authentication_requirements( SM_AUTHREQ_BONDING | SM_AUTHREQ_MITM_PROTECTION);
// setup ATT server
att_server_init(profile_data, att_read_callback, att_write_callback);
att_write_queue_init();
att_attributes_init();
att_server_register_packet_handler(app_packet_handler);
att_dump_attributes();
}
int btstack_main(int argc, const char * argv[]){
#ifdef HAVE_BTSTACK_STDIN
int arg = 1;
cmdline_addr_found = 0;
while (arg < argc) {
if(!strcmp(argv[arg], "-a") || !strcmp(argv[arg], "--address")){
arg++;
cmdline_addr_found = sscanf_bd_addr(argv[arg], cmdline_addr);
arg++;
if (!cmdline_addr_found) exit(1);
continue;
}
usage(argv[0]);
return 0;
}
#else
(void)argc;
(void)argv;
#endif
hci_event_callback_registration.callback = &hci_event_handler;
hci_add_event_handler(&hci_event_callback_registration);
l2cap_init();
gatt_client_init();
sm_init();
sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
// use different connection parameters: conn interval min/max (* 1.25 ms), slave latency, supervision timeout, CE len min/max (* 0.6125 ms)
// gap_set_connection_parameters(0x06, 0x06, 4, 1000, 0x01, 0x06 * 2);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
/*
* Copyright (c) 2014, STMicroelectronics International N.V.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. 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.
*
* 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 HOLDER 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.
*/
#include <stdint.h>
#include <string.h>
#include <sm/sm.h>
#include <sm/sm_defs.h>
#include <sm/tee_mon.h>
#include <sm/teesmc.h>
#include <sm/teesmc_st.h>
#include <kernel/arch_debug.h>
#include <arm32.h>
#include <kernel/thread.h>
#include <kernel/panic.h>
#include <kernel/util.h>
#include <kernel/tee_core_trace.h>
#include <kernel/misc.h>
#include <mm/tee_pager_unpg.h>
#include <mm/core_mmu.h>
#include <tee/entry.h>
#include <assert.h>
#ifdef WITH_STACK_CANARIES
#define STACK_CANARY_SIZE (4 * sizeof(uint32_t))
#define START_CANARY_VALUE 0xdededede
#define END_CANARY_VALUE 0xabababab
#define GET_START_CANARY(name, stack_num) name[stack_num][0]
#define GET_END_CANARY(name, stack_num) \
name[stack_num][sizeof(name[stack_num]) / sizeof(uint32_t) - 1]
#else
#define STACK_CANARY_SIZE 0
#endif
#define STACK_ALIGNMENT 8
#define DECLARE_STACK(name, num_stacks, stack_size) \
static uint32_t name[num_stacks][(stack_size + STACK_CANARY_SIZE) / \
sizeof(uint32_t)] \
__attribute__((section(".bss.prebss.stack"), \
aligned(STACK_ALIGNMENT)))
#define GET_STACK(stack) \
((vaddr_t)(stack) + sizeof(stack) - STACK_CANARY_SIZE / 2)
DECLARE_STACK(stack_tmp, CFG_TEE_CORE_NB_CORE, STACK_TMP_SIZE);
DECLARE_STACK(stack_abt, CFG_TEE_CORE_NB_CORE, STACK_ABT_SIZE);
DECLARE_STACK(stack_sm, CFG_TEE_CORE_NB_CORE, SM_STACK_SIZE);
DECLARE_STACK(stack_thread, NUM_THREADS, STACK_THREAD_SIZE);
const vaddr_t stack_tmp_top[CFG_TEE_CORE_NB_CORE] = {
GET_STACK(stack_tmp[0]),
#if CFG_TEE_CORE_NB_CORE > 1
GET_STACK(stack_tmp[1]),
#endif
#if CFG_TEE_CORE_NB_CORE > 2
GET_STACK(stack_tmp[2]),
#endif
#if CFG_TEE_CORE_NB_CORE > 3
GET_STACK(stack_tmp[3]),
#endif
#if CFG_TEE_CORE_NB_CORE > 4
#error "Top of tmp stacks aren't defined for more than 4 CPUS"
#endif
};
static void main_fiq(void);
static void main_tee_entry(struct thread_smc_args *args);
static uint32_t main_default_pm_handler(uint32_t a0, uint32_t a1);
static void init_canaries(void)
{
size_t n;
#define INIT_CANARY(name) \
for (n = 0; n < ARRAY_SIZE(name); n++) { \
uint32_t *start_canary = &GET_START_CANARY(name, n); \
uint32_t *end_canary = &GET_END_CANARY(name, n); \
\
*start_canary = START_CANARY_VALUE; \
*end_canary = END_CANARY_VALUE; \
}
INIT_CANARY(stack_tmp);
INIT_CANARY(stack_abt);
INIT_CANARY(stack_sm);
INIT_CANARY(stack_thread);
}
void check_canaries(void)
{
#ifdef WITH_STACK_CANARIES
size_t n;
#define ASSERT_STACK_CANARIES(name) \
for (n = 0; n < ARRAY_SIZE(name); n++) { \
assert(GET_START_CANARY(name, n) == START_CANARY_VALUE);\
assert(GET_END_CANARY(name, n) == END_CANARY_VALUE); \
} while (0)
ASSERT_STACK_CANARIES(stack_tmp);
ASSERT_STACK_CANARIES(stack_abt);
ASSERT_STACK_CANARIES(stack_sm);
ASSERT_STACK_CANARIES(stack_thread);
#endif /*WITH_STACK_CANARIES*/
}
static const struct thread_handlers handlers = {
.std_smc = main_tee_entry,
.fast_smc = main_tee_entry,
.fiq = main_fiq,
.svc = NULL, /* XXX currently using hardcod svc handler */
.abort = tee_pager_abort_handler,
.cpu_on = main_default_pm_handler,
.cpu_off = main_default_pm_handler,
.cpu_suspend = main_default_pm_handler,
.cpu_resume = main_default_pm_handler,
.system_off = main_default_pm_handler,
.system_reset = main_default_pm_handler,
};
void main_init(uint32_t nsec_entry); /* called from assembly only */
void main_init(uint32_t nsec_entry)
{
struct sm_nsec_ctx *nsec_ctx;
size_t pos = get_core_pos();
/*
* Mask IRQ and FIQ before switch to the thread vector as the
* thread handler requires IRQ and FIQ to be masked while executing
* with the temporary stack. The thread subsystem also asserts that
* IRQ is blocked when using most if its functions.
*/
write_cpsr(read_cpsr() | CPSR_F | CPSR_I);
if (pos == 0) {
size_t n;
/* Initialize canries around the stacks */
init_canaries();
/* Assign the thread stacks */
for (n = 0; n < NUM_THREADS; n++) {
if (!thread_init_stack(n, GET_STACK(stack_thread[n])))
panic();
}
}
if (!thread_init_stack(THREAD_TMP_STACK, GET_STACK(stack_tmp[pos])))
panic();
if (!thread_init_stack(THREAD_ABT_STACK, GET_STACK(stack_abt[pos])))
panic();
thread_init_handlers(&handlers);
/* Initialize secure monitor */
sm_init(GET_STACK(stack_sm[pos]));
nsec_ctx = sm_get_nsec_ctx();
nsec_ctx->mon_lr = nsec_entry;
nsec_ctx->mon_spsr = CPSR_MODE_SVC | CPSR_I;
sm_set_entry_vector(thread_vector_table);
}
static void le_streamer_setup(void){
l2cap_init();
// setup le device db
le_device_db_init();
// setup SM: Display only
sm_init();
// setup ATT server
att_server_init(profile_data, NULL, att_write_callback);
att_server_register_packet_handler(packet_handler);
// setup advertisements
uint16_t adv_int_min = 0x0030;
uint16_t adv_int_max = 0x0030;
uint8_t adv_type = 0;
bd_addr_t null_addr;
memset(null_addr, 0, 6);
gap_advertisements_set_params(adv_int_min, adv_int_max, adv_type, 0, null_addr, 0x07, 0x00);
gap_advertisements_set_data(adv_data_len, (uint8_t*) adv_data);
gap_advertisements_enable(1);
}
void sb700_after_pci_fixup(void) {
#ifdef ENABLE_SATA
printk_info("sata init\n");
sata_init(_pci_make_tag(0, 0x11, 0));
#endif
printk_info("OHCI0-USB1 init\n");
usb_init(_pci_make_tag(0, 0x12, 0));
printk_info("OHCI1-USB1 init\n");
usb_init(_pci_make_tag(0, 0x12, 1));
#if 1
//printk_info("EHCI-USB1 init\n");
//usb_init2(_pci_make_tag(0, 0x12, 2));
printk_info("OHCI0-USB2 init\n");
usb_init(_pci_make_tag(0, 0x13, 0));
printk_info("OHCI1-USB2 init\n");
usb_init(_pci_make_tag(0, 0x13, 1));
//printk_info("EHCI-USB2 init\n");
//usb_init2(_pci_make_tag(0, 0x13, 2));
printk_info("OHCI0-USB3 init\n");
usb_init(_pci_make_tag(0, 0x14, 5));
#endif
printk_info("lpc init\n");
lpc_init(_pci_make_tag(0, 0x14, 3));
printk_info("ide init\n");
ide_init(_pci_make_tag(0, 0x14, 1));
//vga test
printk_info("pci init\n");
pci_init(_pci_make_tag(0, 0x14, 4));
printk_info("sm init\n");
sm_init(_pci_make_tag(0, 0x14, 0));
#ifdef USE_780E_VGA
printk_info("rs780_internal_gfx_init\n");
internal_gfx_pci_dev_init(_pci_make_tag(0,0,0) , _pci_make_tag(1,0x5,0));
#endif
}
int nmragetcvbyte(obj inst, int cv) {
/* direct cv access */
iODDXData data = Data((iODDX)inst);
char SendStream[2048];
int ack;
int start, i;
int value = 0;
int sendsize = 0;
int fastcvget = data->fastcvget;
TraceOp.trc( __FILE__, TRCLEVEL_MONITOR, __LINE__, 9999, "PT: cvget for %d", cv);
/* no special error handling, it's job of the clients */
if (cv<0 || cv>1024) return -1;
if (!sm_initialized) sm_init();
TraceOp.trc( __FILE__, TRCLEVEL_MONITOR, __LINE__, 9999, "PT: enable booster output");
/* enable booster output */
SerialOp.setDTR(data->serial,True);
/**
* NMRA RP 9.2.3 section E
* Power On Cycle - Upon applying power to the track, the Command Station/Programmer must
* transmit at least 20 valid packets to the Digital Decoder to allow it time to stabilize
* internal operation before any Service Mode operations are initiated.
*/
TraceOp.trc( __FILE__, TRCLEVEL_MONITOR, __LINE__, 9999, "PT: power on cycle");
TraceOp.trc( __FILE__, TRCLEVEL_MONITOR, __LINE__, 9999, "PT: start polling...");
start = 1;
do {
SerialOp.flush(data->serial);
ack = scanACK(data->serial);
sendsize = __createCVgetpacket(cv, value, SendStream, start);
if( value % 10 == 0 || !fastcvget )
TraceOp.trc( __FILE__, TRCLEVEL_MONITOR, __LINE__, 9999, "PT: sending %d bytes checking value %d...", sendsize, value);
SerialOp.write(data->serial,SendStream,sendsize);
if (start)
ThreadOp.sleep(240);
else if( !fastcvget )
ThreadOp.sleep(40);
ack = 0;
/* wait for UART: */
ack=waitUARTempty_scanACK(data->serial);
for( i = 0; i < (fastcvget ? 5:120) && ack == 0; i++ ) {
ack = scanACK(data->serial);
/* Some USB2Serial adapter dont give a chance to detect uart empty
* We use waitMM as a fix for this. If detection is impossible,
* first wait argument is used, else second wait argument is used.
* This will cause pauses between values, where output will drain.
* For real Uart, this will not happen.
*ACK is 6-8ms long, poll att least every 6ms*/
if( !fastcvget )
SerialOp.waitMM(data->serial,5000,100);
}
/* init for next loop: */
start = 0;
if(ack==0) {
value++;
}
else {
/* 1 or more Reset Packets if an acknowledgement is detected */
for( i = 0; i < 3; i++ ) {
SerialOp.write(data->serial,resetstream,rs_size);
}
}
TraceOp.trc( __FILE__, TRCLEVEL_DEBUG, __LINE__, 9999, "PT: next value %d...", value);
} while( ack == 0 && value < 256);
TraceOp.trc( __FILE__, TRCLEVEL_MONITOR, __LINE__, 9999, "PT: ack = %d", ack);
TraceOp.trc( __FILE__, TRCLEVEL_MONITOR, __LINE__, 9999, "PT: disable booster output");
/* disable booster output */
SerialOp.setDTR(data->serial,False);
if( ack == 0 )
value = -1;
return value;
}
ret_code_t pm_init(void)
{
ret_code_t err_code;
err_code = pds_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = pdb_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = sm_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = smd_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = gcm_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = gscm_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
err_code = im_init();
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
internal_state_reset();
m_pairing_flag_id = ble_conn_state_user_flag_acquire();
if (m_pairing_flag_id == BLE_CONN_STATE_USER_FLAG_INVALID)
{
return NRF_ERROR_INTERNAL;
}
m_bonding_flag_id = ble_conn_state_user_flag_acquire();
if (m_bonding_flag_id == BLE_CONN_STATE_USER_FLAG_INVALID)
{
return NRF_ERROR_INTERNAL;
}
m_peer_rank_initialized = false;
m_module_initialized = true;
return NRF_SUCCESS;
}
int main(int argc, char* argv[])
{
char *path;
char cmd[256];
int udev = 0;
uev_t timer; /* Bootstrap timer, on timeout call finalize() */
uev_ctx_t loop;
/*
* finit/init/telinit client tool uses /dev/initctl pipe
* for compatibility but initctl client tool uses socket
*/
if (getpid() != 1)
return client(argc, argv);
/*
* Initalize event context.
*/
uev_init(&loop);
ctx = &loop;
/*
* Set PATH and SHELL early to something sane
*/
setenv("PATH", _PATH_STDPATH, 1);
setenv("SHELL", _PATH_BSHELL, 1);
/*
* Mount base file system, kernel is assumed to run devtmpfs for /dev
*/
chdir("/");
umask(0);
mount("none", "/proc", "proc", 0, NULL);
mount("none", "/sys", "sysfs", 0, NULL);
if (fisdir("/proc/bus/usb"))
mount("none", "/proc/bus/usb", "usbfs", 0, NULL);
/*
* Parse kernel command line (debug, rescue, splash, etc.)
* Also calls log_init() to set correct log level
*/
conf_parse_cmdline();
/* Set up canvas */
if (!rescue && !log_is_debug())
screen_init();
/*
* In case of emergency.
*/
emergency_shell();
/*
* Initial setup of signals, ignore all until we're up.
*/
sig_init();
/*
* Load plugins early, finit.conf may contain references to
* features implemented by plugins.
*/
plugin_init(&loop);
/*
* Hello world.
*/
banner();
/*
* Check file filesystems in /etc/fstab
*/
for (int pass = 1; pass < 10 && !rescue; pass++) {
if (fsck(pass))
break;
}
/*
* Initialize .conf system and load static /etc/finit.conf
* Also initializes global_rlimit[] for udevd, below.
*/
conf_init();
/*
* Some non-embedded systems without an initramfs may not have /dev mounted yet
* If they do, check if system has udevadm and perform cleanup from initramfs
*/
if (!fismnt("/dev"))
mount("udev", "/dev", "devtmpfs", MS_RELATIME, "size=10%,nr_inodes=61156,mode=755");
else if (whichp("udevadm"))
run_interactive("udevadm info --cleanup-db", "Cleaning up udev db");
/* Some systems use /dev/pts */
makedir("/dev/pts", 0755);
mount("devpts", "/dev/pts", "devpts", 0, "gid=5,mode=620");
/*
* Some systems rely on us to both create /dev/shm and, to mount
* a tmpfs there. Any system with dbus needs shared memory, so
* mount it, unless its already mounted, but not if listed in
* the /etc/fstab file already.
*/
makedir("/dev/shm", 0755);
if (!fismnt("/dev/shm") && !ismnt("/etc/fstab", "/dev/shm"))
mount("shm", "/dev/shm", "tmpfs", 0, NULL);
/*
* New tmpfs based /run for volatile runtime data
* For details, see http://lwn.net/Articles/436012/
*/
if (fisdir("/run") && !fismnt("/run"))
mount("tmpfs", "/run", "tmpfs", MS_NODEV, "mode=0755,size=10%");
umask(022);
/* Bootstrap conditions, needed for hooks */
cond_init();
/*
* Populate /dev and prepare for runtime events from kernel.
* Prefer udev if mdev is also available on the system.
*/
path = which("udevd");
if (!path)
path = which("/lib/systemd/systemd-udevd");
if (path) {
/* Desktop and server distros usually have a variant of udev */
udev = 1;
/* Register udevd as a monitored service */
snprintf(cmd, sizeof(cmd), "[S12345789] pid:udevd %s -- Device event managing daemon", path);
if (service_register(SVC_TYPE_SERVICE, cmd, global_rlimit, NULL)) {
_pe("Failed registering %s", path);
udev = 0;
} else {
snprintf(cmd, sizeof(cmd), ":1 [S] <svc%s> "
"udevadm trigger -c add -t devices "
"-- Requesting device events", path);
service_register(SVC_TYPE_RUN, cmd, global_rlimit, NULL);
snprintf(cmd, sizeof(cmd), ":2 [S] <svc%s> "
"udevadm trigger -c add -t subsystems "
"-- Requesting subsystem events", path);
service_register(SVC_TYPE_RUN, cmd, global_rlimit, NULL);
}
free(path);
} else {
path = which("mdev");
if (path) {
/* Embedded Linux systems usually have BusyBox mdev */
if (log_is_debug())
touch("/dev/mdev.log");
snprintf(cmd, sizeof(cmd), "%s -s", path);
free(path);
run_interactive(cmd, "Populating device tree");
}
}
/*
* Start built-in watchdog as soon as possible, if enabled
*/
wdogpid = watchdog(argv[0]);
/*
* Mount filesystems
*/
if (!rescue) {
#ifdef REMOUNT_ROOTFS
run("mount -n -o remount,rw /");
#endif
#ifdef SYSROOT
mount(SYSROOT, "/", NULL, MS_MOVE, NULL);
#endif
}
if (!rescue) {
_d("Root FS up, calling hooks ...");
plugin_run_hooks(HOOK_ROOTFS_UP);
umask(0);
if (run_interactive("mount -na", "Mounting filesystems"))
plugin_run_hooks(HOOK_MOUNT_ERROR);
_d("Calling extra mount hook, after mount -a ...");
plugin_run_hooks(HOOK_MOUNT_POST);
run("swapon -ea");
umask(0022);
}
/* Base FS up, enable standard SysV init signals */
sig_setup(&loop);
if (!rescue) {
_d("Base FS up, calling hooks ...");
plugin_run_hooks(HOOK_BASEFS_UP);
}
/*
* Set up inotify watcher for /etc/finit.d and read all .conf
* files to figure out how to bootstrap the system.
*/
conf_monitor(&loop);
/*
* Initalize state machine and start all bootstrap tasks
* NOTE: no network available!
*/
sm_init(&sm);
sm_step(&sm);
/* Debian has this little script to copy generated rules while the system was read-only */
if (udev && fexist("/lib/udev/udev-finish"))
run_interactive("/lib/udev/udev-finish", "Finalizing udev");
/* Start new initctl API responder */
api_init(&loop);
umask(022);
/*
* Wait for all SVC_TYPE_RUNTASK to have completed their work in
* [S], or timeout, before calling finalize()
*/
_d("Starting bootstrap finalize timer ...");
uev_timer_init(&loop, &timer, service_bootstrap_cb, finalize, 1000, 1000);
/*
* Enter main loop to monior /dev/initctl and services
*/
_d("Entering main loop ...");
return uev_run(&loop, 0);
}
