static void standard_funcs_giant_taken_test( size_t set_size,
cpu_set_t *cpu_set, SMP_barrier_State *bs )
{
if ( rtems_get_current_processor() == 0)
_Thread_Disable_dispatch();
_SMP_barrier_Wait( &ctx.barrier, bs, rtems_get_processor_count() );
cache_manager_smp_functions( set_size, cpu_set );
if ( rtems_get_current_processor() == 0)
_Thread_Enable_dispatch();
}
static void test_func_test( size_t set_size, cpu_set_t *cpu_set,
SMP_barrier_State *bs )
{
ctx.count[rtems_get_current_processor()] = 0;
_SMP_barrier_Wait( &ctx.barrier, bs, rtems_get_processor_count() );
_SMP_Multicast_action( set_size, cpu_set, test_cache_message, &ctx );
_SMP_barrier_Wait( &ctx.barrier, bs, rtems_get_processor_count() );
rtems_test_assert( ctx.count[rtems_get_current_processor()] ==
rtems_get_processor_count() );
}
static void *thread_b(void *arg)
{
test_context *ctx;
rtems_id scheduler_b_id;
rtems_status_code sc;
rtems_task_priority prio;
int prio_ceiling;
int eno;
ctx = arg;
rtems_test_assert(rtems_get_current_processor() == 0);
sc = rtems_scheduler_ident(SCHED_B, &scheduler_b_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_priority(pthread_self(), RTEMS_CURRENT_PRIORITY, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(pthread_self(), scheduler_b_id, prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(rtems_get_current_processor() == 1);
eno = pthread_mutex_init(&ctx->mtx_b, &ctx->mtx_attr);
rtems_test_assert(eno == 0);
eno = pthread_mutex_getprioceiling(&ctx->mtx_b, &prio_ceiling);
rtems_test_assert(eno == 0);
rtems_test_assert(prio_ceiling == 254);
eno = pthread_mutex_lock(&ctx->mtx_b);
rtems_test_assert(eno == 0);
eno = pthread_mutex_unlock(&ctx->mtx_b);
rtems_test_assert(eno == 0);
eno = pthread_mutex_destroy(&ctx->mtx_b);
rtems_test_assert(eno == 0);
eno = pthread_mutex_getprioceiling(&ctx->mtx_a, &prio_ceiling);
rtems_test_assert(eno == 0);
rtems_test_assert(prio_ceiling == 126);
eno = pthread_mutex_lock(&ctx->mtx_a);
rtems_test_assert(eno == EINVAL);
return ctx;
}
static void delay_clock_tick(test_context *ctx)
{
rtems_interrupt_level level;
const Per_CPU_Control *cpu_self = _Per_CPU_Get_by_index(0);
const Per_CPU_Control *cpu_other = _Per_CPU_Get_by_index(1);
uint64_t ticks;
rtems_test_assert(rtems_get_current_processor() == 0);
rtems_test_spin_until_next_tick();
ticks = cpu_self->Watchdog.ticks;
rtems_interrupt_local_disable(level);
/* (A) */
wait(ctx, &ctx->delay_barrier_state);
/* (B) */
wait(ctx, &ctx->delay_barrier_state);
rtems_test_assert(cpu_self->Watchdog.ticks == ticks);
rtems_test_assert(cpu_other->Watchdog.ticks == ticks + 1);
rtems_interrupt_local_enable(level);
rtems_test_assert(cpu_self->Watchdog.ticks == ticks + 1);
rtems_test_assert(cpu_other->Watchdog.ticks == ticks + 1);
/* (C) */
wait(ctx, &ctx->delay_barrier_state);
}
rtems_task Test_task(
rtems_task_argument task_index
)
{
uint32_t cpu_num;
char name[5];
char *p;
/* Get the task name */
p = rtems_object_get_name( RTEMS_SELF, 5, name );
rtems_test_assert( p != NULL );
/* Get the CPU Number */
cpu_num = rtems_get_current_processor();
/* Print that the task is up and running. */
Loop();
locked_printf(" CPU %" PRIu32 " running Task %s\n", cpu_num, name);
/* Set the flag that the task is up and running */
TaskRan[cpu_num] = true;
/* Drop into a loop which will keep this task on
* running on the cpu.
*/
while(1);
}
rtems_task Test_task(
rtems_task_argument argument
)
{
locked_printf( "Shut down from CPU %" PRIu32 "\n", rtems_get_current_processor() );
success();
}
static void task(rtems_task_argument arg)
{
rtems_status_code sc;
(void) arg;
rtems_test_assert(rtems_get_current_processor() == 1);
rtems_test_assert(sched_get_priority_min(SCHED_RR) == 1);
rtems_test_assert(sched_get_priority_max(SCHED_RR) == INT_MAX - 1);
sc = rtems_semaphore_obtain(cmtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_NOT_DEFINED);
sc = rtems_event_transient_send(main_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_obtain(imtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_release(imtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_send(main_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
while (1) {
/* Do nothing */
}
}
static void fatal_extension(
rtems_fatal_source source,
bool is_internal,
rtems_fatal_code code
)
{
if (
source == RTEMS_FATAL_SOURCE_APPLICATION
|| source == RTEMS_FATAL_SOURCE_SMP
) {
uint32_t self = rtems_get_current_processor();
SMP_barrier_State state = SMP_BARRIER_STATE_INITIALIZER;
assert(!is_internal);
if (self == main_cpu) {
assert(source == RTEMS_FATAL_SOURCE_SMP);
assert(code == SMP_FATAL_SHUTDOWN_RESPONSE);
} else {
assert(source == RTEMS_FATAL_SOURCE_APPLICATION);
assert(code == 0xdeadbeef);
}
_SMP_barrier_Wait(&fatal_barrier, &state, CPU_COUNT);
if (self == 0) {
rtems_test_endk();
}
_SMP_barrier_Wait(&fatal_barrier, &state, CPU_COUNT);
}
}
static void runner(rtems_task_argument self)
{
test_context *ctx = &ctx_instance;
rtems_task_argument next = (self + 1) % RUNNER_COUNT;
rtems_id next_runner = ctx->runner_ids[next];
test_counters *counters = &ctx->counters[self];
test_counters *next_counters = &ctx->counters[next];
while (true) {
uint32_t current_cpu = rtems_get_current_processor();
++counters->cycles_per_cpu[current_cpu].counter;
if (ctx->token == self) {
uint32_t other_cpu = (current_cpu + 1) % CPU_COUNT;
uint32_t snapshot;
++counters->tokens_per_cpu[current_cpu].counter;
change_prio(next_runner, PRIO_HIGH);
snapshot = next_counters->cycles_per_cpu[other_cpu].counter;
while (next_counters->cycles_per_cpu[other_cpu].counter == snapshot) {
/* Wait for other thread to resume execution */
}
ctx->token = next;
change_prio(RTEMS_SELF, PRIO_NORMAL);
}
}
}
rtems_task Test_task(
rtems_task_argument unused
)
{
rtems_id tid;
rtems_time_of_day time;
uint32_t task_index;
rtems_status_code status;
uint32_t cpu_num;
char name[5];
char *p;
/* Get the task name */
p = rtems_object_get_name( RTEMS_SELF, 5, name );
rtems_test_assert( p != NULL );
status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &tid );
task_index = task_number( tid );
for ( ; ; ) {
/* Get the CPU Number */
cpu_num = rtems_get_current_processor();
status = rtems_clock_get_tod( &time );
if ( time.second >= 35 ) {
TEST_END();
rtems_test_exit( 0 );
}
PrintTaskInfo( p, &time );
status = rtems_task_wake_after(
task_index * 5 * rtems_clock_get_ticks_per_second() );
}
}
static void Init(rtems_task_argument arg)
{
uint32_t self = rtems_get_current_processor();
uint32_t cpu_count = rtems_get_processor_count();
rtems_test_begink();
main_cpu = self;
if (cpu_count >= CPU_COUNT) {
rtems_status_code sc;
rtems_id id;
sc = rtems_task_create(
rtems_build_name( 'W', 'A', 'I', 'T' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(id, acquire_giant_and_fatal_task, 0);
assert(sc == RTEMS_SUCCESSFUL);
wait_for_giant();
} else {
rtems_test_endk();
exit(0);
}
}
static void timer_task(rtems_task_argument arg)
{
test_context *ctx = (test_context *) arg;
rtems_status_code sc;
rtems_id timer_id;
rtems_test_assert(rtems_get_current_processor() == 1);
sc = rtems_timer_create(SCHEDULER_B, &timer_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/* (A) */
wait(ctx, &ctx->timer_barrier_state);
sc = rtems_timer_fire_after(timer_id, 1, timer_isr, ctx);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_wake_after(1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_timer_delete(timer_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/* (C) */
wait(ctx, &ctx->timer_barrier_state);
while (true) {
/* Wait for deletion */
}
}
static void fatal_extension(
rtems_fatal_source source,
bool is_internal,
rtems_fatal_code code
)
{
if (
source == RTEMS_FATAL_SOURCE_APPLICATION
|| source == RTEMS_FATAL_SOURCE_SMP
) {
uint32_t self = rtems_get_current_processor();
assert(!is_internal);
if (self == main_cpu) {
uint32_t cpu;
assert(source == RTEMS_FATAL_SOURCE_APPLICATION);
assert(code == 0xdeadbeef);
for (cpu = 0; cpu < MAX_CPUS; ++cpu) {
const Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( cpu );
Per_CPU_State state = per_cpu->state;
assert(state == PER_CPU_STATE_SHUTDOWN);
}
rtems_test_endk();
} else {
assert(source == RTEMS_FATAL_SOURCE_SMP);
assert(code == SMP_FATAL_SHUTDOWN);
}
}
}
static void test_func_isrdisabled_test( size_t set_size, cpu_set_t *cpu_set,
SMP_barrier_State *bs )
{
ISR_Level isr_level;
ctx.count[rtems_get_current_processor()] = 0;
_ISR_Disable_without_giant( isr_level );
_SMP_barrier_Wait( &ctx.barrier, bs, rtems_get_processor_count() );
_SMP_Multicast_action( set_size, cpu_set, test_cache_message, &ctx );
_ISR_Enable_without_giant( isr_level );
_SMP_barrier_Wait( &ctx.barrier, bs, rtems_get_processor_count() );
rtems_test_assert( ctx.count[rtems_get_current_processor()] ==
rtems_get_processor_count() );
}
static void set_init_task(void)
{
while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL );
/* Set Init task data */
task_data[0].ran = true;
task_data[0].actual_cpu = rtems_get_current_processor();
rtems_semaphore_release(task_sem);
}
static void load_task(rtems_task_argument arg)
{
volatile int *load_data = (volatile int *) arg;
size_t n = data_size;
size_t clsz = cache_line_size;
int j = (int) rtems_get_current_processor();
while (true) {
j = dirty_data_cache(load_data, n, clsz, j);
}
}
static void test_func_giant_taken_test( size_t set_size, cpu_set_t *cpu_set,
SMP_barrier_State *bs )
{
ctx.count[rtems_get_current_processor()] = 0;
if ( rtems_get_current_processor() == 0)
_Thread_Disable_dispatch();
_SMP_barrier_Wait( &ctx.barrier, bs, rtems_get_processor_count() );
_SMP_Multicast_action( set_size, cpu_set, test_cache_message, &ctx );
_SMP_barrier_Wait( &ctx.barrier, bs, rtems_get_processor_count() );
rtems_test_assert( ctx.count[rtems_get_current_processor()] ==
rtems_get_processor_count() );
if ( rtems_get_current_processor() == 0)
_Thread_Enable_dispatch();
}
static void test_task(rtems_task_argument arg)
{
test_context *ctx = &test_instance;
tests();
ctx->cpu_index[arg] = rtems_get_current_processor();
barrier_wait(ctx);
rtems_task_suspend(RTEMS_SELF);
rtems_test_assert(0);
}
static void task(rtems_task_argument arg)
{
rtems_status_code sc;
while (true) {
sc = rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0);
if (sc == RTEMS_SUCCESSFUL) {
task_data[arg].ran = true;
task_data[arg].actual_cpu = rtems_get_current_processor();
rtems_semaphore_release(task_sem);
}
}
}
static void task(rtems_task_argument arg)
{
rtems_status_code sc;
(void) arg;
rtems_test_assert(rtems_get_current_processor() == 1);
sc = rtems_event_transient_send(main_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
while (1) {
/* Do nothing */
}
}
static void test(test_context *ctx)
{
uint32_t cpu_count;
int prio_ceiling;
int eno;
cpu_count = rtems_get_processor_count();
rtems_test_assert(rtems_get_current_processor() == 0);
eno = pthread_mutexattr_init(&ctx->mtx_attr);
rtems_test_assert(eno == 0);
eno = pthread_mutexattr_setprotocol(&ctx->mtx_attr, PTHREAD_PRIO_PROTECT);
rtems_test_assert(eno == 0);
eno = pthread_mutex_init(&ctx->mtx_a, &ctx->mtx_attr);
rtems_test_assert(eno == 0);
eno = pthread_mutex_getprioceiling(&ctx->mtx_a, &prio_ceiling);
rtems_test_assert(eno == 0);
rtems_test_assert(prio_ceiling == 126);
eno = pthread_mutex_lock(&ctx->mtx_a);
rtems_test_assert(eno == 0);
eno = pthread_mutex_unlock(&ctx->mtx_a);
rtems_test_assert(eno == 0);
if (cpu_count > 1) {
void *exit_code;
eno = pthread_create(&ctx->thread_b, NULL, thread_b, ctx);
rtems_test_assert(eno == 0);
exit_code = NULL;
eno = pthread_join(ctx->thread_b, &exit_code);
rtems_test_assert(eno == 0);
rtems_test_assert(exit_code == ctx);
}
eno = pthread_mutex_destroy(&ctx->mtx_a);
rtems_test_assert(eno == 0);
eno = pthread_mutexattr_destroy(&ctx->mtx_attr);
rtems_test_assert(eno == 0);
}
rtems_task Init(
rtems_task_argument argument
)
{
uint32_t i;
char ch;
uint32_t cpu_num;
rtems_id id;
rtems_status_code status;
TEST_BEGIN();
locked_print_initialize();
for ( killtime=0; killtime<1000000; killtime++ )
;
for ( i=0; i<rtems_get_processor_count() -1; i++ ) {
ch = '1' + i;
status = rtems_task_create(
rtems_build_name( 'T', 'A', ch, ' ' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "task create" );
cpu_num = rtems_get_current_processor();
locked_printf(" CPU %" PRIu32 " start task TA%c\n", cpu_num, ch);
status = rtems_task_start( id, Test_task, i+1 );
directive_failed( status, "task start" );
}
locked_printf(" kill 10 clock ticks\n" );
while ( rtems_clock_get_ticks_since_boot() < 10 )
;
rtems_cpu_usage_report();
TEST_END();
rtems_test_exit(0);
}
static void test_send_message_while_processing_a_message(
test_context *ctx
)
{
uint32_t cpu_count = rtems_get_processor_count();
uint32_t cpu_index_self = rtems_get_current_processor();
uint32_t cpu_index;
SMP_barrier_State *bs = &ctx->main_barrier_state;
_SMP_Set_test_message_handler(barrier_handler);
for (cpu_index = 0; cpu_index < cpu_count; ++cpu_index) {
if (cpu_index != cpu_index_self) {
_SMP_Send_message(cpu_index, SMP_MESSAGE_TEST);
/* (A) */
barrier(ctx, bs);
rtems_test_assert(ctx->counters[cpu_index].value == 1);
_SMP_Send_message(cpu_index, SMP_MESSAGE_TEST);
/* (B) */
barrier(ctx, bs);
rtems_test_assert(ctx->counters[cpu_index].value == 1);
/* (C) */
barrier(ctx, bs);
/* (A) */
barrier(ctx, bs);
rtems_test_assert(ctx->counters[cpu_index].value == 2);
/* (B) */
barrier(ctx, bs);
/* (C) */
barrier(ctx, bs);
ctx->counters[cpu_index].value = 0;
}
}
}
static void test_send_message_flood(
test_context *ctx
)
{
uint32_t cpu_count = rtems_get_processor_count();
uint32_t cpu_index_self = rtems_get_current_processor();
uint32_t cpu_index;
_SMP_Set_test_message_handler(counter_handler);
for (cpu_index = 0; cpu_index < cpu_count; ++cpu_index) {
uint32_t i;
/* Wait 1us so that all outstanding messages have been processed */
rtems_counter_delay_nanoseconds(1000000);
for (i = 0; i < cpu_count; ++i) {
if (i != cpu_index) {
ctx->copy_counters[i] = ctx->counters[i].value;
}
}
for (i = 0; i < 100000; ++i) {
_SMP_Send_message(cpu_index, SMP_MESSAGE_TEST);
}
for (i = 0; i < cpu_count; ++i) {
if (i != cpu_index) {
rtems_test_assert(ctx->copy_counters[i] == ctx->counters[i].value);
}
}
}
for (cpu_index = 0; cpu_index < cpu_count; ++cpu_index) {
printf(
"inter-processor interrupts for processor %"
PRIu32 "%s: %" PRIu32 "\n",
cpu_index,
cpu_index == cpu_index_self ? " (main)" : "",
ctx->counters[cpu_index].value
);
}
}
static void test(void)
{
test_context *ctx = &ctx_instance;
rtems_status_code sc;
rtems_mode mode;
ctx->consumer = rtems_task_self();
ctx->consumer_processor = rtems_get_current_processor();
sc = rtems_signal_catch(signal_handler, RTEMS_DEFAULT_MODES);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_create(
rtems_build_name('P', 'R', 'O', 'D'),
RTEMS_MINIMUM_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&ctx->producer
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(ctx->producer, producer, (rtems_task_argument) ctx);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
check_consumer_processor(ctx);
wait_for_state(ctx, SIG_0_SENT);
change_state(ctx, SIG_0_ENABLE);
sc = rtems_task_mode(RTEMS_ASR, RTEMS_ASR_MASK, &mode);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
wait_for_state(ctx, SIG_0_PROCESSED);
check_consumer_processor(ctx);
change_state(ctx, SIG_1_READY);
wait_for_state(ctx, SIG_1_PROCESSED);
check_consumer_processor(ctx);
}
static void verify_tasks(void)
{
int i;
printf("Verify Tasks Ran\n");
while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL );
/* Set Init task data */
task_data[0].ran = true;
task_data[0].actual_cpu = rtems_get_current_processor();
/* Verify all tasks */
for (i = 0; i < NUM_CPUS; i++) {
if (i==0)
printf("Init(%d): ran=%d expected=%d actual=%d\n",
task_data[i].priority,
task_data[i].ran,
task_data[i].expected_cpu,
task_data[i].actual_cpu
);
else
printf( "TA0%d(%d): ran=%d expected=%d actual=%d\n",
i,
task_data[i].priority,
task_data[i].ran,
task_data[i].expected_cpu,
task_data[i].actual_cpu
);
/* Abort test if values are not as expected */
if ( task_data[i].expected_cpu == -1 )
rtems_test_assert( task_data[i].ran == false );
else {
rtems_test_assert( task_data[i].ran == true );
rtems_test_assert( task_data[i].expected_cpu == task_data[i].actual_cpu );
}
}
rtems_semaphore_release(task_sem);
}
static rtems_status_code test_driver_init(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
uint32_t self = rtems_get_current_processor();
uint32_t cpu_count = rtems_get_processor_count();
uint32_t cpu;
rtems_test_begink();
assert(rtems_configuration_get_maximum_processors() == MAX_CPUS);
main_cpu = self;
for (cpu = 0; cpu < MAX_CPUS; ++cpu) {
const Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( cpu );
Per_CPU_State state = per_cpu->state;
if (cpu == self) {
assert(state == PER_CPU_STATE_INITIAL);
} else if (cpu < cpu_count) {
assert(
state == PER_CPU_STATE_INITIAL
|| state == PER_CPU_STATE_READY_TO_START_MULTITASKING
);
} else {
assert(state == PER_CPU_STATE_INITIAL);
}
}
if (cpu_count > 1) {
rtems_fatal(RTEMS_FATAL_SOURCE_APPLICATION, 0xdeadbeef);
} else {
rtems_test_endk();
exit(0);
}
return RTEMS_SUCCESSFUL;
}
static void producer(rtems_task_argument arg)
{
test_context *ctx = (test_context *) arg;
ctx->producer_processor = rtems_get_current_processor();
rtems_test_assert(ctx->consumer_processor != ctx->producer_processor);
wait_for_state(ctx, SIG_0_READY);
signal_send(ctx, SIG_0_SENT);
check_producer_processor(ctx);
wait_for_state(ctx, SIG_1_READY);
signal_send(ctx, SIG_1_SENT);
check_producer_processor(ctx);
rtems_task_suspend(RTEMS_SELF);
rtems_test_assert(0);
}
rtems_task Init(
rtems_task_argument argument
)
{
uint32_t i;
char ch;
uint32_t cpu_num;
rtems_id id;
rtems_status_code status;
locked_print_initialize();
rtems_test_begin();
if ( rtems_get_processor_count() == 1 ) {
success();
}
for ( i=0; i<rtems_get_processor_count() ; i++ ) {
ch = '1' + i;
status = rtems_task_create(
rtems_build_name( 'T', 'A', ch, ' ' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "task create" );
cpu_num = rtems_get_current_processor();
locked_printf(" CPU %" PRIu32 " start task TA%c\n", cpu_num, ch);
status = rtems_task_start( id, Test_task, i+1 );
directive_failed( status, "task start" );
}
while (1)
;
}
void bsp_reset(void)
{
uint32_t self_cpu = rtems_get_current_processor();
if (self_cpu == 0) {
volatile struct irqmp_regs *irqmp = LEON3_IrqCtrl_Regs;
if (irqmp != NULL) {
/*
* Value was choosen to get something in the magnitude of 1ms on a 200MHz
* processor.
*/
uint32_t max_wait = 1234567;
uint32_t cpu_count = rtems_get_processor_count();
uint32_t halt_mask = 0;
uint32_t i;
for (i = 0; i < cpu_count; ++i) {
if (i != self_cpu) {
halt_mask |= UINT32_C(1) << i;
}
}
/* Wait some time for secondary processors to halt */
i = 0;
while ((irqmp->mpstat & halt_mask) != halt_mask && i < max_wait) {
++i;
}
}
__asm__ volatile (
"mov 1, %g1\n"
"ta 0\n"
"nop"
);
}
leon3_power_down_loop();
}