osal.c

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

/*****************************************************************************
*                O S A L  . C
******************************************************************************
*
******************************************************************************
*
*  Project           : CDM M8 CAV2
*  Organisation      : Philips Optical Storage
*  Module            : Operating System Abstraction Layer
*
*  Description       : interface-layer functions of the OS Abstraction Layer
*
 *******************************************************************************
 *
 *  \par          Change History:
 *
 * - MR060911e    Moved HostIfTask() from osal.c to hostif.c.
 *
 ***************************************************
 *
 * STM CVS Log:
 *
 * $Log: osal.c,v $
 * Revision 1.37  2007/09/27 11:37:30  belardi
 * Increased Decoder stack size to fix overflow with low bitrate WMA
 *
 * Revision 1.36  2007/09/20 21:35:52  longauer
 * virtual iPod authentication is working
 *
 * Revision 1.35  2007/08/14 15:28:26  dellorto
 * multiple mechanisms
 *
 * Revision 1.34  2007/08/10 12:33:29  longauer
 * IPOD_AP compilation switch enables future iAP
 *
 * Revision 1.33  2007/04/11 14:20:14  belardi
 * Integration of HAVE_CD_MECHA modification by [GP]
 *
 * Revision 1.32  2007/02/09 12:12:27  belardi
 * First integration of iPod pass-through
 * - increased USB task stack in case of debug mode
 *
 * Revision 1.31  2006/10/09 15:18:52  dellorto
 * LoaderTask and CaptureTask moved to related files
 *
 * Revision 1.30  2006/09/18 09:55:24  belardi
 * Corrected CVS keyword usage
 *
 * Revision 1.29  2006/09/18 09:24:52  belardi
 * Added Log CVS keyword into file header
 *
 *
 ******************************************************************************/

#include "configuration.h"

#define  DEBUG_MODID       DEBUG_MODULE_ID_OSAL

#include "gendef.h"        // for uint32 etc.

#include "os20.h"
#include "lld_eic.h"       // for EIC_CH_xx

#include "osal.h"

#ifdef APM_PICKUP
#include "service.h"
#endif

#if (DEBUG_INCLUDE_PCDEB == 1)
#include "pcdeb.h"
#endif

#define DEBUG_OSAL(s)   DEBUG_printf(s)

/*****************************************************************************
*                    Macro Definitions
*****************************************************************************/

// implementator's note: avoid runtime malloc
// unfortunately there is a hardcoded connection between the
// number of threads (OSAL_THREAD_LAST) and the number of stacks...
// (who knows a more elegant way?)

#define STACKSIZE_IDLE        (512)
#define STACKSIZE_HOSTIF      (512)
#define STACKSIZE_SERVO       (512)
#define STACKSIZE_PLAYER      (1024)
#define STACKSIZE_LOADER      (256)
#if (HAVE_WMA!=0 || HAVE_AAC!=0)
#define STACKSIZE_DECODER     (2048)
#else
#define STACKSIZE_DECODER     (1024)
#endif
#define STACKSIZE_CONTROLLER  (768)
#define STACKSIZE_CAPTURE     (512)
#define STACKSIZE_FILESYS     (3*1024)
#if (0 != HAVE_USB)
#if (MUSB_DIAG > 0) // this is defined in the project, not in configuration.h!
 #define STACKSIZE_USB         (5*256)
#else
 #define STACKSIZE_USB         (4*256)
#endif
#endif
#if (0 != HAVE_SDC)
#define STACKSIZE_SDC         (256)
#endif /* HAVE_SDC */
#if (0 != IPOD_AP)	//[LL]new
#define STACKSIZE_ACP         (256)	//[LL]new
#endif/*IPOD_AP*/	//[LL]new

#define HOSTIF_TASK_PRIORITY      (MAX_USER_PRIORITY - 1)
#define LOADER_TASK_PRIORITY      (MAX_USER_PRIORITY - 2)
#define PLAYER_TASK_PRIORITY      (MAX_USER_PRIORITY - 3)
#define SERVO_TASK_PRIORITY       (MAX_USER_PRIORITY - 4)
#define CAPTURE_TASK_PRIORITY     (MAX_USER_PRIORITY - 5)
#define USB_TASK_PRIORITY         (MAX_USER_PRIORITY - 6)
#define SDC_TASK_PRIORITY         (MAX_USER_PRIORITY - 7)
#define CONTROLLER_TASK_PRIORITY  (MAX_USER_PRIORITY - 9)
#define DECODER_TASK_PRIORITY     (MAX_USER_PRIORITY - 10)
#define FILESYS_TASK_PRIORITY     (MAX_USER_PRIORITY - 11)
#if (0 != IPOD_AP)	//[LL]new
#define ACP_TASK_PRIORITY         (MAX_USER_PRIORITY - 12)	//[LL]new
#endif/*IPOD_AP*/	//[LL]new

#ifdef APM_PICKUP
#define LOADER_START    0
#else
#define LOADER_START    1
#endif

#define IDLE_TASK_PRIORITY        (MIN_USER_PRIORITY + 1)
/*****************************************************************************
*                    Type Definitions
*****************************************************************************/

// static (initialization) info for each thread
typedef struct
{
  uint8 *                   stack;
  uint16                    stacksize;
  uint8                     priority;
  OSAL_THREAD_FPTR          fptr;
  int                       sem_cnt;
  OSAL_THREAD_ID_t          thread_id;
  char                      tname[16];
} OSAL_THREAD_STARTUP_t;


/*****************************************************************************
*                    Static Function Prototypes
*****************************************************************************/


/*****************************************************************************
*                    Static Data Definitions
*****************************************************************************/

static   OSAL_THREAD_DATA_t thread_admin[OSAL_THREAD_LAST];

static __align(8) uint8 idle_stack[STACKSIZE_IDLE];
static __align(8) uint8 hostif_stack[STACKSIZE_HOSTIF];
#if (HAVE_CD_MECHA == 1)
static __align(8) uint8 servo_stack[STACKSIZE_SERVO];
#endif
static __align(8) uint8 player_stack[STACKSIZE_PLAYER];
#if (HAVE_CD_MECHA == 1)
static __align(8) uint8 loader_stack[STACKSIZE_LOADER];
#endif
static __align(8) uint8 decoder_stack[STACKSIZE_DECODER];
static __align(8) uint8 controller_stack[STACKSIZE_CONTROLLER];
static __align(8) uint8 capture_stack[STACKSIZE_CAPTURE];
static __align(8) uint8 filesys_stack[STACKSIZE_FILESYS];
#if (0 != HAVE_USB)
static __align(8) uint8 usb_stack[STACKSIZE_USB];
#endif
#if (0 != HAVE_SDC)
static __align(8) uint8 sdc_stack[STACKSIZE_SDC];
#endif /* HAVE_SDC */
#if (0 != IPOD_AP)	//[LL]new
static __align(8) uint8 acp_stack[STACKSIZE_ACP];	//[LL]new
#endif /*IPOD_AP*/	//[LL]new

void IdleTask(void *unused);
#if (HAVE_CD_MECHA == 1)
void LoaderTask(void *unused);
#endif
void HostIfTask(void *unused);   /* Implementation in hostif.c. */
#if (0 != HAVE_USB)
void USBTask(void *unused);
#endif
#if (0 != HAVE_SDC)
void SDCTask(void *unused);
#endif /* HAVE_SDC */

#if (HAVE_CD_MECHA == 1)
void ServoTask(void *unused);
#endif
void PlayerTask(void *unused);
void DecoderTask(void *unused);
void ControllerTask(void *unused);
void CaptureTask(void *unused);
void FileSystemTask(void *unused);
#if (0 != IPOD_AP)	//[LL]new
void ACPTask(void *unused);	//[LL]new
#endif/*IPOD_AP*/	//[LL]new

const OSAL_THREAD_STARTUP_t OSAL_thread_startup_list[OSAL_THREAD_LAST] =
{
  //stack             stacksize             priority                  fptr
  { idle_stack,       STACKSIZE_IDLE,       IDLE_TASK_PRIORITY,       IdleTask,         0,  OSAL_THREAD_IdleTask            ,"Idle"      },
  { hostif_stack,     STACKSIZE_HOSTIF,     HOSTIF_TASK_PRIORITY,     HostIfTask,       0,  OSAL_THREAD_HostIfTask          ,"HostIf"    },
#if (HAVE_CD_MECHA == 1)
  { servo_stack,      STACKSIZE_SERVO,      SERVO_TASK_PRIORITY,      ServoTask,        1,  OSAL_THREAD_ServoTask           ,"Servo"     },
#endif
  { player_stack,     STACKSIZE_PLAYER,     PLAYER_TASK_PRIORITY,     PlayerTask,       1,  OSAL_THREAD_PlayerTask          ,"Player"    },
#if (HAVE_CD_MECHA == 1)
  { loader_stack,     STACKSIZE_LOADER,     LOADER_TASK_PRIORITY,     LoaderTask,       LOADER_START,  OSAL_THREAD_LoaderTask ,"Loader"  },
#endif
  { decoder_stack,    STACKSIZE_DECODER,    DECODER_TASK_PRIORITY,    DecoderTask,      0,  OSAL_THREAD_DecoderTask         ,"Decoder"   },
  { controller_stack, STACKSIZE_CONTROLLER, CONTROLLER_TASK_PRIORITY, ControllerTask,   0,  OSAL_THREAD_ControllerTask      ,"Controller"},
  { capture_stack,    STACKSIZE_CAPTURE,    CAPTURE_TASK_PRIORITY,    CaptureTask,      1,  OSAL_THREAD_CaptureTask         ,"Capture"   },
  { filesys_stack,    STACKSIZE_FILESYS,    FILESYS_TASK_PRIORITY,    FileSystemTask,   0,  OSAL_THREAD_FilesysTask         ,"FileSystem"},
#if (0 != HAVE_USB)
  { usb_stack,        STACKSIZE_USB,        USB_TASK_PRIORITY,        USBTask,          1,  OSAL_THREAD_USBTask             ,"USBTask"   },
#endif
#if (0 != HAVE_SDC)
  { sdc_stack,        STACKSIZE_SDC,        SDC_TASK_PRIORITY,        SDCTask,          1,  OSAL_THREAD_SDCTask                 ,"SDCTask"   },
#endif /* HAVE_SDC */
#if (0 != IPOD_AP)	//[LL]new
  { acp_stack,        STACKSIZE_ACP,        ACP_TASK_PRIORITY,        ACPTask,          1,  OSAL_THREAD_ACPTask             ,"ACPTask"   },	//[LL]new
#endif /*IPOD_AP*/	//[LL]new
};


#if (OS20_PROFILING == 1) && (0 != HAVE_PRINTF)
static const int8 isrnames[][15] =
{
   "EINT0_3",
   "EINT4_7",
   "EINT8",
   "EINT_I2C0",
   "WIU",
   "RCCU",
   "SPI",
   "UART0",