void nrf_pwr_mgmt_run(void)
{
#if NRF_PWR_MGMT_CONFIG_FPU_SUPPORT_ENABLED
/*
* Clear FPU exceptions.
* Without this step, the FPU interrupt is marked as pending,
* preventing system from sleeping.
*/
uint32_t fpscr = __get_FPSCR();
__set_FPSCR(fpscr & ~0x9Fu);
__DMB();
NVIC_ClearPendingIRQ(FPU_IRQn);
// Assert if a critical FPU exception is signaled.
ASSERT((fpscr & 0x03) == 0);
#endif // NRF_PWR_MGMT_CONFIG_FPU_SUPPORT_ENABLED
SLEEP_LOCK();
#if NRF_PWR_MGMT_CONFIG_CPU_USAGE_MONITOR_ENABLED
uint32_t sleep_start;
uint32_t sleep_end;
uint32_t sleep_duration;
sleep_start = app_timer_cnt_get();
#endif // NRF_PWR_MGMT_CONFIG_CPU_USAGE_MONITOR_ENABLED
DEBUG_PIN_SET();
// Wait for an event.
#ifdef SOFTDEVICE_PRESENT
ret_code_t ret_code = sd_app_evt_wait();
if (ret_code == NRF_ERROR_SOFTDEVICE_NOT_ENABLED)
{
__WFE();
__SEV();
__WFE();
}
else
{
APP_ERROR_CHECK(ret_code);
}
#else
__WFE();
__SEV();
__WFE();
#endif // SOFTDEVICE_PRESENT
DEBUG_PIN_CLEAR();
#if NRF_PWR_MGMT_CONFIG_CPU_USAGE_MONITOR_ENABLED
sleep_end = app_timer_cnt_get();
UNUSED_VARIABLE(app_timer_cnt_diff_compute(sleep_end,
sleep_start,
&sleep_duration));
m_ticks_sleeping += sleep_duration;
#endif // NRF_PWR_MGMT_CONFIG_CPU_USAGE_MONITOR_ENABLED
SLEEP_RELEASE();
}
/***
* try_to_wake_up - wake up a thread
* @p: the to-be-woken-up thread
* @state: the mask of task states that can be woken
* @sync: do a synchronous wakeup?
*/
int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
{
Assert(p);
dde26_thread_data *t = lxtask_to_ddethread(p);
Assert(t);
Assert(SLEEP_LOCK(t));
p->state = TASK_RUNNING;
ddekit_sem_up(SLEEP_LOCK(t));
return 0;
}
void L1Audio_SetFlag( uint16 audio_id )
{
uint32 savedMask;
if (!kal_if_hisr() && !kal_if_lisr())
kal_trace( TRACE_GROUP_AUD_MD2GCTRL, L1AUDIO_SETFLAG_A,audio_id,l1audio.runningState);
else
kal_dev_trace( TRACE_GROUP_AUD_MD2GCTRL, L1AUDIO_SETFLAG_A,audio_id,l1audio.runningState);
kal_take_sem( l1audio.sema, KAL_INFINITE_WAIT );
ASSERT( l1audio.id_flag & (1 << audio_id) );
ASSERT( (l1audio.runningState & (1 << audio_id)) == 0 );
if( (l1audio.runningState == 0) && (l1audio.disallowSleepState == 0) ) {
#if defined( __CENTRALIZED_SLEEP_MANAGER__ )
Audio_Wake_DSP(audio_id, KAL_TRUE);
#endif
}
if (l1audio.runningState == 0)
SLEEP_LOCK();
savedMask = SaveAndSetIRQMask();
l1audio.runningState |= (1 << audio_id);
RestoreIRQMask( savedMask );
kal_give_sem( l1audio.sema );
}
/* Initialize a dde26 thread.
*
* - Allocate thread data, as well as a Linux task struct,
* - Fill in default values for thread_info, and task,
* - Adapt task struct's thread_info backreference
* - Initialize the DDE sleep lock
*/
static dde26_thread_data *init_dde26_thread(void)
{
/*
* Virtual PID counter
*/
static atomic_t pid_counter = ATOMIC_INIT(0);
dde26_thread_data *t = vmalloc(sizeof(dde26_thread_data));
Assert(t);
memcpy(&t->_vpid, &init_struct_pid, sizeof(struct pid));
t->_vpid.numbers[0].nr = atomic_inc_return(&pid_counter);
memcpy(&LX_THREAD(t), &init_thread, sizeof(struct thread_info));
LX_TASK(t) = vmalloc(sizeof(struct task_struct));
Assert(LX_TASK(t));
memcpy(LX_TASK(t), &init_task, sizeof(struct task_struct));
/* nice: Linux backreferences a task`s thread_info from the
* task struct (which in turn can be found using the
* thread_info...) */
LX_TASK(t)->stack = &LX_THREAD(t);
/* initialize this thread's sleep lock */
SLEEP_LOCK(t) = ddekit_sem_init(0);
return t;
}
void L1Audio_DisallowSleep( kal_uint16 audio_id )
{
uint32 savedMask;
ASSERT( l1audio.id_flag & (1 << audio_id) );
ASSERT( l1audio.runningState & (1 << audio_id) );
savedMask = SaveAndSetIRQMask();
l1audio.disallowSleepState |= (1 << audio_id);
RestoreIRQMask( savedMask );
if( (l1audio.runningState & l1audio.disallowSleepState) )
SLEEP_LOCK();
}
/* Our version of scheduler invocation.
*
* Scheduling is performed by Fiasco, so we don't care about it as long as
* a thread is running. If a task becomes TASK_INTERRUPTIBLE or
* TASK_UNINTERRUPTIBLE, we make sure that the task does not become
* scheduled by locking the task's sleep lock.
*/
asmlinkage void schedule(void)
{
dde26_thread_data *t = lxtask_to_ddethread(current);
switch (current->state) {
case TASK_RUNNING:
ddekit_thread_schedule();
break;
case TASK_INTERRUPTIBLE:
case TASK_UNINTERRUPTIBLE:
ddekit_sem_down(SLEEP_LOCK(t));
break;
default:
panic("current->state = %d --- unknown state\n", current->state);
}
}
/**
* Initialize a DDE Linux 2.6 thread
*
* - Allocate thread data, as well as a Linux task struct,
* - Fill in default values for thread_info, and task,
* - Adapt task struct's thread_info backreference
* - Initialize the DDE sleep lock
*/
static inline dde_linux26_thread_data *init_dde_linux26_thread(void)
{
dde_linux26_thread_data *t = vmalloc(sizeof(dde_linux26_thread_data));
dde_kit_assert(t);
memcpy(&LX_THREAD(t), &init_thread, sizeof(struct thread_info));
LX_TASK(t) = vmalloc(sizeof(struct task_struct));
dde_kit_assert(LX_TASK(t));
memcpy(LX_TASK(t), &init_task, sizeof(struct task_struct));
/* nice: Linux backreferences a task`s thread_info from the
* task struct (which in turn can be found using the
* thread_info...) */
LX_TASK(t)->thread_info = &LX_THREAD(t);
/* initialize this thread's sleep lock */
SLEEP_LOCK(t) = dde_kit_sem_init(0);
return t;
}
