3000995c <_CORE_mutex_Seize_interrupt_trylock>:
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000995c: e59f3120 ldr r3, [pc, #288] ; 30009a84 <_CORE_mutex_Seize_interrupt_trylock+0x128>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
30009960: e3a02000 mov r2, #0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
30009964: e5933000 ldr r3, [r3]
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
30009968: e52de004 push {lr} ; (str lr, [sp, #-4]!)
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000996c: e5832034 str r2, [r3, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
30009970: e590c050 ldr ip, [r0, #80] ; 0x50 30009974: e15c0002 cmp ip, r2
30009978: 0a00002c beq 30009a30 <_CORE_mutex_Seize_interrupt_trylock+0xd4>
the_mutex->lock = CORE_MUTEX_LOCKED;
3000997c: e5802050 str r2, [r0, #80] ; 0x50
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
30009980: e593c008 ldr ip, [r3, #8]
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
30009984: e5902048 ldr r2, [r0, #72] ; 0x48
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
30009988: e580c060 str ip, [r0, #96] ; 0x60
the_mutex->nest_count = 1;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000998c: e3520002 cmp r2, #2
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
30009990: e3a0c001 mov ip, #1 30009994: e580c054 str ip, [r0, #84] ; 0x54
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
30009998: e580305c str r3, [r0, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000999c: 0a000001 beq 300099a8 <_CORE_mutex_Seize_interrupt_trylock+0x4c>
300099a0: e3520003 cmp r2, #3
300099a4: 1a000004 bne 300099bc <_CORE_mutex_Seize_interrupt_trylock+0x60>
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
300099a8: e593c01c ldr ip, [r3, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
300099ac: e3520003 cmp r2, #3
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
300099b0: e28c2001 add r2, ip, #1 300099b4: e583201c str r2, [r3, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
300099b8: 0a000000 beq 300099c0 <_CORE_mutex_Seize_interrupt_trylock+0x64>
_ISR_Enable( *level_p );
300099bc: ea00002a b 30009a6c <_CORE_mutex_Seize_interrupt_trylock+0x110>
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
300099c0: e590204c ldr r2, [r0, #76] ; 0x4c
current = executing->current_priority;
300099c4: e593c014 ldr ip, [r3, #20]
if ( current == ceiling ) {
300099c8: e15c0002 cmp ip, r2
300099cc: 1a000000 bne 300099d4 <_CORE_mutex_Seize_interrupt_trylock+0x78>
_ISR_Enable( *level_p );
300099d0: ea000025 b 30009a6c <_CORE_mutex_Seize_interrupt_trylock+0x110>
return 0;
}
if ( current > ceiling ) {
300099d4: 9a00000b bls 30009a08 <_CORE_mutex_Seize_interrupt_trylock+0xac>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
300099d8: e59f30a8 ldr r3, [pc, #168] ; 30009a88 <_CORE_mutex_Seize_interrupt_trylock+0x12c> 300099dc: e5932000 ldr r2, [r3] 300099e0: e2822001 add r2, r2, #1 300099e4: e5832000 str r2, [r3] 300099e8: e5913000 ldr r3, [r1] 300099ec: e129f003 msr CPSR_fc, r3
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
300099f0: e3a02000 mov r2, #0 300099f4: e590104c ldr r1, [r0, #76] ; 0x4c 300099f8: e590005c ldr r0, [r0, #92] ; 0x5c 300099fc: ebfff28b bl 30006430 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
30009a00: ebfff3eb bl 300069b4 <_Thread_Enable_dispatch> 30009a04: ea00001a b 30009a74 <_CORE_mutex_Seize_interrupt_trylock+0x118>
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
30009a08: e3a02006 mov r2, #6 30009a0c: e5832034 str r2, [r3, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
the_mutex->nest_count = 0; /* undo locking above */
30009a10: e3a02000 mov r2, #0 30009a14: e5802054 str r2, [r0, #84] ; 0x54
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
the_mutex->lock = CORE_MUTEX_UNLOCKED;
30009a18: e2822001 add r2, r2, #1 30009a1c: e5802050 str r2, [r0, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
executing->resource_count--; /* undo locking above */
30009a20: e593201c ldr r2, [r3, #28] 30009a24: e2422001 sub r2, r2, #1 30009a28: e583201c str r2, [r3, #28]
_ISR_Enable( *level_p );
30009a2c: ea00000e b 30009a6c <_CORE_mutex_Seize_interrupt_trylock+0x110>
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
30009a30: e590205c ldr r2, [r0, #92] ; 0x5c 30009a34: e1520003 cmp r2, r3
30009a38: 1a00000f bne 30009a7c <_CORE_mutex_Seize_interrupt_trylock+0x120>
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
30009a3c: e5903040 ldr r3, [r0, #64] ; 0x40 30009a40: e3530000 cmp r3, #0
30009a44: 0a000002 beq 30009a54 <_CORE_mutex_Seize_interrupt_trylock+0xf8>
30009a48: e3530001 cmp r3, #1
30009a4c: 1a00000a bne 30009a7c <_CORE_mutex_Seize_interrupt_trylock+0x120>
30009a50: ea000003 b 30009a64 <_CORE_mutex_Seize_interrupt_trylock+0x108><== NOT EXECUTED
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
30009a54: e5903054 ldr r3, [r0, #84] ; 0x54 30009a58: e2833001 add r3, r3, #1 30009a5c: e5803054 str r3, [r0, #84] ; 0x54
_ISR_Enable( *level_p );
30009a60: ea000001 b 30009a6c <_CORE_mutex_Seize_interrupt_trylock+0x110>
return 0;
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
30009a64: e3a03002 mov r3, #2 <== NOT EXECUTED 30009a68: e5823034 str r3, [r2, #52] ; 0x34 <== NOT EXECUTED
30009a6c: e5913000 ldr r3, [r1]
30009a70: e129f003 msr CPSR_fc, r3
30009a74: e3a00000 mov r0, #0
30009a78: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30009a7c: e3a00001 mov r0, #1
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
30009a80: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30009a84: 30018f60 .word 0x30018f60
30009a88: 30018eac .word 0x30018eac
30006f10 <_Thread_queue_Enqueue_priority>:
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
30006f10: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
30006f14: e5913014 ldr r3, [r1, #20]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
30006f18: e281503c add r5, r1, #60 ; 0x3c 30006f1c: e5815038 str r5, [r1, #56] ; 0x38
the_chain->permanent_null = NULL;
30006f20: e3a05000 mov r5, #0
the_chain->last = _Chain_Head(the_chain);
30006f24: e281c038 add ip, r1, #56 ; 0x38
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
30006f28: e3130020 tst r3, #32
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
30006f2c: e1a04323 lsr r4, r3, #6
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
30006f30: e581503c str r5, [r1, #60] ; 0x3c 30006f34: e285500c add r5, r5, #12
the_chain->last = _Chain_Head(the_chain);
30006f38: e581c040 str ip, [r1, #64] ; 0x40
block_state = the_thread_queue->state;
30006f3c: e5907038 ldr r7, [r0, #56] ; 0x38
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
30006f40: e02c0495 mla ip, r5, r4, r0
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
30006f44: 159f8154 ldrne r8, [pc, #340] ; 300070a0 <_Thread_queue_Enqueue_priority+0x190>
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
30006f48: 1a000023 bne 30006fdc <_Thread_queue_Enqueue_priority+0xcc>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
30006f4c: e28c8004 add r8, ip, #4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30006f50: e10f5000 mrs r5, CPSR 30006f54: e3854080 orr r4, r5, #128 ; 0x80 30006f58: e129f004 msr CPSR_fc, r4
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
30006f5c: e3e06000 mvn r6, #0 30006f60: e59c4000 ldr r4, [ip]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
30006f64: ea00000b b 30006f98 <_Thread_queue_Enqueue_priority+0x88>
search_priority = search_thread->current_priority;
30006f68: e5946014 ldr r6, [r4, #20]
if ( priority <= search_priority )
30006f6c: e1530006 cmp r3, r6
30006f70: 9a00000a bls 30006fa0 <_Thread_queue_Enqueue_priority+0x90>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
30006f74: e10fa000 mrs sl, CPSR 30006f78: e129f005 msr CPSR_fc, r5 30006f7c: e129f00a msr CPSR_fc, sl
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
30006f80: e594a010 ldr sl, [r4, #16] 30006f84: e117000a tst r7, sl
30006f88: 1a000001 bne 30006f94 <_Thread_queue_Enqueue_priority+0x84>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30006f8c: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED 30006f90: eaffffee b 30006f50 <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
30006f94: e5944000 ldr r4, [r4]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
30006f98: e1540008 cmp r4, r8
30006f9c: 1afffff1 bne 30006f68 <_Thread_queue_Enqueue_priority+0x58>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
30006fa0: e5907030 ldr r7, [r0, #48] ; 0x30
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
30006fa4: e1a0c005 mov ip, r5
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
30006fa8: e3570001 cmp r7, #1
30006fac: 1a000038 bne 30007094 <_Thread_queue_Enqueue_priority+0x184>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
30006fb0: e1530006 cmp r3, r6
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
30006fb4: e3a03000 mov r3, #0 30006fb8: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
30006fbc: 0a00002a beq 3000706c <_Thread_queue_Enqueue_priority+0x15c>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
30006fc0: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
30006fc4: e5814000 str r4, [r1]
the_node->previous = previous_node;
30006fc8: e5813004 str r3, [r1, #4]
previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
30006fcc: e5810044 str r0, [r1, #68] ; 0x44
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
previous_node->next = the_node;
30006fd0: e5831000 str r1, [r3]
search_node->previous = the_node;
30006fd4: e5841004 str r1, [r4, #4]
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level );
30006fd8: ea000021 b 30007064 <_Thread_queue_Enqueue_priority+0x154>
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
30006fdc: e5d86000 ldrb r6, [r8] 30006fe0: e2866001 add r6, r6, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30006fe4: e10f5000 mrs r5, CPSR 30006fe8: e3854080 orr r4, r5, #128 ; 0x80 30006fec: e129f004 msr CPSR_fc, r4
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
30006ff0: e59c4008 ldr r4, [ip, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
30006ff4: ea00000b b 30007028 <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
30006ff8: e5946014 ldr r6, [r4, #20]
if ( priority >= search_priority )
30006ffc: e1530006 cmp r3, r6
30007000: 2a00000a bcs 30007030 <_Thread_queue_Enqueue_priority+0x120>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
30007004: e10fa000 mrs sl, CPSR 30007008: e129f005 msr CPSR_fc, r5 3000700c: e129f00a msr CPSR_fc, sl
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
30007010: e594a010 ldr sl, [r4, #16] 30007014: e117000a tst r7, sl
30007018: 1a000001 bne 30007024 <_Thread_queue_Enqueue_priority+0x114>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3000701c: e129f005 msr CPSR_fc, r5 30007020: eaffffed b 30006fdc <_Thread_queue_Enqueue_priority+0xcc>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
30007024: e5944004 ldr r4, [r4, #4]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
30007028: e154000c cmp r4, ip
3000702c: 1afffff1 bne 30006ff8 <_Thread_queue_Enqueue_priority+0xe8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
30007030: e5907030 ldr r7, [r0, #48] ; 0x30
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
30007034: e1a0c005 mov ip, r5
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
30007038: e3570001 cmp r7, #1
3000703c: 1a000014 bne 30007094 <_Thread_queue_Enqueue_priority+0x184>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
30007040: e1530006 cmp r3, r6
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
30007044: e3a03000 mov r3, #0 30007048: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
3000704c: 0a000006 beq 3000706c <_Thread_queue_Enqueue_priority+0x15c>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
30007050: e5943000 ldr r3, [r4]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
30007054: e8810018 stm r1, {r3, r4}
search_node->next = the_node; next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
30007058: e5810044 str r0, [r1, #68] ; 0x44
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
3000705c: e5841000 str r1, [r4]
next_node->previous = the_node;
30007060: e5831004 str r1, [r3, #4] 30007064: e129f005 msr CPSR_fc, r5 30007068: ea000007 b 3000708c <_Thread_queue_Enqueue_priority+0x17c> 3000706c: e284403c add r4, r4, #60 ; 0x3c
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
30007070: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
30007074: e5814000 str r4, [r1]
the_node->previous = previous_node;
30007078: e5813004 str r3, [r1, #4]
previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
3000707c: e5810044 str r0, [r1, #68] ; 0x44
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
previous_node->next = the_node;
30007080: e5831000 str r1, [r3]
search_node->previous = the_node;
30007084: e5841004 str r1, [r4, #4] 30007088: e129f00c msr CPSR_fc, ip 3000708c: e3a00001 mov r0, #1
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30007090: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
* the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state;
30007094: e5900030 ldr r0, [r0, #48] ; 0x30
* For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level;
30007098: e582c000 str ip, [r2]
return the_thread_queue->sync_state; }
3000709c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
300070a0: 300182b4 .word 0x300182b4
30014aa0 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
30014aa0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30014aa4: e24dd020 sub sp, sp, #32
30014aa8: e28d3014 add r3, sp, #20
30014aac: e28d5008 add r5, sp, #8
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
30014ab0: e3a09000 mov r9, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
30014ab4: e283a004 add sl, r3, #4 30014ab8: e2858004 add r8, r5, #4
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
30014abc: e58d301c str r3, [sp, #28]
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
30014ac0: e2802008 add r2, r0, #8
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
30014ac4: e2803040 add r3, r0, #64 ; 0x40
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
30014ac8: e1a04000 mov r4, r0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
30014acc: e58da014 str sl, [sp, #20]
the_chain->permanent_null = NULL;
30014ad0: e58d9018 str r9, [sp, #24]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
30014ad4: e58d8008 str r8, [sp, #8]
the_chain->permanent_null = NULL;
30014ad8: e58d900c str r9, [sp, #12]
the_chain->last = _Chain_Head(the_chain);
30014adc: e58d5010 str r5, [sp, #16]
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
30014ae0: e280b030 add fp, r0, #48 ; 0x30
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
30014ae4: e2807068 add r7, r0, #104 ; 0x68
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
30014ae8: e58d2004 str r2, [sp, #4]
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
30014aec: e58d3000 str r3, [sp]
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
30014af0: e28d2014 add r2, sp, #20 30014af4: e5842078 str r2, [r4, #120] ; 0x78
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
30014af8: e59f2168 ldr r2, [pc, #360] ; 30014c68 <_Timer_server_Body+0x1c8>
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
30014afc: e1a0000b mov r0, fp
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
30014b00: e5923000 ldr r3, [r2]
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
30014b04: e594103c ldr r1, [r4, #60] ; 0x3c
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
30014b08: e1a02005 mov r2, r5
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
30014b0c: e584303c str r3, [r4, #60] ; 0x3c
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
30014b10: e0611003 rsb r1, r1, r3 30014b14: eb001000 bl 30018b1c <_Watchdog_Adjust_to_chain>
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
30014b18: e59f314c ldr r3, [pc, #332] ; 30014c6c <_Timer_server_Body+0x1cc>
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
30014b1c: e5942074 ldr r2, [r4, #116] ; 0x74
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
30014b20: e5936000 ldr r6, [r3]
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
30014b24: e1560002 cmp r6, r2
30014b28: 9a000004 bls 30014b40 <_Timer_server_Body+0xa0>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
30014b2c: e0621006 rsb r1, r2, r6 30014b30: e1a00007 mov r0, r7 30014b34: e1a02005 mov r2, r5 30014b38: eb000ff7 bl 30018b1c <_Watchdog_Adjust_to_chain> 30014b3c: ea000003 b 30014b50 <_Timer_server_Body+0xb0>
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
30014b40: 30662002 rsbcc r2, r6, r2 30014b44: 31a00007 movcc r0, r7 30014b48: 33a01001 movcc r1, #1 30014b4c: 3b000fca blcc 30018a7c <_Watchdog_Adjust>
}
watchdogs->last_snapshot = snapshot;
30014b50: e5846074 str r6, [r4, #116] ; 0x74
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
30014b54: e5940078 ldr r0, [r4, #120] ; 0x78 30014b58: eb000229 bl 30015404 <_Chain_Get>
if ( timer == NULL ) {
30014b5c: e2501000 subs r1, r0, #0
30014b60: 0a00000a beq 30014b90 <_Timer_server_Body+0xf0>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
30014b64: e5913038 ldr r3, [r1, #56] ; 0x38 30014b68: e3530001 cmp r3, #1
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
30014b6c: 02811010 addeq r1, r1, #16 30014b70: 01a0000b moveq r0, fp
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
30014b74: 0a000003 beq 30014b88 <_Timer_server_Body+0xe8>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
30014b78: e3530003 cmp r3, #3
30014b7c: 1afffff4 bne 30014b54 <_Timer_server_Body+0xb4>
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
30014b80: e2811010 add r1, r1, #16 30014b84: e1a00007 mov r0, r7 30014b88: eb001010 bl 30018bd0 <_Watchdog_Insert> 30014b8c: eafffff0 b 30014b54 <_Timer_server_Body+0xb4>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30014b90: e10f3000 mrs r3, CPSR 30014b94: e3832080 orr r2, r3, #128 ; 0x80 30014b98: e129f002 msr CPSR_fc, r2
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
30014b9c: e59d2014 ldr r2, [sp, #20] 30014ba0: e152000a cmp r2, sl
30014ba4: 1a000005 bne 30014bc0 <_Timer_server_Body+0x120>
ts->insert_chain = NULL;
30014ba8: e5841078 str r1, [r4, #120] ; 0x78
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30014bac: e129f003 msr CPSR_fc, r3
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
30014bb0: e59d3008 ldr r3, [sp, #8] 30014bb4: e1530008 cmp r3, r8
30014bb8: 1a000002 bne 30014bc8 <_Timer_server_Body+0x128>
30014bbc: ea000015 b 30014c18 <_Timer_server_Body+0x178>
30014bc0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 30014bc4: eaffffcb b 30014af8 <_Timer_server_Body+0x58> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30014bc8: e10f2000 mrs r2, CPSR 30014bcc: e3823080 orr r3, r2, #128 ; 0x80 30014bd0: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
30014bd4: e59d3008 ldr r3, [sp, #8]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
30014bd8: e1530008 cmp r3, r8
30014bdc: 0a00000b beq 30014c10 <_Timer_server_Body+0x170>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
30014be0: e5931000 ldr r1, [r3]
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
30014be4: e3530000 cmp r3, #0
the_chain->first = new_first;
30014be8: e58d1008 str r1, [sp, #8]
new_first->previous = _Chain_Head(the_chain);
30014bec: e5815004 str r5, [r1, #4]
30014bf0: 0a000006 beq 30014c10 <_Timer_server_Body+0x170>
watchdog->state = WATCHDOG_INACTIVE;
30014bf4: e5839008 str r9, [r3, #8]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30014bf8: e129f002 msr CPSR_fc, r2
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
30014bfc: e5930020 ldr r0, [r3, #32] 30014c00: e5931024 ldr r1, [r3, #36] ; 0x24 30014c04: e1a0e00f mov lr, pc 30014c08: e593f01c ldr pc, [r3, #28]
}
30014c0c: eaffffed b 30014bc8 <_Timer_server_Body+0x128> 30014c10: e129f002 msr CPSR_fc, r2 30014c14: eaffffb5 b 30014af0 <_Timer_server_Body+0x50> 30014c18: e59f3050 ldr r3, [pc, #80] ; 30014c70 <_Timer_server_Body+0x1d0>
} else {
ts->active = false;
30014c1c: e5c4907c strb r9, [r4, #124] ; 0x7c 30014c20: e5932000 ldr r2, [r3] 30014c24: e2822001 add r2, r2, #1 30014c28: e5832000 str r2, [r3]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
30014c2c: e3a01008 mov r1, #8 30014c30: e5940000 ldr r0, [r4] 30014c34: eb000d43 bl 30018148 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
30014c38: e1a00004 mov r0, r4 30014c3c: ebffff6b bl 300149f0 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
30014c40: e1a00004 mov r0, r4 30014c44: ebffff7f bl 30014a48 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
30014c48: eb000aaf bl 3001770c <_Thread_Enable_dispatch>
ts->active = true;
30014c4c: e3a03001 mov r3, #1 30014c50: e5c4307c strb r3, [r4, #124] ; 0x7c
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
30014c54: e59d0004 ldr r0, [sp, #4] 30014c58: eb001035 bl 30018d34 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
30014c5c: e59d0000 ldr r0, [sp] 30014c60: eb001033 bl 30018d34 <_Watchdog_Remove> 30014c64: eaffffa1 b 30014af0 <_Timer_server_Body+0x50> 30014c68: 30038904 .word 0x30038904 30014c6c: 30038834 .word 0x30038834 30014c70: 300387ac .word 0x300387ac
30007990 <_Watchdog_Insert>:
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
30007990: e59f30f0 ldr r3, [pc, #240] ; 30007a88 <_Watchdog_Insert+0xf8>
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
30007994: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
30007998: e5933000 ldr r3, [r3]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3000799c: e10f4000 mrs r4, CPSR 300079a0: e3842080 orr r2, r4, #128 ; 0x80 300079a4: e129f002 msr CPSR_fc, r2
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
300079a8: e5912008 ldr r2, [r1, #8] 300079ac: e3520000 cmp r2, #0
300079b0: 0a000000 beq 300079b8 <_Watchdog_Insert+0x28>
_ISR_Enable( level );
300079b4: ea000031 b 30007a80 <_Watchdog_Insert+0xf0> <== NOT EXECUTED
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
300079b8: e59f20cc ldr r2, [pc, #204] ; 30007a8c <_Watchdog_Insert+0xfc>
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
300079bc: e59f60cc ldr r6, [pc, #204] ; 30007a90 <_Watchdog_Insert+0x100>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
300079c0: e592c000 ldr ip, [r2]
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
300079c4: e1a07006 mov r7, r6
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
300079c8: e28cc001 add ip, ip, #1 300079cc: e582c000 str ip, [r2]
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
300079d0: e3a02001 mov r2, #1 300079d4: e5812008 str r2, [r1, #8]
_Watchdog_Sync_count++;
restart:
delta_interval = the_watchdog->initial;
300079d8: e591200c ldr r2, [r1, #12]
* cache *header!! * * Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc) * */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
300079dc: e590c000 ldr ip, [r0]
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
300079e0: e3520000 cmp r2, #0
300079e4: 0a000014 beq 30007a3c <_Watchdog_Insert+0xac>
300079e8: e59c5000 ldr r5, [ip] 300079ec: e3550000 cmp r5, #0
300079f0: 0a000011 beq 30007a3c <_Watchdog_Insert+0xac>
break;
if ( delta_interval < after->delta_interval ) {
300079f4: e59c5010 ldr r5, [ip, #16] 300079f8: e1520005 cmp r2, r5
after->delta_interval -= delta_interval;
300079fc: 30625005 rsbcc r5, r2, r5 30007a00: 358c5010 strcc r5, [ip, #16]
break;
30007a04: 3a00000c bcc 30007a3c <_Watchdog_Insert+0xac>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
30007a08: e10f8000 mrs r8, CPSR 30007a0c: e129f004 msr CPSR_fc, r4 30007a10: e129f008 msr CPSR_fc, r8
* mechanism used here WAS redesigned to address this.
*/
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
30007a14: e5918008 ldr r8, [r1, #8]
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
30007a18: e0652002 rsb r2, r5, r2
* mechanism used here WAS redesigned to address this.
*/
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
30007a1c: e3580001 cmp r8, #1
30007a20: 1a000010 bne 30007a68 <_Watchdog_Insert+0xd8>
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
30007a24: e5965000 ldr r5, [r6] 30007a28: e1550003 cmp r5, r3
_Watchdog_Sync_level = insert_isr_nest_level;
30007a2c: 85873000 strhi r3, [r7]
goto restart;
30007a30: 8affffe8 bhi 300079d8 <_Watchdog_Insert+0x48>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
30007a34: e59cc000 ldr ip, [ip]
}
}
30007a38: eaffffe8 b 300079e0 <_Watchdog_Insert+0x50>
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
30007a3c: e59f5050 ldr r5, [pc, #80] ; 30007a94 <_Watchdog_Insert+0x104>
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
30007a40: e59c0004 ldr r0, [ip, #4]
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
30007a44: e5955000 ldr r5, [r5]
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
30007a48: e590c000 ldr ip, [r0] 30007a4c: e5815014 str r5, [r1, #20]
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
30007a50: e3a05002 mov r5, #2
after_node->next = the_node;
30007a54: e5801000 str r1, [r0]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
30007a58: e9810021 stmib r1, {r0, r5}
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
30007a5c: e5812010 str r2, [r1, #16]
before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node;
30007a60: e58c1004 str r1, [ip, #4]
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
30007a64: e581c000 str ip, [r1]
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
30007a68: e59f1020 ldr r1, [pc, #32] ; 30007a90 <_Watchdog_Insert+0x100>
_Watchdog_Sync_count--;
30007a6c: e59f2018 ldr r2, [pc, #24] ; 30007a8c <_Watchdog_Insert+0xfc>
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
30007a70: e5813000 str r3, [r1]
_Watchdog_Sync_count--;
30007a74: e5923000 ldr r3, [r2] 30007a78: e2433001 sub r3, r3, #1 30007a7c: e5823000 str r3, [r2]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
30007a80: e129f004 msr CPSR_fc, r4
30007a84: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
30007a88: 30018f3c .word 0x30018f3c
30007a8c: 30019000 .word 0x30019000
30007a90: 30018f5c .word 0x30018f5c
30007a94: 30019004 .word 0x30019004