osal.c

本程序为ST公司开发的源代码

   "UART1",
   "I2C0_EVENT",
   "I2C0_DATA",
   "I2C1_EVENT",
   "I2C1_DATA",
   "UNUSED13",
   "USB",
   "SRC_ERROR",
   "SRC_FULL",
   "SRC_EMPTY",
   "DMA",
   "DMA0",
   "DMA1",
   "OIF",
   "BD",
   "CLV",
   "CIRC",
   "ACQ",
   "RATE",
   "MAILBOX",
   "CAV",
   "TIMER0",
   "TIMER1",
   "WATCHDOG",
};

int8 *_OSAL_get_isr_name(int8 index)
{
  return (int8 *) isrnames[index];
}

int8 *_OSAL_get_thread_name(int8 startupindex)
{
  return (int8 *) OSAL_thread_startup_list[startupindex].tname;
}
#endif

/***********************************************************************/
void OSAL_start(void)
/***********************************************************************/
{
  uint32 i;                   // loop-counter
  int rtnval;              // for various OS20-calls
  //   extern void       PLATFORM_init(void);
  event_init();        /* initialize event handling */

  os20_start();

  /****
      * OS20 is started up: init platform
      * Here because: some hal routines uses DEBUG and to use DEBUG
      * the semaphores should be initialised
      ****/
  DEBUG_start();

  //PLATFORM_init();

  DEBUG_OSAL(("OS20 version:", 0, 1, kernel_version()));

  /*
   * create all threads
   */
  for (i = 0; i < (uint32) OSAL_THREAD_LAST; i++)
  {
    OSAL_THREAD_ID_t id = OSAL_thread_startup_list[i].thread_id;

    thread_admin[id].thread_ID = id;
    thread_admin[id].eventcmd_to_shedule = 0;

    semaphore_init_fifo(&thread_admin[id].sem, OSAL_thread_startup_list[i].sem_cnt);

    rtnval = task_init (         OSAL_thread_startup_list[i].fptr,
                                 NULL,                                   /* param */
                        (void *) OSAL_thread_startup_list[i].stack,
                        (int)    OSAL_thread_startup_list[i].stacksize,
                                 &thread_admin[id].task,                  /* task_t */
                                 NULL,                                   /* task descriptor always NULL */
                                 OSAL_thread_startup_list[i].priority,
                                 OSAL_thread_startup_list[i].tname,      /* name */
                                 task_flags_default);                    /* flags */

    if (rtnval != OS20_SUCCESS)
    {
      DEBUG_OSAL(("OSAL ERROR create-thread", 1, 1, i));
    }
    ASSERT(OS20_SUCCESS == rtnval, "");
  }

  DEBUG_OSAL(("OSAL initialized", 0, 0));

#if 0
   /*
    *  Ready with all initializations; other threads may run
    */
   (void) task_priority_set (NULL, MIN_USER_PRIORITY + 1);

   while (1)
   {
      osal_task_counter++;
   }
#endif
}

#ifdef APM_PICKUP   /* [RB] commented out to reduce ROM space */
/***********************************************************************/
OSAL_THREAD_DATA_t * OSAL_get_thread_data(void)
/***********************************************************************/
{
  return (OSAL_THREAD_DATA_t *) task_id();
}

/***********************************************************************/
OSAL_THREAD_ID_t OSAL_get_thread_id(void)
/***********************************************************************/
{
  OSAL_THREAD_DATA_t *ptask;
  ptask = (OSAL_THREAD_DATA_t *) task_id();
  return ptask->thread_ID;
}
#endif

/***********************************************************************/
void OSAL_wake_thread(OSAL_THREAD_ID_t thread)
/***********************************************************************/
{
  semaphore_signal(&thread_admin[thread].sem);
}

/***********************************************************************/
void _OSAL_thread_priority_set(OSAL_THREAD_ID_t thread, int NewPriority)
/***********************************************************************/
{
  (void) task_priority_set(&thread_admin[thread].task, NewPriority);
}

/***********************************************************************/
void _event_OSAL_wake_thread(OSAL_THREAD_ID_t thread)
/***********************************************************************/
{
  if (0 == thread_admin[thread].sem.semaphore_count)
  {
    semaphore_signal(&thread_admin[thread].sem);
  }
}


/***********************************************************************/
void OSAL_wait_thread(OSAL_THREAD_ID_t thread)
/***********************************************************************/
{
  semaphore_wait(&thread_admin[thread].sem);
}

/***********************************************************************/
void OSAL_isr_install(OSAL_ISR_ID_t vector, OSAL_ISR_PRIORITY_t priority, OSAL_ISR_FPTR isr)
/***********************************************************************/
{
  EIC_InstallChannel(vector, priority, (CALLBACK_fnct) isr);
}

/***********************************************************************/
void OSAL_isr_disable(OSAL_ISR_ID_t vector)
/***********************************************************************/
{
  EIC_DisableChannel(vector);
}

/***********************************************************************/
void OSAL_isr_enable(OSAL_ISR_ID_t vector)
/***********************************************************************/
{
  EIC_EnableChannel(vector);
}

/***********************************************************************/
UInt OSAL_isr_status(OSAL_ISR_ID_t vector)
/***********************************************************************/
{
  return EIC_ChannelStatus(vector);
}

/***********************************************************************/
Int OSAL_enter_critical_section(void)
/***********************************************************************/
{
  extern int interruptCount;
  Int itr = EIC_vEicGlobalDis();
  if (!(interruptCount > 0))
  {
    task_lock();
  }
  return itr;
}

/***********************************************************************/
void OSAL_leave_critical_section(Int itr)
/***********************************************************************/
{
  extern int interruptCount;
  if (!(interruptCount > 0))
  {
    task_unlock();
  }
  EIC_vEicGlobalRest(itr);
}




/***********************************************************************
 * local operations
 ***********************************************************************/

/******************************************************************************/
/* Function:  IdleTask                                                        */
/*                                                                            */
/*! \brief    Main body of the Idle OS task
 *  \param    unused
 *  \return   void
 *  \remark
 */
/******************************************************************************/
static  uint32 idle_counter;

void IdleTask(void *unused)
{
  idle_counter = 0;

  while (1)
  {
    idle_counter++;
    DEBUG_send();
#ifdef APM_PICKUP
    service_fsm();
#endif
#if (DEBUG_INCLUDE_PCDEB == 1)
    event_disable_scheduling();
    pcintf();
    event_cmd_shedule();
    event_enable_scheduling();
#endif
  }
}

/* EOF */