zte's code,first commit
Change-Id: I9a04da59e459a9bc0d67f101f700d9d7dc8d681b
diff --git a/cp/ps/plat/src/oss/sup/inc/ramdump_arch.h b/cp/ps/plat/src/oss/sup/inc/ramdump_arch.h
new file mode 100644
index 0000000..fe5fca7
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/ramdump_arch.h
@@ -0,0 +1,48 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_arch.h
+* Îļþ±êʶ: ramdump_arch.h
+* ÄÚÈÝÕªÒª: ramdump´¦ÀíÆ÷Ïà¹Ø½Ó¿Ú/Êý¾Ý½á¹¹¶¨ÒåÍ·Îļþ
+* ʹÓ÷½·¨:
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/3/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+#ifndef _RAMDUMP_ARCH_H
+#define _RAMDUMP_ARCH_H
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+
+/*******************************************************************************
+* Íⲿº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿ÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Öº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+extern void ramdump_arch_clean_caches(void);
+extern void ramdump_arch_clean_and_invalid_caches(void);
+extern char *ramdump_arch_store_modes_regs(char *mem);
+extern char *ramdump_arch_store_mm_regs(char *mem);
+extern void ramdump_arch_save_all_regs(void);
+
+#endif //#ifndef _RAMDUMP_ARCH_H
+
diff --git a/cp/ps/plat/src/oss/sup/inc/ramdump_collect_server.h b/cp/ps/plat/src/oss/sup/inc/ramdump_collect_server.h
new file mode 100644
index 0000000..2fea030
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/ramdump_collect_server.h
@@ -0,0 +1,51 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_collect_server.h
+* Îļþ±êʶ: ramdump_collect_server.h
+* ÄÚÈÝÕªÒª: ramdump collect server¶ÔÍâ½Ó¿ÚÍ·Îļþ
+* ʹÓ÷½·¨:
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/3/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+#ifndef _RAMDUMP_COLLECT_SERVER_H
+#define _RAMDUMP_COLLECT_SERVER_H
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+#include "ramdump_pub.h"
+
+/*******************************************************************************
+* Íⲿº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿ÉùÃ÷ *
+*******************************************************************************/
+/* first except cpu id */
+extern unsigned long ramdump_except_cpu_id;
+/*******************************************************************************
+* È«¾Öº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+extern int ramdump_collect_server_icp_init(void);
+extern void ramdump_collect_server_notify_clients_dump(void);
+extern void ramdump_get_collect_server_ram_conf(
+ ramdump_ram_config_sync_msg_t *msg);
+extern unsigned long * ramdump_get_first_dump_cpu_id(void);
+extern unsigned long * ramdump_get_client_init_rsp(void);
+
+#endif //#ifndef _RAMDUMP_COLLECT_SERVER_H
+
diff --git a/cp/ps/plat/src/oss/sup/inc/ramdump_oss.h b/cp/ps/plat/src/oss/sup/inc/ramdump_oss.h
new file mode 100644
index 0000000..a208fd9
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/ramdump_oss.h
@@ -0,0 +1,149 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_oss.h
+* Îļþ±êʶ: ramdump_oss.h
+* ÄÚÈÝÕªÒª: ramdump²Ù×÷ϵͳÒÀÀµ½Ó¿Ú/Êý¾Ý½á¹¹¶¨ÒåÍ·Îļþ
+* ʹÓ÷½·¨:
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/3/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+#ifndef _RAMDUMP_OSS_H
+#define _RAMDUMP_OSS_H
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+#include "ramdump_pub.h"
+
+#ifdef _OS_LINUX
+#include <linux/soc/zte/rpm/rpmsg.h>
+#include <asm/io.h>
+#include <asm/current.h>
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <asm/memory.h>
+#include <linux/irqflags.h>
+#include <asm/setup.h>
+#include <linux/kthread.h>
+#include <linux/bug.h>
+#include <linux/kernel.h>
+#include <asm/barrier.h>
+#include <asm/outercache.h>
+#elif defined (_OS_TOS)
+#include "oss_api.h"
+#include "drvs_rpmsg.h"
+#include "drvs_usbPoll.h"
+#include "drvs_icp.h"
+#include "ps_ephy_interface.h"
+#include "drv_api.h"
+#include <cyg/hal/tos_arm_mmu.h>
+#include <cyg/hal/tos_cache.h>
+#include "rpmsg_channel.h"
+#endif
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+#define OSS_MMAP(addr,size) ramdump_oss_mmap(addr,size)
+
+#ifdef _OS_LINUX
+
+#define OSS_PANIC(val) panic(val)
+#define OSS_LOCK(flag) local_irq_disable()
+#define OSS_UNLOCK(flag) local_irq_enable()
+#define OSS_SLEEP(val) msleep(val)
+
+#define OSS_PHY_TO_VIRT(addr) phys_to_virt(addr)
+#define OSS_VIRT_TO_PHY(addr) virt_to_phys(addr)
+#define OSS_PHY_TO_PFN(addr) __phys_to_pfn(addr)
+#define OSS_PFN_VALID(pfn) pfn_valid(pfn)
+
+/*
+ * to make sure ramdump init after icp device init
+ */
+#define OSS_INIT(fn) late_initcall(fn)
+#define OSS_PRINTF printk
+
+#elif defined (_OS_TOS)
+
+#define OSS_PANIC(val) zOss_ASSERT(0)
+#define OSS_LOCK(flag) ZOSS_SAVE_IRQ(flag)
+#define OSS_UNLOCK(flag) ZOSS_RESTORE_IRQ(flag)
+#define OSS_SLEEP(val) zOss_Sleep(val)
+#define OSS_CREATE_THREAD(name,entry) ramdump_oss_create_thread(name,entry)
+#define OSS_PHY_TO_VIRT(addr) (addr)
+
+#define OSS_INIT(fn)
+#define OSS_PRINTF(fmt...) zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, fmt)
+
+#endif //#ifdef _OS_LINUX
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+typedef ramdump_msg_t ramdump_oss_msg_t;
+
+#ifdef _OS_LINUX
+
+typedef T_ZDrvRpMsg_ActorID ramdump_oss_icp_actorid;
+typedef T_ZDrvRpMsg_ChID ramdump_oss_icp_channelid;
+typedef T_ZDrvRpMsg_CallbackFunction ramdump_oss_icp_callback;
+typedef T_ZDrvRpMsg_Msg ramdump_oss_icp_msg;
+typedef void (*ramdump_oss_thread_entry_t)(unsigned long arg);
+
+#elif defined (_OS_TOS) //#ifdef _OS_LINUX
+
+typedef T_ZDrvRpMsg_MsgActor ramdump_oss_icp_actorid;
+typedef T_ZDrvRpMsg_ChID ramdump_oss_icp_channelid;
+typedef T_ZDrvRpMsg_CallbackFunction ramdump_oss_icp_callback;
+typedef T_ZDrvRpMsg_Msg ramdump_oss_icp_msg;
+typedef void (*ramdump_oss_thread_entry_t)(SINT32 arg);
+
+#endif //#ifdef _OS_LINUX
+/*******************************************************************************
+* È«¾Ö±äÁ¿ÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Öº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Öº¯ÊýʵÏÖ *
+*******************************************************************************/
+extern int ramdump_oss_icp_create_channel(
+ ramdump_oss_icp_actorid actorID,
+ ramdump_oss_icp_channelid chID,
+ unsigned int size);
+extern int ramdump_oss_icp_regcallback(
+ ramdump_oss_icp_actorid actorID,
+ unsigned int chID,
+ ramdump_oss_icp_callback callback);
+extern int ramdump_oss_icp_write(const ramdump_oss_icp_msg *pMsg);
+extern void ramdump_oss_data_trans_init(void);
+extern void ramdump_oss_data_trans_read (
+ unsigned char *buffer,
+ unsigned int size);
+extern void ramdump_oss_data_trans_write(
+ unsigned char *buffer,
+ unsigned int size);
+extern void ramdump_oss_data_trans_done(void);
+extern void ramdump_oss_error_log_creat(char *buf);
+extern int ramdump_oss_icp_send(
+ ramdump_oss_msg_t *icp_msg,
+ unsigned int client_id,
+ unsigned int ch_id);
+extern void ramdump_oss_create_thread(
+ char *name,
+ ramdump_oss_thread_entry_t entry);
+extern unsigned long ramdump_oss_mmap(
+ unsigned long addr,
+ unsigned long size);
+
+#endif //#ifndef _RAMDUMP_OSS_H
+
diff --git a/cp/ps/plat/src/oss/sup/inc/ramdump_pub.h b/cp/ps/plat/src/oss/sup/inc/ramdump_pub.h
new file mode 100644
index 0000000..9e9d769
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/ramdump_pub.h
@@ -0,0 +1,178 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_pub.h
+* Îļþ±êʶ: ramdump_pub.h
+* ÄÚÈÝÕªÒª: ramdump¹«¹²Í·Îļþ
+* ʹÓ÷½·¨: #include "ramdump_pub.h"
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/3/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+#ifndef _RAMDUMP_PUB_H
+#define _RAMDUMP_PUB_H
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+#include "ramdump.h"
+#include "ramdump_arch.h"
+#include "ramdump_soc.h"
+
+/*******************************************************************************
+* Íⲿº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+#define RAMDUMP_SUCCESS (0)
+#define RAMDUMP_FAILED (-1)
+
+#define RAMDUMP_ICP_SUCCESS (RAMDUMP_SUCCESS)
+#define RAMDUMP_ICP_FAILED (RAMDUMP_FAILED)
+
+#define RAMDUMP_TRUE (1)
+#define RAMDUMP_FALSE (0)
+
+#define RAMDUMP_SYNC_RESET (0x73787384) /* 73:I 78:N 73:I 84:T */
+#define RAMDUMP_SYNC_RAM_CONFIG_DONE (0x68696576) /* 68:D 69:E 65:A 76:L */
+#define RAMDUMP_SYNC_RAM_CONTENT_DONE (0x68797869) /* 68:D 79:O 78:N 69:E */
+
+#define RAMDUMP_ICP_MSG_DATA_RAMCONF_SIZE (40) //sizeof(ramdump_ram_conf_table_entry)
+#define RAMDUMP_RAMCONF_TABLE_MAX_ENTRYS (RAMDUMP_RAMCONF_TABLE_MAXSIZE/RAMDUMP_ICP_MSG_DATA_RAMCONF_SIZE)
+
+/* adapt diff printf fun*/
+#define RAMDUMP_PRINTF OSS_PRINTF
+
+#define RAMDUMP_ARRAY_NR(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+#define RAMDUMP_WAIT_TIMELEN (200) /* like before,just a value roughly */
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+typedef unsigned long ramdump_msg_id_t;
+typedef unsigned long ramdump_cpu_id_t;
+typedef unsigned long *ramdump_client_done_flag_t;
+
+/*
+ * ICP MSG struct collect server with
+ * clients and trans server.
+ */
+enum
+{
+ RAMDUMP_MSG_INIT_REQ,
+ RAMDUMP_MSG_INIT_RSP,
+ RAMDUMP_MSG_SYNC,
+ RAMDUMP_MSG_EXCEPT,
+};
+
+/*
+ * ramdump client id
+ * collect server : RAMDUMP_CPU_0
+ * trans server : RAMDUMP_CPU_1
+ * client1 : RAMDUMP_CPU_2
+ * client2 : RAMDUMP_CPU_3
+ */
+enum
+{
+/*
+ * collect server/client0 : RAMDUMP_CPU_0
+ * trans server : RAMDUMP_CPU_1
+ * client1 : RAMDUMP_CPU_2
+ */
+ RAMDUMP_CPU_0,
+ RAMDUMP_CPU_1,
+ RAMDUMP_CPU_2,
+ RAMDUMP_CPU_MAX
+};
+
+/* client and server icp ram conf data */
+typedef struct
+{
+ char name[RAMDUMP_RAMCONF_FILENAME_MAXLEN];
+ unsigned long phy;
+ unsigned long vir;
+ unsigned long size;
+
+ unsigned long flag; /* RAMDUMP_FLAG_XXX */
+ unsigned long copy; /* Copy destination address */
+ unsigned long exter; /* External address */
+ ramdump_callback_t callback; /* Callback funtion */
+} ramdump_ram_config_t;
+
+/* client and server icp init msg */
+typedef struct
+{
+ ramdump_ram_config_t *array;
+ unsigned long nr;
+ ramdump_client_done_flag_t done_flag;
+} ramdump_ram_config_msg_t;
+
+/* collect to trans server icp msginfo */
+typedef struct
+{
+ ramdump_ram_config_msg_t *array;
+ unsigned long nr;
+} ramdump_ram_config_sync_msg_t;
+
+/* client and server message define */
+typedef struct
+{
+ ramdump_cpu_id_t cpu_id;
+ ramdump_msg_id_t msg_id;
+
+ union
+ {
+ ramdump_ram_config_msg_t ram_config;
+ ramdump_ram_config_sync_msg_t ram_config_sync;
+ } msg_data_t;
+} ramdump_msg_t;
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿ÉùÃ÷ *
+*******************************************************************************/
+/*
+ * ramdump assign id array, records the true cpu id value.
+ */
+extern unsigned long ramdump_cpu_id[RAMDUMP_CPU_MAX];
+extern unsigned long ramdump_cpu_ch[RAMDUMP_CPU_MAX];
+extern char *ramdump_cpu_name[RAMDUMP_CPU_MAX];
+
+/*******************************************************************************
+* È«¾Öº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ÄÚÁªº¯ÊýʵÏÖ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_wait_client_dump_delay
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) ms: µÈ´ýMSÊý
+ addr: µØÖ·
+ flag: µÈ´ý±êÖ¾
+* (´«³ö²ÎÊý)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷: This function is used to delay certain seconds
+*******************************************************************************/
+static inline void ramdump_wait_done_delay(
+ unsigned long ms,
+ volatile unsigned long *addr,
+ unsigned long flag)
+{
+ int j = 0;
+ int i = 0;
+ for (j = 0; j < RAMDUMP_DELAY_MS_COUNT; j++)
+ for (i = 0; i < ms; i++)
+ if (*addr == flag)
+ return;
+}
+
+#endif //#ifndef _RAMDUMP_PUB_H
+
diff --git a/cp/ps/plat/src/oss/sup/inc/ramdump_soc.h b/cp/ps/plat/src/oss/sup/inc/ramdump_soc.h
new file mode 100644
index 0000000..dc4db7b
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/ramdump_soc.h
@@ -0,0 +1,79 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_soc.h
+* Îļþ±êʶ: ramdump_soc.h
+* ÄÚÈÝÕªÒª: ramdump´¦ÀíÆ÷¾ßÌåÓ²¼þSOCƽ̨Ïà¹ØÍ·Îļþ£¬Æ½Ì¨¸ü»»ºóÐèÊÊÅä
+* ʹÓ÷½·¨:
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/3/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+#ifndef _RAMDUMP_SOC_H
+#define _RAMDUMP_SOC_H
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+
+/*******************************************************************************
+* Íⲿº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+
+/* ramdump max file len, estimated */
+#define RAMDUMP_RAMCONF_FILENAME_MAXLEN (32)
+/* cpu name max len (string) */
+#define RAMDUMP_CPU_NAME_MAXLEN (RAMDUMP_RAMCONF_FILENAME_MAXLEN)
+/*
+ * dump file table contens at least 60 item,
+ * refer to all the ddr + iram + tcm sections in zx297520v2 chip menual,
+ * these sections are just what we can dump.
+ */
+#define RAMDUMP_RAMCONF_TABLE_MAXSIZE (2400) /* 2k about, estimated */
+
+/* ramdump cmm scripts size, estimated */
+#define RAMDUMP_CMM_SIZE (0x2000) /* 4K */
+
+/* ramdump cmm scripts size, estimated */
+#define RAMDUMP_ERROR_LOG_SIZE (1024)
+
+/* statics 2500 per ms, estimated */
+#define RAMDUMP_DELAY_MS_COUNT (2500)
+
+#ifdef __USE_RAMDUMP_TRANS_SERVER__
+/* ramdump channel number & size, estimated */
+#define RAMDUMP_CHANNEL_SIZE (0x100) /* 4K */ //0x2000
+#define RAMDUMP_CHANNEL (ICP_CHANNEL_RAMDUMP)
+
+/* zx297520V2 AP ram config */
+#define RAMDUMP_SERVER_DDR_BASE (PLAT_PHYS_OFFSET) //(0x22000000) //TODO! ramconf.h
+#define RAMDUMP_SERVER_DDR_SIZE (PLAT_PHYS_SIZE)
+
+#elif defined (__USE_RAMDUMP_CLIENT__)
+/* ramdump channel number & size, estimated */
+#define RAMDUMP_CHANNEL_SIZE (0x100) /* 4K */ //0x2000
+#define RAMDUMP_CHANNEL (RAMDUMP)
+
+#endif
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿ÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Öº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+#endif //#ifndef _RAMDUMP_SOC_H
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup.h b/cp/ps/plat/src/oss/sup/inc/sup.h
new file mode 100644
index 0000000..da4dc33
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup.h
@@ -0,0 +1,114 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : sup.h
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : supÄÚ²¿Í·Îļþ,¶¨ÒåÄÚ²¿¸÷Ä£¿é¹«¹²Êý¾Ý½á¹¹µÈ
+* ×÷ Õß : hongkun
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2007-10-25
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001782014
+**************************************************************************/
+
+#ifndef _SUP_H
+#define _SUP_H
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#define CHANNEL_CFG_NUM 30
+
+#define SUP_THREAD_LIVE_BIT 1
+#define SUP_THREAD_LAZY_BIT 2
+#define SUP_THREAD_STATISTIC_INFO_BIT 4
+
+#ifdef _OS_TOS
+#define TOS_STATISTIC_TIMESLICE
+#endif
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+/* ÄÚ´æ¹ÜÀíÄ£¿é */
+typedef struct
+{
+ T_ZOss_Node node; /* Á´±í¿ØÖƽṹ */
+ VOID *mem; /* ÄÚ´æÖ¸Õë */
+ UINT32 mem_size; /* ÄÚ´æ´óС */
+ CHAR name[12]; /* ÉêÇëλÖÃÎļþ */
+ UINT32 line; /* ÉêÇëλÖÃÐкŠ*/
+ ZOSS_THREAD_ID thread_id; /* ÉêÇëÏ̺߳Š*/
+ ZOSS_TASK_ID task_id; /* ÉêÇëÈÎÎñºÅ */
+ UINT32 apply_time_tick; /* ÉêÇëʱ¼ä(TICK) */
+}T_Mem_MemNodeInfo; /* ϵͳÄÚ´æÐÅÏ¢ */
+
+/**************************************************************************
+* º¯ÊýÉùÃ÷Çø
+**************************************************************************/
+UINT32 TIMER_Init(VOID);
+UINT32 TEST_Init(VOID);
+UINT32 PSM_Init(VOID);
+UINT32 NV_Init(VOID);
+#ifdef TOS_STATISTIC_TIMESLICE
+void zOss_StatisticTimesliceStart(UINT32 time_len, UINT32 type);
+#endif
+/*ÈÎÎñ¹ÜÀíÄ£¿é */
+UINT32 SCHE_Init(VOID);
+UINT32 zOss_TaskSendDataEx(T_ZOss_TaskMsgHead *buf);
+UINT32 Sche_TaskSend(UINT32 msg_id, VOID *buf, UINT16 msg_len, ZOSS_TASK_ID s_task_id, ZOSS_TASK_ID t_task_id);
+UINT32 Sche_TaskSendData(UINT32 msg_id, VOID *buf, UINT16 msg_len, ZOSS_TASK_ID s_task_id, ZOSS_TASK_ID t_task_id);
+UINT32 Sche_InterruptTaskSend(UINT32 msg_id, T_ZOss_TaskMsgHead *pMsg, UINT16 msg_len, ZOSS_TASK_ID task_id);
+VOID *Sche_getBufPoint(T_ZOss_TaskMsgHead *phead);
+UINT32 Sche_getBufLength(T_ZOss_TaskMsgHead *phead);
+UINT32 Sche_DeadLoop(ZOSS_TASK_ID *task_id_arr);
+
+/* ÄÚ´æ¹ÜÀíÄ£¿é */
+UINT32 MEM_Init(VOID);
+VOID FS_Init(VOID);
+UINT32 Mem_GetSysMemDebugInfo(T_ZOss_List *mem_debug_info_lst);
+UINT32 Mem_GetUBUseInfo(T_Mem_UBPoolGrpInfo *ub_pool_grp_info, UINT8 num);
+UINT32 Mem_CheckUBLeak(T_Mem_UBLeakInfo *ub_leak_info, UINT32 ub_leak_time, UINT8 poolNum, UINT32 size);
+UINT32 Mem_ThreadUBInfo(ZOSS_THREAD_ID threadId, T_Mem_UBBlockInfo *threadUbInfo, UINT32 num, UINT8 poolNum);
+UINT32 Mem_TaskUBInfo(ZOSS_TASK_ID taskId, T_Mem_UBBlockInfo *taskUbInfo, UINT32 num, UINT8 poolNum);
+
+/* Òì³£¹ÜÀíÄ£¿é */
+UINT32 EXCEP_Init(VOID);
+VOID Excep_DaemonTask(UINT8 state, UINT32 msg_id, UINT8 *buf, UINT16 msg_len, UINT8 *private_data);
+
+/* Ê¡µç¹³×Óº¯Êý*/
+VOID zOss_ThreadSwapInPsmHook(T_ZOsa_ThreadUserArea *user_area);
+VOID zOss_ThreadSwapOutPsmHook(T_ZOsa_ThreadUserArea *user_area);
+VOID zOss_RecordPsmLastSwapTime(VOID);
+VOID zOss_ClearSleepTime(VOID);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿ÉùÃ÷Çø
+**************************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SUP_H */
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_agent.h b/cp/ps/plat/src/oss/sup/inc/sup_agent.h
new file mode 100644
index 0000000..58e737e
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_agent.h
@@ -0,0 +1,77 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+
+#ifndef OSAGT_H
+#define OSAGT_H
+
+#ifdef _USE_MONITOR
+/**************************************************************************************************
+* ³£Á¿¶¨ÒåÇø
+***************************************************************************************************/
+//¹¤¾ß×Ô¶¨ÒåµÄʼþºÅ
+#define PC_AGT_ACK 100
+#define PC_AGT_SET_VARIABLE 101
+#define PC_AGT_GET_VARIABLE 102
+#define PC_AGT_SNAPSHOT 103
+#define PC_AGT_STOP 104
+#define PC_AGT_START 105
+
+#define AGT_PC_ACK 50
+#define AGT_PC_WINDOW_INFO_THREAD 0
+#define AGT_PC_WINDOW_INFO_EVENT 1
+#define AGT_PC_WINDOW_INFO_TIMER 2
+#define AGT_PC_WINDOW_INFO_TASK 3
+#define AGT_PC_WINDOW_INFO_RAMLOG 4
+#define AGT_PC_WINDOW_INFO_POOL 5
+#define AGT_PC_WINDOW_INFO_MMU 6
+#define AGT_PC_WINDOW_INFO_MSG 7
+#define AGT_PC_WINDOW_INFO_POOLLEAK 8
+#define AGT_PC_WINDOW_INFO_VARIABLE 9
+#define AGT_PC_WINDOW_INFO_MEM 10
+#define AGT_PC_WINDOW_INFO_CPU 11
+#define PC_WINDOW_NUM 12
+
+#define WINDOW_OS_MAP_MAX_NUM 3
+
+//PC²à´°¿Ú±àºÅ
+#define PC_TOOL_WINDOW_THREAD AGT_PC_WINDOW_INFO_THREAD
+#define PC_TOOL_WINDOW_EVENT AGT_PC_WINDOW_INFO_EVENT
+#define PC_TOOL_WINDOW_TIMER AGT_PC_WINDOW_INFO_TIMER
+#define PC_TOOL_WINDOW_TASK AGT_PC_WINDOW_INFO_TASK
+#define PC_TOOL_WINDOW_RAMLOG AGT_PC_WINDOW_INFO_RAMLOG
+#define PC_TOOL_WINDOW_POOL AGT_PC_WINDOW_INFO_POOL
+#define PC_TOOL_WINDOW_MMU AGT_PC_WINDOW_INFO_MMU
+#define PC_TOOL_WINDOW_MSG AGT_PC_WINDOW_INFO_MSG
+#define PC_TOOL_WINDOW_POOLLEAK AGT_PC_WINDOW_INFO_POOLLEAK
+#define PC_TOOL_WINDOW_VARIABLE AGT_PC_WINDOW_INFO_VARIABLE
+#define PC_TOOL_WINDOW_MEM AGT_PC_WINDOW_INFO_MEM
+#define PC_TOOL_WINDOW_CPU AGT_PC_WINDOW_INFO_CPU
+
+//Ä¿±êÄ£¿éÃû
+#define OS_TASK_NAME "OssMonitor"
+#endif
+#endif
+
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_agent_osinfopack.h b/cp/ps/plat/src/oss/sup/inc/sup_agent_osinfopack.h
new file mode 100644
index 0000000..cf61e49
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_agent_osinfopack.h
@@ -0,0 +1,181 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+
+#ifndef OSINFOPACK_H
+#define OSINFOPACK_H
+
+#ifdef _USE_MONITOR
+/**************************************************************************************************
+* includeÇø
+***************************************************************************************************/
+#include "oss_api.h"
+#include "oss_monitor.h"
+
+/**************************************************************************************************
+* ³£Á¿¶¨ÒåÇø
+***************************************************************************************************/
+#define NUMERIC_LEN 4
+#define VERSION_LEN 32
+#define FILE_LEN 128
+#define THREAD_NAME_LEN 64
+#define TASK_NAME_LEN 64
+#define EVENT_NAME_LEN 64
+#define TICKSTAMP_LEN 8
+#define MMU_NAME_LEN 64
+#define OWNER_NAME_LEN 64
+#define SENDER_NAME_LEN 64
+#define RECEIVER_NAME_LEN 64
+#define TIMER_EXPIRY_NUM 2
+#define TIMER_EXPIRY_LEN 4
+#define EVENT_NUM 4
+#define EVENT_LEN 16
+#define TASK_STATUS_NUM 4
+#define TASK_STATUS_LEN 8
+#define MMU_PERMISSION_NUM 6
+#define MMU_PERMISSION_LEN 16
+#define THREAD_STATUS_NUM 3
+#define THREAD_STATUS_LEN 8
+
+/**************************************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+***************************************************************************************************/
+typedef struct
+{
+ char version[VERSION_LEN];
+}T_Version;
+
+typedef struct
+{
+ BYTE feq[NUMERIC_LEN];
+}T_Frequency;
+
+typedef struct
+{
+ BYTE load[NUMERIC_LEN];
+}T_CpuLoad;
+
+typedef struct
+{
+ BYTE size[NUMERIC_LEN];
+ BYTE total[NUMERIC_LEN];
+ BYTE used[NUMERIC_LEN];
+ BYTE maxUsed[NUMERIC_LEN];
+}T_Pool_Ele;
+
+typedef struct
+{
+ BYTE address[NUMERIC_LEN];
+ BYTE owner[NUMERIC_LEN];
+ BYTE timeStamp[NUMERIC_LEN];
+ char file[FILE_LEN];
+ BYTE line[NUMERIC_LEN];
+}T_Pool_Alloc_Ele, T_Pool_Leak_Ele;
+
+typedef struct
+{
+ BYTE base[NUMERIC_LEN];
+ BYTE size[NUMERIC_LEN];
+ BYTE used[NUMERIC_LEN];
+}T_Heap;
+
+typedef struct//modified by zyn
+{
+ char name[THREAD_NAME_LEN];
+ BYTE handle[NUMERIC_LEN];
+ BYTE msg_no[NUMERIC_LEN];
+ char status[THREAD_STATUS_LEN];
+ BYTE priority[NUMERIC_LEN];
+ BYTE stack_used[NUMERIC_LEN];
+ BYTE stack_max_used[NUMERIC_LEN];
+ BYTE cpu_load[NUMERIC_LEN];
+
+}T_Thread_Ele;
+
+typedef struct //modified by zyn
+{
+ char name[TASK_NAME_LEN];
+ BYTE handle[NUMERIC_LEN];
+ BYTE thread_handle[NUMERIC_LEN];
+ char status[TASK_STATUS_LEN];
+
+}T_Task_Ele;
+
+typedef struct //modified by zyn
+{
+ char name[EVENT_NAME_LEN];
+ char event[EVENT_LEN];
+ BYTE handle[NUMERIC_LEN];
+ BYTE tickstamp[TICKSTAMP_LEN];
+
+}T_Event_Ele;
+
+typedef struct
+{
+ BYTE msgId[NUMERIC_LEN];
+ BYTE address[NUMERIC_LEN]; //ÆðʼµØÖ·
+ BYTE size[NUMERIC_LEN]; //³¤¶È
+ char sender[SENDER_NAME_LEN];
+ char receiver[RECEIVER_NAME_LEN];
+ BYTE timestamp[NUMERIC_LEN];
+}T_Msg_Ele;
+
+typedef struct //modified by zyn
+{
+ BYTE handle[NUMERIC_LEN];
+ BYTE start_time[NUMERIC_LEN];
+ BYTE expire_time[NUMERIC_LEN];
+ BYTE callback_func[NUMERIC_LEN];
+ char is_period[TIMER_EXPIRY_LEN];
+}T_Timer_Ele;
+
+typedef struct
+{
+ char name[MMU_NAME_LEN];
+ BYTE vir_addr[NUMERIC_LEN];
+ BYTE phy_addr[NUMERIC_LEN];
+ BYTE size[NUMERIC_LEN];
+ char attr[MMU_PERMISSION_LEN]; /* permission and access */
+}T_Mmu_Ele;
+
+/**************************************************************************************************
+* º¯ÊýÉùÃ÷Çø
+***************************************************************************************************/
+VOID zOss_MonitorAgt_PackVersion(UINT8* code, T_ZOss_Mon_Version* version);
+VOID zOss_MonitorAgt_PackFrequency(UINT8* code, T_ZOss_Mon_Cpu_Frequency* frequency);
+VOID zOss_MonitorAgt_PackCpuLoad(UINT8* code, T_ZOss_Mon_Cpu_Load* cpuLoad);
+VOID zOss_MonitorAgt_PackPoolEle(UINT8* code, T_ZOss_Mon_Pool_Ele* pool_ele);
+VOID zOss_MonitorAgt_PackPoolAllocEle(UINT8* code, T_ZOss_Mon_Pool_Alloc_Ele* pool_alloc_ele);
+VOID zOss_MonitorAgt_PackPoolLeakEle(UINT8* code, T_ZOss_Mon_Pool_Leak_Ele* pool_leak_ele);
+VOID zOss_MonitorAgt_PackHeap(UINT8* code, T_ZOss_Mon_Heap* heap);
+VOID zOss_MonitorAgt_PackThreadEle(UINT8* code, T_ZOss_Mon_Thread_Ele* thread_ele);
+VOID zOss_MonitorAgt_PackTaskEle(UINT8* code, T_ZOss_Mon_Task_Ele* task_ele);
+VOID zOss_MonitorAgt_PackEventEle(UINT8* code, T_ZOss_Mon_Event_Ele* event_ele);
+VOID zOss_MonitorAgt_PackMsgEle(UINT8* code, T_ZOss_Mon_Msg_Ele* msg_ele);
+VOID zOss_MonitorAgt_PackTimerEle(UINT8* code, T_ZOss_Mon_Timer_Ele* timer_ele);
+VOID zOss_MonitorAgt_PackMmuEle(UINT8* code, T_ZOss_Mon_Mmu_Ele* mmu_ele);
+
+#endif
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_agent_pcmessage.h b/cp/ps/plat/src/oss/sup/inc/sup_agent_pcmessage.h
new file mode 100644
index 0000000..6562d2f
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_agent_pcmessage.h
@@ -0,0 +1,47 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+
+#ifndef OSAGT_PCMESSAGE_H
+#define OSAGT_PCMESSAGE_H
+#ifdef _USE_MONITOR
+/**************************************************************************************************
+* º¯ÊýÉùÃ÷Çø
+***************************************************************************************************/
+VOID zOss_MonitorAgt_PcAckReq(VOID);
+#ifdef _USE_WINCOMM_SERVER
+VOID zOss_MonitorAgt_PcSetValueReq(UINT32 len, BYTE* buf);
+VOID zOss_MonitorAgt_PcGetValueReq(UINT32 len, BYTE* buf);
+#else
+VOID zOss_MonitorAgt_PcSetValueReq(UINT16 len, BYTE* buf);
+VOID zOss_MonitorAgt_PcGetValueReq(UINT16 len, BYTE* buf);
+#endif
+VOID zOss_MonitorAgt_PcSnapshotReq(UINT8 msgId);
+VOID zOss_MonitorAgt_PcStop(VOID);
+VOID zOss_MonitorAgt_PcStart(VOID);
+
+#endif
+#endif
+
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_agent_status.h b/cp/ps/plat/src/oss/sup/inc/sup_agent_status.h
new file mode 100644
index 0000000..bbdb884
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_agent_status.h
@@ -0,0 +1,52 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+#ifndef OSAGT_STATUS_H
+#define OSAGT_STATUS_H
+#ifdef _USE_MONITOR
+
+/**************************************************************************************************
+* includeÇø
+***************************************************************************************************/
+#include "oss_api.h"
+
+/**************************************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+***************************************************************************************************/
+typedef enum
+{
+ OsAgt_Status_Error = 0,
+ OsAgt_Status_Ok
+
+}OsAgt_Status;
+
+/**************************************************************************************************
+* º¯ÊýÉùÃ÷Çø
+***************************************************************************************************/
+OsAgt_Status zOss_MonitorAgt_CheckReceiveMessage(UINT32 msgId);
+OsAgt_Status zOss_MonitorAgt_CheckReplyMessage(UINT32 msgId);
+
+#endif
+#endif/*__OS_AGENT_STATUS_H__*/
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_agent_toolkit.h b/cp/ps/plat/src/oss/sup/inc/sup_agent_toolkit.h
new file mode 100644
index 0000000..b21a23f
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_agent_toolkit.h
@@ -0,0 +1,45 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+#ifndef OSAGT_TOOLKIT_H
+#define OSAGT_TOOLKIT_H
+#ifdef _USE_MONITOR
+
+/**************************************************************************************************
+* includeÇø
+***************************************************************************************************/
+#include "oss_api.h"
+
+/**************************************************************************************************
+* º¯ÊýÉùÃ÷Çø
+***************************************************************************************************/
+VOID zOss_MonitorAgt_SendMsgToOs(UINT32 id, UINT16 len, UINT8* buf);
+VOID zOss_MonitorAgt_SendDataToPcTool(UINT8* buf, UINT32 len);
+VOID zOss_MonitorAgt_CharToByteArray(char* array, const char* charStr, DWORD maxLen);
+VOID zOss_MonitorAgt_FileNameToByteArray(char* array, const char* charStr, DWORD maxLen);
+VOID zOss_MonitorAgt_SetOsTaskId(ZOSS_TASK_ID taskId);
+
+#endif
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_agent_uemessage.h b/cp/ps/plat/src/oss/sup/inc/sup_agent_uemessage.h
new file mode 100644
index 0000000..ec09226
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_agent_uemessage.h
@@ -0,0 +1,45 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+
+#ifndef OSAGT_UEMESSAGE_H
+#define OSAGT_UEMESSAGE_H
+#ifdef _USE_MONITOR
+
+/**************************************************************************************************
+* includeÇø
+***************************************************************************************************/
+#include "oss_api.h"
+#include "oss_monitor.h"
+
+/**************************************************************************************************
+* º¯ÊýÉùÃ÷Çø
+***************************************************************************************************/
+VOID zOss_MonitorAgt_InitUeMessage(VOID);
+//handle all message
+VOID zOss_MonitorAgt_UeMessageHandler(UINT32 msgId, UINT8 *buf);
+
+#endif
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_except.h b/cp/ps/plat/src/oss/sup/inc/sup_except.h
new file mode 100644
index 0000000..2530330
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_except.h
@@ -0,0 +1,92 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_except.h
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : P96AÒì³£¹ÜÀíÄ£¿éÍ·Îļþ
+* ×÷ Õß : ÖܹúÆÂ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2007/09/04
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : dengningkun
+* ÐÞ¸ÄÈÕÆÚ : 2012/9/27
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT¼ì²é EC:617001782169
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0002
+* ÐÞ ¸Ä ÈË : dengningkun
+* ÐÞ¸ÄÈÕÆÚ : 2012/10/10
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é EC:617001782205
+**************************************************************************/
+
+#ifndef _SUP_EXCEP_H
+#define _SUP_EXCEP_H
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#ifdef _OS_WIN
+#define snprintf _snprintf /* vcÊÇ_snprintf */
+#endif
+
+#define EXCEP_DAEMONTASKNAME "zOss_ExcepDaemonTask"
+
+#ifdef _OS_LINUX
+# define EXCEP_IDLETHREADNAME "swapper"
+#else
+# ifdef _USE_PSM
+# define EXCEP_IDLETHREADNAME "zOss_ThreadPsm"
+# else
+# ifdef _OS_TOS
+# define EXCEP_IDLETHREADNAME "tos_idle_thread"
+# else
+# define EXCEP_IDLETHREADNAME "zOss_ExcepIdleThread"
+# endif
+# endif
+#endif
+
+/* ÏûÏ¢ */
+#define EV_ZOSS_EXCEP_WDT_SET (EV_ZOSS_EXCEP_BASE + 0x10) /* ÉèÖÿ´ÃŹ· */
+#define EV_ZOSS_EXCEP_DEADLOOPCHECK (EV_ZOSS_EXCEP_BASE + 0x13) /* ËÀÑ»·¼ì²â */
+#define EV_ZOSS_EXCEP_UPDATECPUTIME (EV_ZOSS_EXCEP_BASE + 0x15) /* ÉèÖøüÐÂCPUʹÓÃÂÊʱ¼ä */
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* º¯ÊýÉùÃ÷Çø
+**************************************************************************/
+UINT32 Excep_ErrlogWrite(const CHAR *buf, UINT32 buf_len);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿ÉùÃ÷Çø
+**************************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SUP_EXCEP_H */
+
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_nvm.h b/cp/ps/plat/src/oss/sup/inc/sup_nvm.h
new file mode 100644
index 0000000..2a7cafb
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_nvm.h
@@ -0,0 +1,81 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_NV
+* ÎÄ ¼þ Ãû : sup_nvm.h
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : NVÊý¾Ý¹ÜÀíÄ£¿é
+* ×÷ Õß : ¬л¼ª
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2012-09-10
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : wuzhengjun
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001781798
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0002
+* ÐÞ ¸Ä ÈË : wuzhengjun
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-27
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é EC:617001781846
+**************************************************************************/
+#ifndef _SUP_NVM_H
+#define _SUP_NVM_H
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/* NVÁ´±í½Úµã½á¹¹Ìå */
+typedef struct
+{
+ T_ZOss_Node Node; /* ͨÓÃÁ´±í½Úµã */
+ T_ZOss_List Child_List; /* ×ÓÁ´±í */
+ UINT32 Block_Addr; /* ¿éµØÖ· */
+}T_NV_MAIN_NODE; /* NVÁ´±íÖ÷½Úµã */
+
+
+typedef struct
+{
+ T_ZOss_Node Node; /* ͨÓÃÁ´±í½Úµã */
+ UINT32 Addr; /* µØÖ· */
+ UINT32 Len; /* ³¤¶È */
+}T_NV_CHILD_NODE; /* NVÁ´±í×Ó½Úµã */
+/**************************************************************************
+* º¯ÊýÉùÃ÷Çø
+**************************************************************************/
+UINT32 Nvram_Finish(VOID);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿ÉùÃ÷Çø
+**************************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SUP_NVM_H */
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_ramdump.h b/cp/ps/plat/src/oss/sup/inc/sup_ramdump.h
new file mode 100644
index 0000000..60ba364
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_ramdump.h
@@ -0,0 +1,276 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_ramdump.h
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : ÌṩramdumpÏûÏ¢½á¹¹Ìå
+* ×÷ Õß : gaohuafeng
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2013/10/29
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : dengningkun
+* ÐÞ¸ÄÈÕÆÚ : 2012/9/27
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT¼ì²é EC:617001782169
+**************************************************************************/
+
+#ifndef _SUP_RAMDUMP_H
+#define _SUP_RAMDUMP_H
+
+#ifdef _USE_MULTI_CORE_RAMDUMP
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+#include "drvs_icp.h"
+#include "ram_config.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+/* Ö¸ÁÒå */
+#define ZOSS_RAMDUMP_FILE_LINK_REQ 1 /*ͬ²½ÇëÇó*/
+#define ZOSS_RAMDUMP_FILE_LINK_RSP 2 /*ͬ²½ÇëÇóÓ¦´ð,´«ÊäramdumpµÄÎļþÊýÄ¿*/
+#define ZOSS_RAMDUMP_FILE_FILE_REQ 3 /*ÇëÇó´«µÝÖ¸¶¨Îļþ±àºÅµÄÎļþÐÅÏ¢*/
+#define ZOSS_RAMDUMP_FILE_FILE_RSP 4 /*ÇëÇó´«µÝÖ¸¶¨Îļþ±àºÅµÄÎļþÐÅÏ¢µÄÓ¦´ð£¬´«ÊäÎļþÃû¼°´óС*/
+#define ZOSS_RAMDUMP_FILE_READ_REQ 5 /*ÇëÇó¶ÁÈ¡Ö¸¶¨Îļþ±àºÅµÄÎļþÄÚÈÝ*/
+#define ZOSS_RAMDUMP_FILE_READ_RSP 6 /*ÇëÇó¶ÁÈ¡Ö¸¶¨Îļþ±àºÅµÄÎļþÄÚÈݵÄÓ¦´ð£¬´«ÊäÎļþÄÚÈÝ*/
+#define ZOSS_RAMDUMP_FILE_END_REQ 7 /*´«Êä½áÊø*/
+#define ZOSS_RAMDUMP_FILE_END_RSP 8 /*´«Êä½áÊøÓ¦´ð*/
+
+/* ramdump×î´óÎļþÃû³¤¶È */
+#define ZOSS_RAMDUMP_FILENAME_LEN 32
+
+/* RamdumpÎļþµÄÃû×Ö */
+#define ZOSS_RAMDUMP_DIR_NAME "ramdump_dir"
+
+/* ´íÎóÀàÐÍ */
+#define ZOSS_RAMDUMP_FILE_CMD_FAIL 9 /*Ö¸Áî´íÎó*/
+#define ZOSS_RAMDUMP_FILE_NO_FAIL 10 /*ÇëÇó´«µÝÖ¸¶¨Îļþ±àºÅ´í*/
+#define ZOSS_RAMDUMP_FILE_LEN_FAIL 11 /*ÇëÇó´«µÝÖ¸¶¨ÎļþλÖôóС´í*/
+#define ZOSS_RAMDUMP_CMD_BUFFER_LEN 16 /*Ö¸ÁîÖ¡³¤¶È */
+
+/* ramdumpÄÚ´æ¿é´óСÅäÖÃ,ÐÞ¸ÄÅäÖÃʱעÒâÐÞ¸ÄserverºÍclientµÄ×ܹ²±ÈÀý´óС*/
+#define ZOSS_RAMDUMP_CMM_INFO_RATE 4
+#define ZOSS_RAMDUMP_CONFIGURED_REGION_RATE 4
+#define ZOSS_RAMDUMP_PARSED_REGION_RATE 4
+#define ZOSS_RAMDUMP_FILE_INFO_RATE 4
+#define ZOSS_RAMDUMP_AGENT_FILE_INFO_RATE 4
+#define ZOSS_RAMDUMP_ERR_INFO_RATE 1
+#define ZOSS_RAMDUMP_IO_READBUF_RATE 1
+#define ZOSS_RAMDUMP_IO_WRITEBUF_RATE 1
+#define ZOSS_RAMDUMP_SERVER_TOTAL_RATE 23
+#define ZOSS_RAMDUMP_CLIENT_TOTAL_RATE 17
+
+#define ZOSS_RAMDUMP_FLAG_SIZE 4
+#define ZOSS_RAMDUMP_FLAG_FIRST_VALUE 0x11111111
+#define ZOSS_RAMDUMP_FLAG_SECOND_VALUE 0x22222222
+#define ZOSS_RAMDUMP_FLAG_THIRD_VALUE 0x33333333
+#define ZOSS_RAMDUMP_FLAG_FOUR_VALUE 0x44444444
+
+/* ÏûÏ¢½»»¥ÀàÐÍ */
+#define ZOSS_RAMDUMP_INIT_TYPE 0
+#define ZOSS_RAMDUMP_EXCPT_TYPE 1
+#define ZOSS_RAMDUMP_DATA_READY_TYPE 2
+#define ZOSS_RAMDUMP_TEST_EXCPT_TYPE 3
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+typedef struct
+{
+ UINT32 cmmFileSize;
+ UINT32 cmmFileMaxSize;
+ CHAR cmmFileBuffer[0]; /* cmmÎļþ»º³å£¬ºóÃ滹Óпռä */
+} T_zOss_RamdumpCmmFileInfo;
+
+typedef struct
+{
+ UINT32 srcModId;
+ UINT32 desModId;
+ T_HalIcp_Dword intInfo;
+} T_zOss_RamdumpIcpInfo;
+
+typedef struct
+{
+ UINT32 clientId;
+ CHAR *pRamdumpStartAddr;
+ UINT32 ramdumpSize;
+} T_zOss_RamdumpClientConInfo;
+
+typedef struct
+{
+ CHAR fileName[ZOSS_RAMDUMP_FILENAME_LEN]; /* ÎļþÃû */
+ UINT32 baseforServer; /* server¶Ë¿ÉÒÔ·ÃÎʵĵØÖ· */
+ UINT32 size; /* ´óС */
+} T_zOss_RamdumpFile;
+
+typedef struct
+{
+ UINT32 fileNum; /* Îļþ¸öÊý */
+ UINT32 fileMaxNum; /* ÎļþµÄ×î´ó¸öÊý */
+ T_zOss_RamdumpFile fileInfo[0]; /* ºóÐø¿ÉÄÜ»¹ÓÐÊý¾Ý */
+} T_zOss_RamdumpFileInfo;
+
+typedef struct
+{
+ UINT32 buffLen; /* buffµÄ´óС */
+ CHAR *pBuff; /* buff µÄÖ¸Õë */
+} T_zOss_RamdumpBuffInfo;
+
+typedef struct
+{
+ UINT32 serverId;
+ CHAR *pRamdumpStartAddr;
+ UINT32 ramdumpSize;
+} T_zOss_RamdumpServerConInfo;
+
+/* ramdumpÏûÏ¢½á¹¹Ìå */
+typedef struct
+{
+ UINT32 regionNum;
+ UINT32 regionMaxNum;
+ T_zOss_RamdumpRegion regions[0]; /* ºóÐø¿ÉÄÜ»¹ÓÐÊý¾Ý */
+} T_zOss_RamdumpRegionInfo;
+
+typedef struct
+{
+ UINT32 msgType;
+ UINT32 Identifier;
+} T_zOss_RamdumpAgentMsgInfo;
+
+/* ͬ²½ÇëÇóÓ¦´ð */
+typedef struct
+{
+ UINT32 fileNum; /* Òª´«ÊäµÄÎļþ¸öÊý */
+} T_zOss_RamumpFileLinkRsp;
+
+/* ¿ªÊ¼Îļþ´«ÊäÇëÇóÏûÏ¢Ìå */
+typedef struct
+{
+ UINT32 fileNo; /* Îļþ±àºÅ,0¿ªÊ¼ */
+} T_zOss_RamdumpFileFileReq;
+
+/* ¿ªÊ¼Îļþ´«Êä»ØÓ¦ÏûÏ¢Ìå */
+typedef struct
+{
+ CHAR fileName[ZOSS_RAMDUMP_FILENAME_LEN]; /* ÎļþÃû */
+ UINT32 size; /* Îļþ´óС */
+} T_zOss_RamdumpFileFileRsp;
+
+/* ¶ÁÊý¾ÝÇëÇóÏûÏ¢Ìå */
+typedef struct
+{
+ UINT32 fileNo; /* Îļþ±àºÅ */
+ UINT32 offset; /* offsetΪÊý¾ÝÆ«ÒÆ */
+ UINT32 length; /* lengthΪÊý¾Ý³¤¶È */
+} T_zOss_RamdumpFileReadReq;
+
+typedef struct
+{
+ UINT32 msgType;
+ UINT32 srcModId;
+ CHAR *pRamdumpStartAddr;
+ UINT32 ramdumpSize;
+} T_zOss_RamdumpClientMsgInfo; /* ·¢ËÍÏûÏ¢ÀàÐÍ */
+
+typedef struct
+{
+ UINT32 msgType;
+ VOID *pServerConInfo;
+} T_zOss_RamdumpServerMsgInfo;
+
+typedef struct
+{
+ UINT32 clientId;
+ T_zOss_RamdumpCmmFileInfo *pCmmInfo;
+ T_zOss_RamdumpRegionInfo *pConfigureInfo;
+ T_zOss_RamdumpRegionInfo *pParsedInfo;
+ T_zOss_RamdumpBuffInfo *pErrInfo;
+ volatile UINT32 clientFlagBase;
+} T_zOss_RamdumpClientInfo;
+
+typedef struct
+{
+ UINT32 clientId;
+ T_zOss_RamdumpCmmFileInfo *pCmmInfo;
+ T_zOss_RamdumpRegionInfo *pConfigureInfo;
+ T_zOss_RamdumpRegionInfo *pParsedInfo;
+ T_zOss_RamdumpFileInfo *pFileInfo;
+ T_zOss_RamdumpFileInfo *pAgentFileInfo;
+ T_zOss_RamdumpBuffInfo *pErrInfo;
+ T_zOss_RamdumpBuffInfo *pIoReadbuf;
+ T_zOss_RamdumpBuffInfo *pIoWritebuf;
+ BOOL *pWaitMsgFlag;
+} T_zOss_RamdumpServerInfo;
+
+typedef struct
+{
+ BOOL exceptFlag; /* ÊÇ·ñ·¢Éú¹ýÒì³£ */
+ UINT32 exceptCore; /* ·¢ÉúÒì³£µÄºË */
+} T_zOss_RamdumpExceptInfo; /* Òì³£ÐÅÏ¢½á¹¹Ìå */
+
+#ifdef _USE_ARM1_RAMDUMP
+typedef struct
+{
+ UINT32 startAddr;
+ UINT32 endAddr;
+ UINT32 mapAddr;
+ UINT32 copyAddr;
+} T_zOss_RamdumpArm1Region;
+
+typedef struct
+{
+ UINT32 regionNum;
+ T_zOss_RamdumpArm1Region regions[0];
+} T_zOss_RadmumpArm1RegionInfo;
+#endif
+
+/**************************************************************************
+* º¯ÊýÉùÃ÷Çø
+**************************************************************************/
+VOID zOss_RamdumpEncodeError(CHAR *pBuff, UINT16 user_called, UINT16 ecode, UINT16 extra);
+VOID zOss_RamdumpCreateCmmFile(T_zOss_RamdumpCmmFileInfo *pCmmFileInfo);
+CHAR *zOss_RamdumpCreateRegionsCmmFile(CHAR *address);
+VOID zOss_RamdumpSaveRegisters(VOID);
+UINT32 zOss_CleanCache(VOID);
+VOID zOss_RamdumpInit(VOID);
+UINT32 zOss_RamdumpForceClientException(UINT32 coreId);
+VOID zOss_RamdumpHandle(UINT16 user_called, UINT16 ecode, UINT16 extra);
+VOID zOss_RamdumpSaveRegisters(VOID);
+UINT32 zOss_Cp15ReadControlRegister(VOID);
+UINT32 zOss_ReadCpsr(VOID);
+VOID zOss_RamdumpSetUsbOpt(VOID);
+VOID zOss_RamdumpSetIcpOpt(VOID);
+VOID zOss_RamdumpUsbInit(VOID);
+VOID zOss_RamdumpUsbReadData(UINT8 *buffer, UINT32 size);
+VOID zOss_RamdumpUsbWriteData(UINT8 *buffer, UINT32 size);
+VOID zOss_RamdumpUsbFinish(VOID);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿ÉùÃ÷Çø
+**************************************************************************/
+extern T_zOss_RamdumpOpt g_zRamdump_Optfunc;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _USE_MULTI_CORE_RAMDUMP */
+#endif /* _SUP_RAMDUMP_H */
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_shell.h b/cp/ps/plat/src/oss/sup/inc/sup_shell.h
new file mode 100644
index 0000000..7c5f054
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_shell.h
@@ -0,0 +1,76 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : sup_shell.h
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : shell¿ò¼ÜÍ·Îļþ
+* ×÷ Õß : ÖܹúÆÂ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2008-04-21
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001782014
+**************************************************************************/
+#ifndef _SUP_SHELL_H
+#define _SUP_SHELL_H
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+#include "sup.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#ifdef _OS_WIN
+#define __FUNCTION__ "FUNCTION"
+#endif
+
+#define SHELL_THREAD_NAME "zOss_ShellThread" /* ²âÊÔÏß³ÌÃû³Æ */
+#define T_Test_CommandMessage T_Shell_CommandMessage
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+typedef struct
+{
+ CHAR *cmd;
+ Shell_Func func;
+ CHAR *desc;
+}T_Shell_Cmd; /* ÃüÁî½á¹¹ */
+
+/**************************************************************************
+* º¯ÊýÉùÃ÷Çø
+**************************************************************************/
+SINT32 Shell_StrisNumber(const CHAR *pStr);
+SINT32 Shell_isIdentifier(const CHAR *pStr);
+UINT32 Shell_GetWintracePrintFlag(VOID);
+UINT32 Shell_SetPrintFlag(UINT32 WintraceFlag);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿ÉùÃ÷Çø
+**************************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SUP_SHELL_H */
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_shell_cmd.h b/cp/ps/plat/src/oss/sup/inc/sup_shell_cmd.h
new file mode 100644
index 0000000..9591a61
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_shell_cmd.h
@@ -0,0 +1,118 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : sup_shell_cmd.h
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ :
+* ×÷ Õß : ÖܹúÆÂ
+* °æ ±¾ : v1.0
+* Íê³ÉÈÕÆÚ : 2008-04-21
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001782014
+**************************************************************************/
+#ifndef _SUP_SHELL_CMD_H
+#define _SUP_SHELL_CMD_H
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_shell.h"
+#ifdef _OS_LINUX
+#include <linux/ctype.h>
+#else
+#include <ctype.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ³£Á¿¶¨ÒåÇø
+**************************************************************************/
+#define CHAR_PRT(c) (isgraph(c) ? (c) : '.')
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* º¯ÊýÉùÃ÷Çø
+**************************************************************************/
+/* »ù±¾ÃüÁî */
+extern VOID OSS_DbgShowBootInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgSetWintracePrintFlag(T_Shell_CommandMessage *CmdMsg);
+
+/* ÄÚ´æ¹Û²ì */
+extern VOID OSS_DbgShowMemInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgShowUbInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgShowThreadUbInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgShowTaskUbInfo(T_Shell_CommandMessage *CmdMsg);
+
+/* NV */
+extern VOID OSS_DbgShowNvInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgReadNv(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgWriteNv(T_Shell_CommandMessage *CmdMsg);
+
+/* µ÷¶ÈͨѶ */
+extern VOID OSS_DbgShowThreadInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgSuspendThread(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgResumeThread(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgSetThreadPri(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgShowTaskInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgShowMsg(T_Shell_CommandMessage *CmdMsg);
+
+/* Òì³£ */
+extern VOID OSS_DbgDisplayThreadExecInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgDisplayThreadsExecInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgSetUpdateCPUTime(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgThreadSetFlag(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgGetSysCPU(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgShowRegInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgRamdumpConfigRegionInfo(T_Shell_CommandMessage *CmdMsg);
+
+/* µ×²ãµ÷ÊÔÖ¸Áî */
+extern VOID OSS_DbgGetMem(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgSetMem(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgReboot(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSA_SetUBDbgSwitch(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSA_DbgMem(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSA_ForceRamdump(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSA_DbgMemTimeLeakInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSA_DbgMemInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSA_DbgUbInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSA_SetMemDbgSwitch(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSA_DbgTrace(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DbgProfile(T_Shell_CommandMessage * CmdMsg);
+extern VOID OSS_OpenTraceSwitch(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_SetAssertLevel(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_StartDaemonTask(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_PsmTraceInfo(T_Shell_CommandMessage *CmdMsg);
+extern VOID OSS_DfmTraceInfo(T_Shell_CommandMessage *CmdMsg);
+VOID Shell_ShowPoolInfo(T_Shell_CommandMessage *CmdMsg);
+VOID Shell_ShowProcSig(T_Shell_CommandMessage *CmdMsg);
+
+/**************************************************************************
+* È«¾Ö±äÁ¿ÉùÃ÷Çø
+**************************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SUP_SHELL_CMD_H */
+
+
diff --git a/cp/ps/plat/src/oss/sup/inc/sup_task.h b/cp/ps/plat/src/oss/sup/inc/sup_task.h
new file mode 100644
index 0000000..37d3ed8
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/inc/sup_task.h
@@ -0,0 +1,116 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : sup_task.h
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ :
+* ×÷ Õß : ¹¨Òí
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2007-09-12
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001782014
+**************************************************************************/
+#ifndef _SUP_TASK_H
+#define _SUP_TASK_H
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ³£Á¿¶¨ÒåÇø
+**************************************************************************/
+#define SCHE_MSG_MONI_ON (UINT8)1 /* ÈÎÎñÏûÏ¢¼à¿Ø */
+#define SCHE_MSG_MONI_OFF (UINT8)0 /* ÈÎÎñÏûÏ¢²»¼à¿Ø */
+#define SCHE_MAX_TICK (UINT32)0xffffffff /* ϵͳ×î´óTickÊý */
+
+/* ÈÎÎñÀàÐÍ */
+#define SCHE_OSS_TASK 1 /* ƽ̨ÈÎÎñ */
+#define SCHE_SDL_TASK 2 /* SDLÈÎÎñ */
+
+#ifdef _OS_WIN
+#define SCHE_printf printf
+#else
+#define _SUBMDL_ SUBMDL_SCHE
+#define _PRINT_LEVEL_ PRINT_LEVEL_NORMAL
+#define SCHE_printf(...) zOss_Printf(_SUBMDL_, _PRINT_LEVEL_, ##__VA_ARGS__)
+#endif
+
+#define ZOSS_CAPT_MSG 0
+#define ZOSS_SELF_MIMO 0
+
+/* ÏûÏ¢³¤¶È */
+#define SCHE_M_TASKMSGHEAD_LEN sizeof(T_ZOss_TaskMsgHead) /* ÏûϢͷ³¤¶È */
+#define SCHE_M_TASKMSGEX_LEN sizeof(T_ZOss_TaskMsg) /* ÏûÏ¢Ì峤¶È */
+
+/* µ÷¶ÈÏ̵߳ǼDZí */
+#define SCHE_THREAD_TAB \
+/* Ïß³ÌÃû Ïß³ÌID Ïß³ÌÓÅÏȼ¶ ¶ÀÕ¼±êÖ¾ */ \
+ {{0}, "zOss_ScheThread1", NULL, 10, 1, {0}, {0}, {0}}, \
+ {{0}, "zOss_ScheThread2", NULL, 11, 1, {0}, {0}, {0}}, \
+ {{0}, "zOss_ScheThread3", NULL, 12, 1, {0}, {0}, {0}}, \
+ {{0}, "zOss_ScheThread4", NULL, 13, 1, {0}, {0}, {0}}, \
+ {{0}, "zOss_ScheThread5", NULL, 14, 1, {0}, {0}, {0}}, \
+ {{0}, "zOss_ScheThread6", NULL, 15, 1, {0}, {0}, {0}}, \
+ {{0}, "zOss_ScheThread7", NULL, 16, 1, {0}, {0}, {0}}, \
+ {{0}, "zOss_ScheThread8", NULL, 17, 1, {0}, {0}, {0}}
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+/* SDLÏà¹Ø»Øµ÷º¯ÊýÀàÐÍ */
+typedef UINT32 (*Task_SEND_HOOK)(UINT32 msg_id, const VOID *buf, UINT16 msg_len, ZOSS_TASK_ID task_id, ZOSS_TASK_ID s_task_id);
+typedef UINT32 (*Task_SEND_DATA_HOOK)(UINT32 msg_id, VOID *buf, UINT16 msg_len, ZOSS_TASK_ID task_id, ZOSS_TASK_ID s_task_id);
+typedef UINT32 (*Task_GET_ALL_ID_HOOK)(ZOSS_TASK_ID *task_id_arr);
+typedef ZOSS_TASK_ID (*Task_GET_ID_HOOK)(const CHAR *task_name);
+typedef CHAR *(*Task_GET_THAKNAME_HOOK)(ZOSS_TASK_ID task_id);
+
+typedef struct
+{
+ T_ZOss_Node node; /* Ë«ÏòÁ´±í½áµã */
+ CHAR thread_name[ZOSS_MAX_TASKNAME_LEN + 1]; /* Ïß³ÌÃû£¬×64×Ö½Ú */
+ ZOSS_THREAD_ID thread_id; /* Ïß³ÌID */
+ UINT32 priority; /* Ïß³ÌÓÅÏȼ¶ */
+ UINT8 pno; /* ¶ÀÕ¼Ï̱߳ê־λ */
+ T_ZOss_List TCBReady; /* ¾ÍÐ÷ÈÎÎñÁ´±íÍ· */
+ T_ZOss_List TCBStopped; /* ×èÈûÈÎÎñÁ´±íÍ· */
+ T_ZOss_List TCBIdle; /* ¿ÕÏÐÈÎÎñÁ´±íÍ· */
+}T_ZOss_TRF; /* µ÷¶ÈÏ̵߳ǼDZí */
+
+/**************************************************************************
+* º¯ÊýÉùÃ÷Çø
+**************************************************************************/
+UINT32 Sche_SetTaskID(ZOSS_THREAD_ID threadId, VOID *taskId);
+VOID *Sche_GetTaskID(ZOSS_THREAD_ID threadId);
+
+/**************************************************************************
+* È«¾Ö±äÁ¿ÉùÃ÷Çø
+**************************************************************************/
+extern ZOSS_SEMAPHORE_ID gSche_SaticTaskInitSema;
+extern UINT32 gTask_TaskNum;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SUP_TASK_H */
+
+
diff --git a/cp/ps/plat/src/oss/sup/src/makefile b/cp/ps/plat/src/oss/sup/src/makefile
new file mode 100644
index 0000000..6186f80
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/makefile
@@ -0,0 +1,216 @@
+# /*****************************************************************************
+#* °æȨËùÓÐ(C) 2013 ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾
+#*
+#* ÎļþÃû³Æ: Makefile
+#* Îļþ±êʶ: Makefile
+#* ÄÚÈÝÕªÒª: ±àÒëtraceÄ£¿é
+#* ʹÓ÷½·¨:
+#*
+#* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+#* -----------------------------------------------------------------------------
+#* 2013/01/01 V1.0 001 P98G ´´½¨
+#*
+# *****************************************************************************/
+
+include $(PRJ_PATH)/config/project.mk
+
+#===============================================================================
+#·¾¶ÉèÖÃ
+#===============================================================================
+_MDL_NAME = sup
+
+_MDL_SRC_PATH = $(PLAT_PATH)/src/oss/sup/src
+_MDL_INC_PATH = $(PLAT_PATH)/src/oss/sup/inc
+_MDL_OBJ_PATH = $(OBJ_PATH)/plat/oss/$(_MDL_NAME)
+
+#===============================================================================
+#¸÷Ä£¿éÒÀÀµ¹«¹²Í·ÎļþÉèÖÃ
+#===============================================================================
+INCLUDE += -I$(PLAT_PATH)/inc \
+ -I$(PLAT_PATH)/inc/oss \
+ -I$(PLAT_PATH)/inc/drv \
+ -I$(PLAT_PATH)/src/oss/osa/inc \
+ -I$(DRV_PATH)/include \
+ -I$(COMMOM_PATH)/inc/config \
+ -I$(COMMOM_PATH)/inc/config/private \
+ -I$(COMMOM_PATH)/inc/config/public \
+ -I$(COMMOM_PATH)/inc/config/atcfg \
+ -I$(_MDL_INC_PATH)
+
+ifeq ($(OSTYPE),tos)
+INCLUDE += -I$(PLAT_PATH)/src/oss/osa/tos/inc \
+ -I$(PRJ_PATH)/config/os/tos
+endif
+
+ifeq ($(OSTYPE),linux)
+INCLUDE += -I$(PLAT_PATH)/src/oss/osa/linux/inc \
+ -I$(PRJ_PATH)/config/os/linux \
+ -I$(DRV_PATH)/inc/misc
+endif
+
+#===============================================================================
+#×ÓϵͳÀ©Õ¹¶¨Òå
+#===============================================================================
+DEFINE +=
+
+#===============================================================================
+#Ä£¿éÎļþÐÅÏ¢
+#===============================================================================
+ifeq ($(USE_MULTI_CORE_RAMDUMP), yes)
+
+ifeq ($(USE_SERVER_RAMDUMP), yes)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_ramdump_server.c)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_ramdump_comm.c)
+endif
+
+ifeq ($(USE_CLIENT_RAMDUMP), yes)
+#_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_ramdump_client.c)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/ramdump_v7.c)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/ramdump_client.c)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/ramdump_oss.c)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/ramdump_soc.c)
+ifeq ($(OSTYPE), tos)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/ramdump_client_tos_adapt.c)
+endif
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/ramdump_collect_server.c)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/ramdump_v7_asm.S)
+endif
+
+ifeq ($(CPU_ARCH), armv5)
+
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_ramdump_arm.c)
+
+ifeq ($(CMPL_TYPE), rvct)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm_rvct.S)
+endif
+
+ifeq ($(CMPL_TYPE), gcc_arm)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm.S)
+endif
+
+ifeq ($(CMPL_TYPE), gcc_arm_linux)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm.S)
+endif
+
+endif
+
+ifeq ($(CPU_ARCH), armv6)
+
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_ramdump_arm.c)
+
+ifeq ($(CMPL_TYPE), rvct)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm_rvct.S)
+endif
+
+ifeq ($(CMPL_TYPE), gcc_arm)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm.S)
+endif
+
+ifeq ($(CMPL_TYPE), gcc_arm_linux)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm.S)
+endif
+
+endif
+
+ifeq ($(CPU_ARCH), armv7-r)
+
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_ramdump_arm.c)
+
+ifeq ($(CMPL_TYPE), rvct)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm_rvct.S)
+endif
+
+ifeq ($(CMPL_TYPE), gcc_arm)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm.S)
+endif
+
+ifeq ($(CMPL_TYPE), gcc_arm_linux)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm.S)
+endif
+
+endif
+
+ifeq ($(CPU_ARCH), armv7-a)
+
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_ramdump_arm.c)
+
+ifeq ($(CMPL_TYPE), rvct)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm_rvct.S)
+endif
+
+ifeq ($(CMPL_TYPE), gcc_arm)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm.S)
+endif
+
+ifeq ($(CMPL_TYPE), gcc_arm_linux)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_arm_asm.S)
+endif
+
+endif
+
+ifeq ($(CPU_ARCH), armv6-m)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_ramdump_cortexm.c)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_cortexm_asm.S)
+endif
+
+ifeq ($(CPU_ARCH), ck610)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_ramdump_csky.c)
+_S_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_except_csky_asm.S)
+endif
+
+endif
+
+ifeq ($(USE_OSS_MIN), yes)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_assert.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_ramdump_client_lib.c)
+else
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_agent_entry.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_agent_osinfopack.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_agent_pcmessage.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_agent_status.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_agent_toolkit.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_agent_uemessage.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_crc.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_except.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_monitor.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_nvm.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_printf.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_ramlog.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_shell.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_sys.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_assert.c) \
+ $(wildcard $(_MDL_SRC_PATH)/sup_task.c)
+
+ifeq ($(USE_OSS_SHELL_THREAD), yes)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_shell_thread.c)
+endif
+
+ifeq ($(USE_OSS_SHELL_MEM), yes)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_shell_mem.c)
+endif
+
+ifeq ($(USE_OSS_SHELL_PSM), yes)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_shell_psm.c)
+endif
+
+ifeq ($(USE_OSS_SHELL_MISC), yes)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_shell_misc.c)
+endif
+
+ifeq ($(USE_VSIM), yes)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_vsim.c)
+endif
+
+ifeq ($(USE_VSIM_AGT), yes)
+_C_SOURCE += $(wildcard $(_MDL_SRC_PATH)/sup_vsim_agt.c)
+endif
+
+endif
+
+_s_SOURCE =
+
+#===============================================================================
+# ±àÒë¹æÔò
+#===============================================================================
+include $(FRAME_PATH)/rules/mdl_rules.mk
+
diff --git a/cp/ps/plat/src/oss/sup/src/ramdump_client.c b/cp/ps/plat/src/oss/sup/src/ramdump_client.c
new file mode 100644
index 0000000..399c9ce
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/ramdump_client.c
@@ -0,0 +1,420 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_client.c
+* Îļþ±êʶ: ramdump_client.c
+* ÄÚÈÝÕªÒª: ramdump¿Í»§¶ËÒì³£ËÀ»úÏÖ³¡Êý¾Ýµ¼³öʵÏÖ
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/6/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+#include "ramdump_pub.h"
+#include "ramdump_oss.h"
+#ifdef __USE_CLIENT_WITH_COLLECT__
+#include "ramdump_collect_server.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+* Íⲿ±äÁ¿¶¨Òå *
+*******************************************************************************/
+#ifdef _OS_TOS
+extern void ramdump_open_tcm_clock(void);
+#else
+void ramdump_open_tcm_clock(void){}
+#endif
+
+/*******************************************************************************
+* ³£Á¿¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+
+#define RAMDUMP_ON_DEFAULT_VAL (1)
+
+#define RAMDUMP_CLIENT_SUCCESS (RAMDUMP_SUCCESS)
+#define RAMDUMP_CLIENT_FAILED (RAMDUMP_FAILED)
+
+#define RAMDUMP_CLIENT_CMM_SCRNAME "client_cmm.cmm"
+#define RAMDUMP_CLIENT_ERR_LOG "client_error_log.txt"
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¾Ö²¿¾²Ì¬±äÁ¿¶¨Òå *
+*******************************************************************************/
+
+static int ramdump_client_init_flag = RAMDUMP_FALSE;
+static int ramdump_count;
+
+/* client ram conf table */
+static ramdump_ram_config_t ramdump_client_ram_conf[RAMDUMP_RAMCONF_TABLE_MAX_ENTRYS];
+/* client ram conf data done flag*/
+static unsigned long ramdump_client_ram_conf_done_flag = RAMDUMP_SYNC_RESET;
+
+/* Cmm file content */
+static char ramdump_client_cmm_buf[RAMDUMP_CMM_SIZE];
+/* */
+static char ramdump_client_errno_log[RAMDUMP_ERROR_LOG_SIZE];
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_client_copy_data
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used to copy some data to the addr
+*******************************************************************************/
+static void ramdump_client_copy_data(void)
+{
+ unsigned long i_ram_conf = 0;
+
+ while (ramdump_client_ram_conf[i_ram_conf].phy != 0 &&
+ ramdump_client_ram_conf[i_ram_conf].size != 0)
+ {
+ if (ramdump_client_ram_conf[i_ram_conf].flag == RAMDUMP_FLAG_NEED_COPY &&
+ ramdump_client_ram_conf[i_ram_conf].copy != 0 &&
+ (ramdump_client_ram_conf[i_ram_conf].phy != ramdump_client_ram_conf[i_ram_conf].copy))
+ {
+ memcpy(
+ (int *)ramdump_client_ram_conf[i_ram_conf].copy,
+ (int *)ramdump_client_ram_conf[i_ram_conf].phy,
+ ramdump_client_ram_conf[i_ram_conf].size);
+ }
+ i_ram_conf++;
+ }
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_client_cmm_and_log_recalc
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used to create err log file
+*******************************************************************************/
+static void ramdump_client_cmm_and_log_recalc(void)
+{
+ unsigned long i_ram_conf = 0;
+
+ while (ramdump_client_ram_conf[i_ram_conf].phy != 0 &&
+ ramdump_client_ram_conf[i_ram_conf].size != 0)
+ {
+ if (ramdump_client_ram_conf[i_ram_conf].phy == (unsigned long)ramdump_client_cmm_buf)
+ ramdump_client_ram_conf[i_ram_conf].size = strlen(ramdump_client_cmm_buf);
+ else if (ramdump_client_ram_conf[i_ram_conf].phy == (unsigned long)ramdump_client_errno_log)
+ ramdump_client_ram_conf[i_ram_conf].size = strlen(ramdump_client_errno_log);
+
+ i_ram_conf++;
+ }
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_client_error_log_create
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used to create err log file
+*******************************************************************************/
+static void ramdump_client_error_log_create(void)
+{
+ int offset = 0;
+ unsigned long *first_dump_cpu_id = ramdump_get_first_dump_cpu_id();
+
+#ifdef __USE_CLIENT_WITH_COLLECT__
+
+ offset = sprintf(
+ ramdump_client_errno_log,
+ "core [%s] exact error!\n",
+ ramdump_cpu_name[*first_dump_cpu_id]);
+
+#endif
+
+ ramdump_oss_error_log_creat(ramdump_client_errno_log + offset);
+
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_client_store_ram_conf
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) mem: addr
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigend char*: changed addr
+* ÆäËü˵Ã÷: This function is used to store ram conf
+*******************************************************************************/
+static char *ramdump_client_store_ram_conf(char *mem)
+{
+ unsigned long i_ram_conf = 0;
+
+ while ((ramdump_client_ram_conf[i_ram_conf].vir != 0) &&
+ (ramdump_client_ram_conf[i_ram_conf].size != 0))
+ {
+ ramdump_ram_config_t *config_entry = &ramdump_client_ram_conf[i_ram_conf];
+ if ((config_entry->phy == (unsigned long)ramdump_client_cmm_buf) ||
+ (config_entry->phy == (unsigned long)ramdump_client_errno_log))
+ {
+ i_ram_conf++;
+ continue;
+ }
+ if(config_entry->callback == NULL ||
+ (config_entry->callback != NULL &&
+ (*(config_entry->callback))() == RAMDUMP_TRUE))
+ mem += sprintf(
+ mem,
+ "data.load.binary &ramdump_dir\\%s 0x%lx--0x%lx /noclear\n",
+ config_entry->name,
+ config_entry->phy,
+ (config_entry->phy + config_entry->size));
+ i_ram_conf++;
+ }
+
+ return mem;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_client_cmm_create
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for client to generate cmm scripts
+*******************************************************************************/
+static void ramdump_client_cmm_create(void)
+{
+ char *pcmm_buf = ramdump_client_cmm_buf;
+
+ // store the cmm BEGIN
+ pcmm_buf += sprintf(pcmm_buf, "ENTRY &ramdump_dir\n");
+ // store procmodes regs
+ pcmm_buf = ramdump_arch_store_modes_regs(pcmm_buf);
+ // store ram config
+ pcmm_buf = ramdump_client_store_ram_conf(pcmm_buf);
+ // store memory map control regs
+ pcmm_buf = ramdump_arch_store_mm_regs(pcmm_buf);
+ // store end symbol
+ pcmm_buf += sprintf(pcmm_buf, "ENDDO\n");
+}
+
+/*******************************************************************************
+* È«¾Öº¯ÊýʵÏÖ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_ram_conf_table_add
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) ram_name: dump ram name
+ ram_start: dump ram start(virtual addr)
+ ram_size: dump ram size
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used to add dump ram conf into public table
+*******************************************************************************/
+void ramdump_ram_conf_table_add(
+ char *ram_name,
+ unsigned long ram_phy,
+ unsigned long ram_size,
+ unsigned long ram_virt,
+ unsigned long ram_flag,
+ unsigned long ram_extra)
+{
+ static int i_entry = 0;
+
+ if ((ram_phy == 0) && (ram_size == 0))
+ return;
+
+ strncpy(ramdump_client_ram_conf[i_entry].name,
+ ram_name,
+ RAMDUMP_RAMCONF_FILENAME_MAXLEN);
+ ramdump_client_ram_conf[i_entry].phy = ram_phy;
+ ramdump_client_ram_conf[i_entry].size = ram_size;
+ ramdump_client_ram_conf[i_entry].vir = ram_virt;
+ ramdump_client_ram_conf[i_entry].flag = ram_flag;
+
+ switch (ram_flag)
+ {
+ case RAMDUMP_FLAG_NEED_COPY:
+ ramdump_client_ram_conf[i_entry].copy = ram_extra;
+ break;
+ case RAMDUMP_FLAG_HAS_EXTERNAL:
+ ramdump_client_ram_conf[i_entry].exter = ram_extra;
+ break;
+ case RAMDUMP_FLAG_HAS_CALLBACK:
+ ramdump_client_ram_conf[i_entry].callback = (ramdump_callback_t)ram_extra;
+ break;
+ default:
+ break;
+ }
+
+ if (i_entry < RAMDUMP_RAMCONF_TABLE_MAX_ENTRYS - 1)
+ i_entry++;
+ else
+ i_entry = 0;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_init
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: RAMDUMP_SUCCESS
+* ÆäËü˵Ã÷: This function is used for ramdump init
+*******************************************************************************/
+int ramdump_init(void)
+{
+ int ret = 0;
+ unsigned long *first_dump_cpu_id = 0;
+ ramdump_ram_config_sync_msg_t msg = {0};
+ char bin_name[RAMDUMP_RAMCONF_FILENAME_MAXLEN] = {0};
+
+ if (ramdump_client_init_flag == RAMDUMP_TRUE)
+ return RAMDUMP_SUCCESS;
+
+#ifdef __USE_CLIENT_WITH_COLLECT__
+
+ ret = ramdump_collect_server_icp_init();
+ if (ret != RAMDUMP_ICP_SUCCESS)
+ return ret;
+ ramdump_get_collect_server_ram_conf(&msg);
+ msg.array[RAMDUMP_CPU_0].array = ramdump_client_ram_conf;
+ msg.array[RAMDUMP_CPU_0].nr = RAMDUMP_RAMCONF_TABLE_MAX_ENTRYS;
+ msg.array[RAMDUMP_CPU_0].done_flag = &ramdump_client_ram_conf_done_flag;
+ /* default except core (the core with collect server)*/
+ first_dump_cpu_id = ramdump_get_first_dump_cpu_id();
+ *first_dump_cpu_id = RAMDUMP_CPU_0;
+
+ /* set client ram data done flag */
+ ramdump_client_ram_conf_done_flag = RAMDUMP_SYNC_RAM_CONFIG_DONE;
+
+ /*
+ * clean all the caches to make sure all data in ddr
+ */
+ ramdump_arch_clean_caches();
+
+#endif //#ifdef __USE_CLIENT_WITH_COLLECT__
+
+ /* generate dump name prefix */
+ sprintf(
+ bin_name,
+ "%s-%s",
+ ramdump_cpu_name[RAMDUMP_CPU_0],
+ RAMDUMP_CLIENT_ERR_LOG);
+ ramdump_ram_conf_table_add(
+ bin_name,
+ (unsigned long)ramdump_client_errno_log,
+ RAMDUMP_ERROR_LOG_SIZE,
+ 0,
+ 0,
+ 0);
+ /* generate dump name prefix */
+ memset(bin_name, 0, sizeof(bin_name));
+ sprintf(
+ bin_name,
+ "%s-%s",
+ ramdump_cpu_name[RAMDUMP_CPU_0],
+ RAMDUMP_CLIENT_CMM_SCRNAME);
+ ramdump_ram_conf_table_add(
+ bin_name,
+ (unsigned long)ramdump_client_cmm_buf,
+ RAMDUMP_CMM_SIZE,
+ 0,
+ 0,
+ 0);
+
+ OSS_PRINTF("Ramdump client init success!\n");
+ ramdump_client_init_flag = RAMDUMP_TRUE;
+
+ return RAMDUMP_SUCCESS;
+}
+OSS_INIT(ramdump_init);
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_client_entry
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for client ramdump entry
+*******************************************************************************/
+void ramdump_client_entry (void)
+{
+ unsigned long flags;
+
+ if (!ramdump_client_init_flag)
+ return;
+
+ if (++ramdump_count > 1)
+ while(TRUE); /* endless circle */
+
+ /*
+ * we need lock the irq, this can`t be interrupt.
+ */
+ OSS_LOCK(flags);
+
+ /*
+ * save all regs first.
+ */
+ ramdump_arch_save_all_regs();
+
+ /* open tcm clock */
+ ramdump_open_tcm_clock();
+
+ /* t32 cmm scripts */
+ ramdump_client_cmm_create();
+ /* err info file */
+ ramdump_client_error_log_create();
+
+ /* special data copy to the copy addr
+ * then other core read from the copy addr
+ */
+ ramdump_client_copy_data();
+ /* recalc client cmm and err_log size */
+ ramdump_client_cmm_and_log_recalc();
+ /* set client ram data done flag */
+ ramdump_client_ram_conf_done_flag = RAMDUMP_SYNC_RAM_CONTENT_DONE;
+
+ /* clean all the caches to make sure all data in ddr */
+ ramdump_arch_clean_caches();
+
+#ifdef __USE_CLIENT_WITH_COLLECT__
+ ramdump_collect_server_notify_clients_dump();
+#endif
+
+ /*
+ * TODO!
+ * now endless circle, e.g., config restart or not is more better.
+ */
+ while (TRUE);
+
+ OSS_UNLOCK(flags);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/ramdump_client_tos_adapt.c b/cp/ps/plat/src/oss/sup/src/ramdump_client_tos_adapt.c
new file mode 100644
index 0000000..ecb44c5
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/ramdump_client_tos_adapt.c
@@ -0,0 +1,250 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_client_tos_adapt.c
+* Îļþ±êʶ: ramdump_client_tos_adapt.c
+* ÄÚÈÝÕªÒª: ramdump¿Í»§¶ËÒÀÀµÌض¨²Ù×÷ϵͳTOSµÄÊÊÅä´úÂë
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/6/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+#include "ramdump_pub.h"
+#include "ramdump_oss.h"
+#include "ramdump_collect_server.h"
+
+#include "sys_func_atcfg.h"
+#include "drvs_sys.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+* Íⲿº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+extern void ramdump_client_entry (void);
+extern VOID zDrvWdt_Stop(VOID);
+extern int ramdump_init(void);
+extern SINT32 zSys_ExceptReboot(UINT32 except_cpu);
+
+/*******************************************************************************
+* ³£Á¿¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+
+#define RAMDUMP_CLIENT_BIN_DEFNAME "client_"
+#define RAMDUMP_CLIENT_INIT_RSP_DONE (0x68797869) /* 68:D 79:O 78:N 69:E */
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¾Ö²¿¾²Ì¬±äÁ¿¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Öº¯ÊýʵÏÖ *
+*******************************************************************************/
+
+/* just adapt code for tos.
+ * TODO!
+ * will be delete in the future.
+ */
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: zOss_RamdumpInit
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for ramdump init
+*******************************************************************************/
+void zOss_RamdumpInit(void)
+{
+ T_ZDrvSys_PowerOn_Type powOnType;
+ unsigned long *client_done_flag;
+ ramdump_init();
+
+ //powOnType = zDrvComm_GetPowerOnState();
+ //if(POWER_ON_FOTA == powOnType || POWER_ON_CHARGING == powOnType)
+ // return;
+
+ /* set phy done flag*/
+ client_done_flag = ramdump_get_client_init_rsp();
+ client_done_flag[RAMDUMP_CPU_2] = RAMDUMP_CLIENT_INIT_RSP_DONE;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: zOss_RamdumpConfigureMem
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) regionInfo: dump ram config
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for ramdump config dump ram
+*******************************************************************************/
+VOID zOss_RamdumpConfigureMem(T_zOss_RamdumpRegion *regionInfo)
+{
+ char ram_name[RAMDUMP_RAMCONF_FILENAME_MAXLEN] = {0};
+ /* generate dump name prefix */
+ sprintf(ram_name,
+ "%s-%s0x%lx.bin",
+ ramdump_cpu_name[RAMDUMP_CPU_0],
+ RAMDUMP_CLIENT_BIN_DEFNAME,
+ regionInfo->baseForSelf);
+ if (regionInfo->baseForCopy != 0 &&
+ regionInfo->baseForCopy != regionInfo->baseForSelf)
+ ramdump_ram_conf_table_add(
+ ram_name,
+ regionInfo->baseForSelf,
+ regionInfo->size,
+ 0,
+ RAMDUMP_FLAG_NEED_COPY,
+ regionInfo->baseForCopy);
+ else if (regionInfo->baseForServer != 0 &&
+ regionInfo->baseForServer != regionInfo->baseForSelf)
+ ramdump_ram_conf_table_add(
+ ram_name,
+ regionInfo->baseForSelf,
+ regionInfo->size,
+ 0,
+ RAMDUMP_FLAG_HAS_EXTERNAL,
+ regionInfo->baseForServer);
+ else
+ ramdump_ram_conf_table_add(
+ ram_name,
+ regionInfo->baseForSelf,
+ regionInfo->size,
+ 0,
+ RAMDUMP_FLAG_NONE,
+ 0);
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: zOss_RamdumpHandle
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) user_called: not used
+ ecode: not used
+ extra: not used
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for enter ramdump
+*******************************************************************************/
+VOID zOss_RamdumpHandle(UINT16 user_called, UINT16 ecode, UINT16 extra)
+{
+ static UINT32 excepNum = 0;
+ ZOSS_INTR old_intr;
+
+ ZOSS_SAVE_IRQ(old_intr);
+ if(++excepNum > 1) /* Ö»±£´æµÚÒ»´Î³ö´íÏÖ³¡ */
+ {
+ for ( ; ; ) ;
+ }
+
+ if (zOss_GetExceptResetFlag() != EXCEPT_RESET_ENABLE)
+ {
+#ifdef _WDT_RST
+ zDrvWdt_Stop();
+#endif
+ /* Ö´ÐÐramdumpÒì³£´¦Àíº¯Êý */
+ ramdump_client_entry();
+ for ( ; ; ) ;
+ }
+ else
+ {
+ //except_RecordExceptInfo(s_zRamdump_ServerCfgInfo.serverId);
+ zSys_ExceptReboot((*ramdump_get_first_dump_cpu_id()));
+ }
+
+ ZOSS_RESTORE_IRQ(old_intr);
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: zOss_RamdumpForceClientException
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) coreId: core id
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: SUCCESS
+* ÆäËü˵Ã÷: This function is used for forced ramdump
+*******************************************************************************/
+UINT32 zOss_RamdumpForceClientException(UINT32 coreId)
+{
+ OSS_PANIC(RAMDUMP_TRUE);
+ return RAMDUMP_SUCCESS;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: Osa_SysErrHndInit
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) VOID
+* (´«³ö²ÎÊý) VOID
+* ·µ »Ø Öµ: VOID
+* ÆäËü˵Ã÷: This function is used for Osa_SysErrHndInit
+*******************************************************************************/
+VOID Osa_SysErrHndInit(VOID)
+{
+
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£º ramdump_ProcessMsgFromZsp
+ * ¹¦ÄÜÃèÊö£º server ´¦ÀízspµÄICPÏûÏ¢º¯Êý
+ * ²ÎÊý˵Ã÷£º
+* (´«Èë²ÎÊý) pMsg: ic msg buf
+* (´«³ö²ÎÊý) void
+ * ·µ »Ø Öµ£º void
+ * ÆäËü˵Ã÷£º void
+**************************************************************************/
+VOID zOss_Ramdump_ProcessMsgFromZsp(VOID *buf, UINT32 len)
+{
+ UINT32 *first_dump_cpu_id = ramdump_get_first_dump_cpu_id();
+
+ OSS_PRINTF("Ramdump client ps recevived forced dump request from zsp!\n");
+
+ *first_dump_cpu_id = RAMDUMP_CPU_2;
+ zOss_RamdumpHandle(1, 1, 1);
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_open_tcm_clock
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) VOID
+* (´«³ö²ÎÊý) VOID
+* ·µ »Ø Öµ: VOID
+* ÆäËü˵Ã÷: This function is used for open tcm clock
+*******************************************************************************/
+void ramdump_open_tcm_clock(void)
+{
+#ifdef _USE_TCM
+ if (!zDrvSysClk_IsEnable(CLK_FROMMATIRX_ACLK))
+ zDrvSysClk_SetGate(CLK_FROMMATIRX_ACLK, SYSCLK_ENABLE);
+ if (!zDrvSysClk_IsEnable(CLK_AXI2AXI_APB_AS_FOR_TCM))
+ zDrvSysClk_SetGate(CLK_AXI2AXI_APB_AS_FOR_TCM, SYSCLK_ENABLE);
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/ramdump_collect_server.c b/cp/ps/plat/src/oss/sup/src/ramdump_collect_server.c
new file mode 100644
index 0000000..e9a5809
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/ramdump_collect_server.c
@@ -0,0 +1,405 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_collect_server.c
+* Îļþ±êʶ: ramdump_collect_server.c
+* ÄÚÈÝÕªÒª: ramdump collect·þÎñ¶ËÊý¾ÝÊÕ¼¯´«µÝʵÏÖ
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/6/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+#include "ramdump_pub.h"
+#include "ramdump_oss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+* Íⲿº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+#ifdef _OS_TOS
+extern VOID zOss_Ramdump_ProcessMsgFromZsp(const T_HalIcp_Msg *pMsg);
+#endif
+
+/*******************************************************************************
+* ³£Á¿¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+
+#define RAMDUMP_ARRAY_BEG(arr) &(arr[0])
+#define RAMDUMP_ARRAY_END(arr) &(arr[RAMDUMP_ARRAY_NR(arr)])
+
+#define RAMDUMP_WAIT_CLIENT_TIMELEN (200) /* like before,just a value roughly */
+#define RAMDUMP_SLEEP_TIME (5) /* 5 ms */
+
+#define RAMDUMP_CLIENT_INIT_RSP_DONE (0x68797869) /* 68:D 79:O 78:N 69:E */
+#define RAMDUMP_CALLBACK_INIT_DONE 1
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+typedef int (*ramdump_initcall_t)(void);
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+static int ramdump_cpu1_icp_init(void);
+static int ramdump_cpu2_icp_init(void);
+
+/*******************************************************************************
+* ¾Ö²¿¾²Ì¬±äÁ¿¶¨Òå *
+*******************************************************************************/
+
+/* store collect ram config */
+static ramdump_ram_config_msg_t ramdump_collected_ram_conf_tables[RAMDUMP_CPU_MAX];
+
+/* store client icp init fun, expandable */
+static ramdump_initcall_t ramdump_client_icp_initcalls[RAMDUMP_CPU_MAX] =
+{NULL, ramdump_cpu1_icp_init,ramdump_cpu2_icp_init};
+
+/* first except cpu id */
+static unsigned long ramdump_except_cpu_id;
+
+/* init rsp done flag for all clients */
+static volatile unsigned long ramdump_client_init_rsp[RAMDUMP_CPU_MAX];
+
+static volatile long ramdump_callback_init_rsp[RAMDUMP_CPU_MAX];
+
+static volatile int ramdumpCfgFinished;
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_icp_to_collect_server_handle
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) buf: icp msg point
+* len: icp msg length
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for ramdump client icp msg handle, common entry
+*******************************************************************************/
+static void ramdump_icp_to_collect_server_handle(
+ void *buf,
+ unsigned int len)
+{
+ ramdump_msg_t *icp_msg;
+
+ icp_msg = buf;
+
+ switch(icp_msg->msg_id)
+ {
+ case RAMDUMP_MSG_INIT_RSP:
+ {
+ ramdump_ram_config_msg_t *table_entry = &(ramdump_collected_ram_conf_tables[icp_msg->cpu_id]);
+
+ /* invalid cpu id */
+ if ((icp_msg->cpu_id < RAMDUMP_CPU_0) ||
+ (icp_msg->cpu_id >= RAMDUMP_CPU_MAX))
+ while (RAMDUMP_TRUE);
+
+ /* client ram conf collect */
+ table_entry->array = icp_msg->msg_data_t.ram_config.array;
+ table_entry->nr = icp_msg->msg_data_t.ram_config.nr;
+ table_entry->done_flag = icp_msg->msg_data_t.ram_config.done_flag;
+
+ ramdump_client_init_rsp[icp_msg->cpu_id] = RAMDUMP_CLIENT_INIT_RSP_DONE;
+
+ break;
+ }
+
+ case RAMDUMP_MSG_EXCEPT:
+ {
+#ifndef __USE_TRANS_WITH_COLLECT__
+
+ if (ramdump_except_cpu_id == 0)
+ ramdump_except_cpu_id = icp_msg->cpu_id;
+
+#endif
+
+ OSS_PANIC("collect server received forced dump request from client!\n");
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_cpu1_icp_init
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: SUCCESS or FAILED
+* ÆäËü˵Ã÷: This function is used for ramdump client1 icp init (now is cp)
+*******************************************************************************/
+static int ramdump_cpu1_icp_init(void)
+{
+ int ret = 0;
+
+ ret = ramdump_oss_icp_create_channel(
+ ramdump_cpu_id[RAMDUMP_CPU_1],
+ ramdump_cpu_ch[RAMDUMP_CPU_1],
+ RAMDUMP_CHANNEL_SIZE);
+ if (ret != RAMDUMP_SUCCESS)
+ return ret;
+
+ ret = ramdump_oss_icp_regcallback(
+ ramdump_cpu_id[RAMDUMP_CPU_1],
+ ramdump_cpu_ch[RAMDUMP_CPU_1],
+ (ramdump_oss_icp_callback)ramdump_icp_to_collect_server_handle);
+ if (ret != RAMDUMP_SUCCESS)
+ return ret;
+
+ return RAMDUMP_SUCCESS;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_cpu2_icp_init
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: SUCCESS or FAILED
+* ÆäËü˵Ã÷: This function is used for ramdump client2 icp init (now is zsp)
+*******************************************************************************/
+static int ramdump_cpu2_icp_init(void)
+{
+ int ret = 0;
+
+ ret = ramdump_oss_icp_create_channel(
+ ramdump_cpu_id[RAMDUMP_CPU_2],
+ ramdump_cpu_ch[RAMDUMP_CPU_2],
+ 0x40);
+ if (ret != RAMDUMP_SUCCESS)
+ return ret;
+
+#ifdef _OS_TOS
+
+ ret = ramdump_oss_icp_regcallback(
+ ramdump_cpu_id[RAMDUMP_CPU_2],
+ ramdump_cpu_ch[RAMDUMP_CPU_2],
+ (ramdump_oss_icp_callback)zOss_Ramdump_ProcessMsgFromZsp);
+
+#else
+
+ ret = ramdump_oss_icp_regcallback(
+ ramdump_cpu_id[RAMDUMP_CPU_2],
+ ramdump_cpu_ch[RAMDUMP_CPU_2],
+ (ramdump_oss_icp_callback)ramdump_icp_to_collect_server_handle);
+
+#endif
+
+ if (ret != RAMDUMP_SUCCESS)
+ return ret;
+
+ return RAMDUMP_SUCCESS;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_cpu_id_init
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for collect server to init cpu_id
+*******************************************************************************/
+static void ramdump_cpu_id_init(void)
+{
+ /* init interactive cpu id */
+#ifdef __USE_CLIENT_WITH_COLLECT__
+ ramdump_cpu_id[RAMDUMP_CPU_1] = ICP_MSG_ACTOR_A9;
+ ramdump_cpu_id[RAMDUMP_CPU_2] = ICP_MSG_ACTOR_ZSP;
+ ramdump_cpu_ch[RAMDUMP_CPU_1] = RAMDUMP;
+ ramdump_cpu_ch[RAMDUMP_CPU_2] = RP_MSG_PS_PHY_RAMDUMP;
+#endif
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_icp_callback_init
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for collect server to init callback
+*******************************************************************************/
+static void ramdump_icp_callback_init(void)
+{
+ int index;
+ for (index = 0; index < RAMDUMP_CPU_MAX; index++)
+ {
+ if (ramdump_client_icp_initcalls[index] != NULL)
+ {
+ if (ramdump_client_icp_initcalls[index]() == RAMDUMP_ICP_SUCCESS)
+ ramdump_callback_init_rsp[index] = RAMDUMP_CALLBACK_INIT_DONE;
+ }
+ }
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_collect_server_thread_entry
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) arg: thread entry arguments
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for ramdump collect server icp init entry
+*******************************************************************************/
+static void ramdump_collect_server_thread_entry(int arg)
+{
+ int index = 0;
+ ramdump_msg_t icp_msg = {0};
+ ramdump_msg_t icp_msg_sync = {0};
+
+ for (index = 0; index < RAMDUMP_CPU_MAX; index++)
+ {
+ if (ramdump_callback_init_rsp[index] == RAMDUMP_CALLBACK_INIT_DONE)
+ {
+ /* init request */
+ icp_msg.msg_id = RAMDUMP_MSG_INIT_REQ;
+ icp_msg.cpu_id = ramdump_cpu_id[RAMDUMP_CPU_0]; /* collect server cpu_id */
+ /* send init req until success */
+ while (ramdump_oss_icp_send(&icp_msg, ramdump_cpu_id[index], ramdump_cpu_ch[index]) != RAMDUMP_ICP_SUCCESS)
+ OSS_SLEEP(RAMDUMP_SLEEP_TIME);//sleep 1 ms
+ /* wait init rsp until done */
+ while (ramdump_client_init_rsp[index] != RAMDUMP_CLIENT_INIT_RSP_DONE)
+ OSS_SLEEP(RAMDUMP_SLEEP_TIME);//sleep 1 ms
+ }
+ }
+
+#ifndef __USE_TRANS_WITH_COLLECT__
+
+ /* sync with trans server */
+ icp_msg_sync.msg_id = RAMDUMP_MSG_SYNC;
+ icp_msg_sync.cpu_id = ramdump_cpu_id[RAMDUMP_CPU_0]; /* collect server cpu_id */
+
+ icp_msg_sync.msg_data_t.ram_config_sync.array = ramdump_collected_ram_conf_tables;
+ icp_msg_sync.msg_data_t.ram_config_sync.nr = RAMDUMP_CPU_MAX;
+
+ while (!ramdumpCfgFinished || ramdump_oss_icp_send(&icp_msg_sync, ramdump_cpu_id[RAMDUMP_CPU_1], ramdump_cpu_ch[RAMDUMP_CPU_1]) != RAMDUMP_ICP_SUCCESS)
+ OSS_SLEEP(RAMDUMP_SLEEP_TIME);//sleep 1 ms
+
+ /* resolve trans server modify will be covered by caches */
+ ramdump_arch_clean_and_invalid_caches();
+#endif
+}
+
+/*******************************************************************************
+* È«¾Öº¯ÊýʵÏÖ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_config_finished
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is called for ramdump config finished
+*******************************************************************************/
+void ramdump_config_finished(void)
+{
+ ramdumpCfgFinished = 1;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_collect_server_icp_init
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: SUCCESS
+* ÆäËü˵Ã÷: This function is used for ramdump client icp init
+*******************************************************************************/
+int ramdump_collect_server_icp_init(void)
+{
+ ramdump_cpu_id_init();
+
+ ramdump_icp_callback_init();
+
+ /* create thread sync cpu init */
+ OSS_CREATE_THREAD("collect_server_sync_thread",(ramdump_oss_thread_entry_t)ramdump_collect_server_thread_entry);
+
+ return RAMDUMP_ICP_SUCCESS;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_collect_server_notify_clients_dump
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for ramdump client icp init
+*******************************************************************************/
+void ramdump_collect_server_notify_clients_dump(void)
+{
+ int cpu_id = 1;
+ ramdump_msg_t icp_msg = {0};
+
+ while (cpu_id < RAMDUMP_CPU_MAX)
+ {
+ /* init request */
+ icp_msg.msg_id = RAMDUMP_MSG_EXCEPT;
+ icp_msg.cpu_id = ramdump_cpu_id[RAMDUMP_CPU_0]; /* collect server cpu_id */
+ ramdump_oss_icp_send(&icp_msg, ramdump_cpu_id[cpu_id], ramdump_cpu_ch[cpu_id]);
+ cpu_id++;
+ }
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_get_collect_server_ram_conf
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) msg: ram_conf
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for ramdump client icp init
+*******************************************************************************/
+void ramdump_get_collect_server_ram_conf(ramdump_ram_config_sync_msg_t *msg)
+{
+ msg->array = ramdump_collected_ram_conf_tables;
+ msg->nr = RAMDUMP_CPU_MAX;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_get_first_dump_cpu_id
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long*: cpu id address
+* ÆäËü˵Ã÷: This function is used for ramdump client icp init
+*******************************************************************************/
+unsigned long * ramdump_get_first_dump_cpu_id(void)
+{
+ return &ramdump_except_cpu_id;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_get_client_init_rsp
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long*: cpu id address
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+volatile unsigned long * ramdump_get_client_init_rsp(void)
+{
+ return ramdump_client_init_rsp;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/ramdump_oss.c b/cp/ps/plat/src/oss/sup/src/ramdump_oss.c
new file mode 100644
index 0000000..0739af0
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/ramdump_oss.c
@@ -0,0 +1,363 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_oss.c
+* Îļþ±êʶ: ramdump_oss.c
+* ÄÚÈÝÕªÒª: ramdump²Ù×÷ϵͳÒÀÀµ½Ó¿Ú/Êý¾Ý½á¹¹¶¨ÒåÍ·Îļþ
+* ʹÓ÷½·¨: Èç¹û¸ü»»²Ù×÷ϵͳ£¬¸ÄÍ·ÎļþÄÚ½Ó¿Ú»òÕßÊý¾Ý¶¨ÒåÐèÒªÖØÐÂÊÊÅä
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/6/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+#include "ramdump_pub.h"
+#include "ramdump_oss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+* Íⲿº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿ÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Öº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+#ifdef _OS_LINUX
+/* icp api */
+extern int zDrvRpMsg_CreateChannel(
+ T_ZDrvRpMsg_ActorID actorID,
+ T_ZDrvRpMsg_ChID chID,
+ unsigned int size);
+extern int zDrvRpMsg_RegCallBack(
+ T_ZDrvRpMsg_ActorID actorID,
+ unsigned int chID,
+ T_ZDrvRpMsg_CallbackFunction callback);
+extern int zDrvRpMsg_WriteLockIrq(const T_ZDrvRpMsg_Msg *pMsg);
+extern void panic(const char *fmt, ...);
+
+extern int zDrvUsbPoll_Init(void);
+extern int zDrvUsbPoll_Isr(void);
+extern bool zDrvUsbPoll_isConnect(void);
+extern int zDrvUsbPoll_Read(unsigned char* pBuf,unsigned long length);
+extern int zDrvUsbPoll_Write(unsigned char* pBuf,unsigned long length);
+#elif defined (_OS_TOS)
+
+extern char *ramdump_error_log_exp(char *mem);
+#endif //#ifdef _OS_LINUX
+
+/*******************************************************************************
+* È«¾Öº¯ÊýʵÏÖ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_create_thread
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+void ramdump_oss_create_thread (
+ char *name,
+ ramdump_oss_thread_entry_t entry)
+{
+#ifdef _OS_TOS
+#define RAMDUMP_THREAD_STACK_DEF_SIZE 2048
+#define RAMDUMP_THREAD_DEF_PRIO 20
+#define RAMDUMP_THREAD_DEF_ARG 0
+#define RAMDUMP_THREAD_AUTORUN 1
+#define RAMDUMP_THREAD_PREEMPT 1
+
+ zOss_CreateThread(
+ name,entry,
+ RAMDUMP_THREAD_DEF_ARG,
+ RAMDUMP_THREAD_STACK_DEF_SIZE,
+ RAMDUMP_THREAD_DEF_PRIO,
+ RAMDUMP_THREAD_PREEMPT,
+ RAMDUMP_THREAD_AUTORUN);
+#endif
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_mmap
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+unsigned long ramdump_oss_mmap (unsigned long addr, unsigned long size)
+{
+#ifdef _OS_LINUX
+ return ioremap(addr,size);
+#elif defined (_OS_TOS)
+
+#ifdef __USE_MMU__
+ T_zTos_MmuRamdumpTable mmuTable = {0};
+ zTos_MmuGetMappingRegion(addr, size, &mmuTable);
+ /*
+ * TODO!
+ * current tos mmap one to one
+ * need new API like ioremap realize
+ */
+ return addr;
+#endif
+
+#endif
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_icp_send
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) icp_msg: msg info
+ client_id: client id
+ ch_id: channel id
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: int: if msg send success
+* ÆäËü˵Ã÷: This function is used for server to send msg to client
+*******************************************************************************/
+int ramdump_oss_icp_send(ramdump_oss_msg_t *icp_msg, unsigned int client_id, unsigned int ch_id)
+{
+ int ret;
+ ramdump_oss_icp_msg rpmsg = {0};
+
+ rpmsg.actorID = client_id;
+ rpmsg.chID = ch_id;
+ rpmsg.flag = 1;
+ rpmsg.buf = icp_msg;
+ rpmsg.len = sizeof(*icp_msg);
+
+ /*
+ * clean all the caches to make sure all data in ddr
+ */
+ ramdump_arch_clean_caches();
+
+ ret = ramdump_oss_icp_write(&rpmsg);
+
+ if (ret != rpmsg.len)
+ {
+#ifdef _OS_LINUX
+ OSS_PRINTF(
+ "[ramdump] icpmsg send fail, ret != rpmsg.len[ret:%d], [client_id:%d]\n",
+ ret,
+ client_id);
+#elif defined (_OS_TOS)
+ OSS_PRINTF(
+ "[ramdump] icpmsg send fail, ret != rpmsg.len[ret:%d], [client_id:%d]\n",
+ ret,
+ client_id);
+#endif
+ return ret;
+ }
+
+ return RAMDUMP_ICP_SUCCESS;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_error_log_creat
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) buf : addr point
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+void ramdump_oss_error_log_creat(char *buf)
+{
+#ifdef _OS_LINUX
+ if (current->mm != NULL)
+ sprintf(
+ buf,
+ " dump at user, app name is: %s, load addr is: %lu \n",
+ current->comm,
+ current->mm->start_code);
+ else
+ sprintf(
+ buf,
+ " dump at kernel, app name is: %s \n",
+ current->comm);
+#elif defined (_OS_TOS)
+ ramdump_error_log_exp(buf);
+#endif
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_icp_create_channel
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) actorID: icp send core id
+ chID: icp channel id
+ size: icp channel size
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: int: if msg send success
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+int ramdump_oss_icp_create_channel(
+ ramdump_oss_icp_actorid actorID,
+ ramdump_oss_icp_channelid chID,
+ unsigned int size)
+{
+ return zDrvRpMsg_CreateChannel(actorID, chID, size);
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_icp_regcallback
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) actorID: icp send core id
+ chID: icp channel id
+ callback:icp callback fun
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: int: if msg send success
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+int ramdump_oss_icp_regcallback (
+ ramdump_oss_icp_actorid actorID,
+ unsigned int chID,
+ ramdump_oss_icp_callback callback)
+{
+ return zDrvRpMsg_RegCallBack(actorID,chID,callback);
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_icp_write
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) pMsg: icp send msg
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: int: if msg send success
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+int ramdump_oss_icp_write(const ramdump_oss_icp_msg *pMsg)
+{
+#ifdef _OS_LINUX
+ return zDrvRpMsg_Write(pMsg);
+#elif defined (_OS_TOS)
+ if (pMsg->actorID == ramdump_cpu_id[RAMDUMP_CPU_2])
+ {
+ switch (((ramdump_msg_t *)(pMsg->buf))->msg_id)
+ {
+ case RAMDUMP_MSG_EXCEPT:
+ {
+ return zDrvRpMsg_WriteLockIrq(pMsg);
+ }
+ case RAMDUMP_MSG_SYNC:
+ default:
+ return pMsg->len;
+ }
+ }
+ else
+ return zDrvRpMsg_WriteLockIrq(pMsg);
+#endif
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_data_trans_init
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+void ramdump_oss_data_trans_init(void)
+{
+#ifdef _OS_LINUX
+ zDrvUsbPoll_Init(); /* ³õʼ»¯USB */
+ while (!zDrvUsbPoll_isConnect()) ; /* ²éѯUSBÊÇ·ñÁ¬½Ó */
+#endif
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_data_trans_read
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) buffer: data buff
+ size: data size
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+void ramdump_oss_data_trans_read(unsigned char *buffer, unsigned int size)
+{
+#ifdef _OS_LINUX
+ unsigned int count = 0;
+
+ do
+ {
+ zDrvUsbPoll_Isr();
+ count = (unsigned int)zDrvUsbPoll_Read(buffer, size);
+ if ( size <= count)
+ {
+ break;
+ }
+ buffer += count;
+ size -=count;
+ }
+ while (size > 0);
+#endif
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_data_trans_write
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) buffer: data buff
+ size: data size
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+void ramdump_oss_data_trans_write(unsigned char *buffer, unsigned int size)
+{
+#ifdef _OS_LINUX
+ unsigned int count = 0;
+
+ while (size > 0)
+ {
+ zDrvUsbPoll_Isr();
+ count = (unsigned int)zDrvUsbPoll_Write(buffer, size);
+ if ( size <= count)
+ {
+ break;
+ }
+
+ buffer += count;
+ size -=count;
+ }
+#endif
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_oss_data_trans_done
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+void ramdump_oss_data_trans_done(void)
+{
+#ifdef _OS_LINUX
+ /* µÈ´ýÊý¾Ý·¢ËÍÍêºó£¬ÔÙÖØÆô */
+ zDrvUsbPoll_Isr();
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/ramdump_soc.c b/cp/ps/plat/src/oss/sup/src/ramdump_soc.c
new file mode 100644
index 0000000..3eeb1bf
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/ramdump_soc.c
@@ -0,0 +1,66 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_soc_7520v2.c
+* Îļþ±êʶ: ramdump_soc_7520v2.c
+* ÄÚÈÝÕªÒª: ramdump´¦ÀíÆ÷Ïà¹Ø½Ó¿Ú/Êý¾Ý¶¨ÒåʵÏÖ
+* ʹÓ÷½·¨: Èç¹û¸ü»»´¦ÀíÆ÷£¬¸ÄÍ·ÎļþÄÚ½Ó¿Ú»òÕßÊý¾Ý¶¨ÒåÐèÒªÖØÐÂÊÊÅä
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/3/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+#include "ramdump_pub.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+* Íⲿº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿ÉùÃ÷ *
+*******************************************************************************/
+/*
+ * collect server/client* : RAMDUMP_CPU_0
+ * trans server : RAMDUMP_CPU_1
+ * client1 : RAMDUMP_CPU_2
+ */
+unsigned long ramdump_cpu_id[RAMDUMP_CPU_MAX] = {RAMDUMP_CPU_0, RAMDUMP_CPU_1, RAMDUMP_CPU_2};
+unsigned long ramdump_cpu_ch[RAMDUMP_CPU_MAX] = {RAMDUMP_CPU_0, RAMDUMP_CPU_1, RAMDUMP_CPU_2};
+
+/*
+ * CP collect server : RAMDUMP_CPU_0
+ * AP trans server : RAMDUMP_CPU_1
+ * ZSP client0: RAMDUMP_CPU_2
+ */
+char *ramdump_cpu_name[RAMDUMP_CPU_MAX] = {"CP", "AP", "ZSP"};
+
+/*******************************************************************************
+* È«¾Öº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Öº¯ÊýʵÏÖ *
+*******************************************************************************/
+
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/ramdump_v7.c b/cp/ps/plat/src/oss/sup/src/ramdump_v7.c
new file mode 100644
index 0000000..e89e88c
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/ramdump_v7.c
@@ -0,0 +1,579 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2016, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_v7.c
+* Îļþ±êʶ: ramdump_v7.c
+* ÄÚÈÝÕªÒª: ramdump armv7´¦ÀíÆ÷ʵÏÖ
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/6/10 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+#include "ramdump_pub.h"
+#include "ramdump_oss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+* Íⲿº¯ÊýÉùÃ÷ *
+*******************************************************************************/
+#ifdef _OS_LINUX
+extern void armv7_clean_dcache_all(void);
+#endif
+
+/*******************************************************************************
+* ³£Á¿¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+#define RAMDUMP_REG_NR (15) /* R0-R14 */
+#define RAMDUMP_FIQ_REG_START (8) /* R8 */
+#define RAMDUMP_FIQ_REG_END (13) /* R12 */
+
+#define RAMDUMP_ARM_USR_MOD (0xd0)
+#define RAMDUMP_ARM_SVC_MOD (0xd3)
+
+/* code & data done instr */
+#define ramdump_dsb() asm volatile("dsb" : : : "memory")
+
+#ifndef __stringify
+#define __stringify_1(x...) #x
+#define __stringify(x...) __stringify_1(x)
+#endif
+
+/* CP15 */
+#ifndef __ACCESS_CP15
+#define __ACCESS_CP15(CRn, Op1, CRm, Op2) p15, Op1, %0, CRn, CRm, Op2
+#endif
+
+#ifdef __USE_MMU__
+/* mmu control regs */
+#define MMU_SCTLR __ACCESS_CP15(c1, 0, c0, 0)
+#define MMU_TTBCR __ACCESS_CP15(c2, 0, c0, 2)
+#define MMU_DACR __ACCESS_CP15(c3, 0, c0, 0)
+#define MMU_TTBR0 __ACCESS_CP15(c2, 0, c0, 0)
+#define MMU_TTBR1 __ACCESS_CP15(c2, 0, c0, 1)
+#elif defined (__USE_MPU__) //#ifdef __USE_MMU__
+/* mpu control regs */
+#define MPU_TYPE_REGISTER_DREGION_POS (8)
+
+#define MPU_REGION_NUM __ACCESS_CP15(c6, 0, c2, 0)
+#define MPU_REGION_BASE __ACCESS_CP15(c6, 0, c1, 0)
+#define MPU_REGION_ATTR __ACCESS_CP15(c6, 0, c1, 4)
+#define MPU_REGION_SIZE __ACCESS_CP15(c6, 0, c1, 2)
+#define MPU_REGION_MAXNUM __ACCESS_CP15(c0, 0, c0, 4)
+#define MPU_DFSR __ACCESS_CP15(c5, 0, c0, 0)
+#define MPU_DFAR __ACCESS_CP15(c6, 0, c0, 0)
+#define MPU_IFSR __ACCESS_CP15(c5, 0, c0, 1)
+#define MPU_IFAR __ACCESS_CP15(c6, 0, c0, 2)
+#endif //#ifdef __USE_MMU__
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+/*
+ * arm cpu mode pub regs
+ */
+typedef struct
+{
+ unsigned long sp;
+ unsigned long lr;
+ unsigned long spsr;
+} ramdump_arm_com_regs;
+/*
+ * arm fiq mode regs
+ */
+typedef struct
+{
+ unsigned long fiq_r8;
+ unsigned long fiq_r9;
+ unsigned long fiq_r10;
+ unsigned long fiq_r11;
+ unsigned long fiq_r12;
+ ramdump_arm_com_regs fiq_com;
+} ramdump_arm_fiq_regs;
+/*
+ * arm cpu modes info record
+ */
+typedef struct
+{
+ unsigned long regs[13]; /* r0-r12*/
+
+ ramdump_arm_com_regs sys;
+ ramdump_arm_com_regs svc;
+ ramdump_arm_com_regs abt;
+ ramdump_arm_com_regs udf;
+ ramdump_arm_com_regs irq;
+ ramdump_arm_fiq_regs fiq;
+} ramdump_arm_regs;
+
+/*******************************************************************************
+* ¾Ö²¿¾²Ì¬±äÁ¿¶¨Òå *
+*******************************************************************************/
+/*
+ * arm cpu sys mod, except usr, we have special handle
+ */
+static const unsigned long arm_sys_modes[] =
+{
+ 0xdf, /* SYS */
+ 0xd3, /* SVC */
+ 0xd7, /* ABT */
+ 0xdb, /* UND */
+ 0xd2, /* IRQ */
+ 0xd1, /* FIQ */
+};
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿¶¨Òå *
+*******************************************************************************/
+ramdump_arm_regs arm_all_modes_regs;
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ *
+*******************************************************************************/
+
+#ifdef __USE_MMU__
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armv7_get_SCTLR
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: armv7 mmu SCTLR registers recover
+*******************************************************************************/
+static unsigned long armv7_get_SCTLR(void)
+{
+ unsigned long scrtlr_reg;
+
+ asm volatile("mrc " __stringify(MMU_SCTLR) : "=r" (scrtlr_reg));
+
+ return scrtlr_reg;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armv7_get_TTBCR
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: ttbcr value
+* ÆäËü˵Ã÷: armv7 mmu Control registers recover
+*******************************************************************************/
+static unsigned long armv7_get_TTBCR(void)
+{
+ unsigned long ttbcr_reg;
+
+ asm volatile("mrc " __stringify(MMU_TTBCR) : "=r" (ttbcr_reg));
+
+ return ttbcr_reg;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armv7_get_DACR
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: dacr value
+* ÆäËü˵Ã÷: armv7 mmu Domain registers recover
+*******************************************************************************/
+static unsigned long armv7_get_DACR(void)
+{
+ unsigned long dacr_reg;
+
+ asm volatile("mrc " __stringify(MMU_DACR) : "=r" (dacr_reg));
+
+ return dacr_reg;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armv7_get_TTBR0
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: ttbr0 value
+* ÆäËü˵Ã÷: armv7 mmu TTBR0 registers recover
+*******************************************************************************/
+static unsigned long armv7_get_TTBR0(void)
+{
+ unsigned long ttbr0_reg;
+
+ asm volatile("mrc " __stringify(MMU_TTBR0) : "=r" (ttbr0_reg));
+
+ return ttbr0_reg;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armv7_get_TTBR1
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: ttbr1 value
+* ÆäËü˵Ã÷: armv7 mmu TTBR1 registers recover
+*******************************************************************************/
+static unsigned long armv7_get_TTBR1(void)
+{
+ unsigned long ttbr1_reg;
+
+ asm volatile("mrc " __stringify(MMU_TTBR1) : "=r" (ttbr1_reg));
+
+ return ttbr1_reg;
+}
+
+#elif defined (__USE_MPU__) // #ifdef __USE_MMU__
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armr7_mpu_set_RegionNum
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) nr: number
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: region set nr
+* ÆäËü˵Ã÷: armv7 mpu set region number, select region
+*******************************************************************************/
+static void armr7_mpu_region_set_nr(unsigned long nr)
+{
+ unsigned long region_num;
+
+ asm volatile("mrc " __stringify(MPU_REGION_NUM) : "=r" (region_num));
+
+ return region_num;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armr7_mpu_get_RegionBase
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: region base
+* ÆäËü˵Ã÷: armv7 mpu get region base address
+*******************************************************************************/
+static unsigned long armr7_mpu_region_get_base(void)
+{
+ unsigned long region_base;
+
+ asm volatile("mrc " __stringify(MPU_REGION_BASE) : "=r" (region_base));
+
+ return region_base;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armr7_mpu_get_RegionAttr
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: region attr
+* ÆäËü˵Ã÷: armv7 mpu get region attribution
+*******************************************************************************/
+static unsigned long armr7_mpu_region_get_attr(void)
+{
+ unsigned long region_attr;
+
+ asm volatile("mrc " __stringify(MPU_REGION_ATTR) : "=r" (region_attr));
+
+ return region_attr;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armr7_mpu_get_RegionSize
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: region size
+* ÆäËü˵Ã÷: armv7 mpu get region size and enable reg
+*******************************************************************************/
+static unsigned long armr7_mpu_region_get_size(void)
+{
+ unsigned long region_size;
+
+ asm volatile("mrc " __stringify(MPU_REGION_SIZE) : "=r" (region_size));
+
+ return region_size;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armr7_mpu_get_RegionMaxNum
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: region max number
+* ÆäËü˵Ã÷: armv7 mpu get region max num
+*******************************************************************************/
+static unsigned long armr7_mpu_region_get_max_nr(void)
+{
+ unsigned long region_max_num;
+
+ asm volatile("mrc " __stringify(MPU_REGION_MAXNUM) : "=r" (region_max_num));
+
+ return (region_max_num >> 8);
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armr7_mpu_get_DFSR
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: dfsr value
+* ÆäËü˵Ã÷: armv7 mpu get DFSR
+*******************************************************************************/
+static unsigned long armr7_mpu_get_DFSR(void)
+{
+ unsigned long dfsr_reg;
+
+ asm volatile("mrc " __stringify(MPU_DFSR) : "=r" (dfsr_reg));
+
+ return dfsr_reg;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armr7_mpu_get_DFAR
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: dfar value
+* ÆäËü˵Ã÷: armv7 mpu get DFAR
+*******************************************************************************/
+static unsigned long armr7_mpu_get_DFAR(void)
+{
+ unsigned long dfar_reg;
+
+ asm volatile("mrc " __stringify(MPU_DFAR) : "=r" (dfar_reg));
+
+ return dfar_reg;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armr7_mpu_get_IFSR
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: ifsr value
+* ÆäËü˵Ã÷: armv7 mpu get IFSR
+*******************************************************************************/
+static unsigned long armr7_mpu_get_IFSR(void)
+{
+ unsigned long ifsr_reg;
+
+ asm volatile("mrc " __stringify(MPU_IFSR) : "=r" (ifsr_reg));
+
+ return ifsr_reg;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: armr7_mpu_get_IFAR
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: unsigned long: ifar value
+* ÆäËü˵Ã÷: armv7 mpu get IFAR
+*******************************************************************************/
+static unsigned long armr7_mpu_get_IFAR(void)
+{
+ unsigned long ifar_reg;
+
+ asm volatile("mrc " __stringify(MPU_IFAR) : "=r" (ifar_reg));
+
+ return ifar_reg;
+}
+
+#endif // #ifdef __USE_MMU__
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: arm_store_sys_regs
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) mem: addr points to buf start
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: addr: changed addr
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+static char *arm_store_sys_regs(char *mem)
+{
+ unsigned long *fiq_regs = NULL;
+ ramdump_arm_com_regs *ptr_mode_regs = NULL;
+ unsigned long fiq_regs_nr = RAMDUMP_FIQ_REG_START;
+ unsigned long arm_sys_mode_nr = 0;
+
+ //SYS/SVC/ABT/UND/IRQ
+ ptr_mode_regs = (ramdump_arm_com_regs*)(&arm_all_modes_regs.sys);
+ do {
+ mem += sprintf(mem, "r.s cpsr 0x%lx\n", (unsigned long)arm_sys_modes[arm_sys_mode_nr]);
+ mem += sprintf(mem, "r.s r13 0x%lx\n", (unsigned long)(ptr_mode_regs->sp));
+ mem += sprintf(mem, "r.s r14 0x%lx\n", (unsigned long)(ptr_mode_regs->lr));
+ mem += sprintf(mem, "r.s spsr 0x%lx\n", (unsigned long)(ptr_mode_regs->spsr));
+ ptr_mode_regs++;
+ arm_sys_mode_nr++;
+ } while (arm_sys_mode_nr < (RAMDUMP_ARRAY_NR(arm_sys_modes) - 1));
+
+ //FIQ r8-r12
+ mem += sprintf(mem, "r.s cpsr 0x%lx\n", (unsigned long)arm_sys_modes[arm_sys_mode_nr]);
+ fiq_regs = ((unsigned long*)&arm_all_modes_regs.fiq.fiq_r8);
+ do {
+ mem += sprintf(mem, "r.s r%lu 0x%lx\n", fiq_regs_nr, *(fiq_regs));
+ fiq_regs++;
+ fiq_regs_nr++;
+ } while (fiq_regs_nr < RAMDUMP_FIQ_REG_END);
+
+ //FIQ r13-r14/cpsr
+ ptr_mode_regs = &arm_all_modes_regs.fiq.fiq_com;
+ mem += sprintf(mem, "r.s r13 0x%lx\n", (unsigned long)(ptr_mode_regs->sp));
+ mem += sprintf(mem, "r.s r14 0x%lx\n", (unsigned long)(ptr_mode_regs->lr));
+ mem += sprintf(mem, "r.s spsr 0x%lx\n", (unsigned long)(ptr_mode_regs->spsr));
+
+ return mem;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: arm_store_cur_regs
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) mem: addr points to buf start
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: addr: changed addr
+* ÆäËü˵Ã÷:
+*******************************************************************************/
+static char *arm_store_cur_regs(char *mem)
+{
+ unsigned long cnt;
+ unsigned long *svc_regs = (unsigned long *)arm_all_modes_regs.regs;
+
+ mem += sprintf(mem, "r.s cpsr 0x%lx\n", (unsigned long)RAMDUMP_ARM_SVC_MOD);
+ for (cnt = 0x00; cnt < RAMDUMP_ARRAY_NR(arm_all_modes_regs.regs); cnt++)
+ mem += sprintf(mem, "r.s r%lu 0x%lx\n", cnt, *svc_regs++);
+ mem += sprintf(mem, "r.s r13 0x%lx\n", arm_all_modes_regs.svc.sp);
+ mem += sprintf(mem, "r.s r14 0x%lx\n", arm_all_modes_regs.svc.lr);
+ mem += sprintf(mem, "r.s pc 0x%lx\n", arm_all_modes_regs.svc.lr);
+ mem += sprintf(mem, "r.s spsr 0x%lx\n", arm_all_modes_regs.svc.spsr);
+
+ return mem;
+}
+
+/*******************************************************************************
+* È«¾Öº¯ÊýʵÏÖ *
+*******************************************************************************/
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_arch_clean_and_invalid_caches
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for arm clean and invalid caches
+*******************************************************************************/
+void ramdump_arch_clean_and_invalid_caches(void)
+{
+#ifdef _OS_TOS
+ tos_cache_clean_invalidate_all();
+#endif
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_arch_clean_caches
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: This function is used for arm clean caches
+*******************************************************************************/
+void ramdump_arch_clean_caches(void)
+{
+#ifdef _OS_LINUX
+ armv7_clean_dcache_all();
+#elif defined (_OS_TOS)
+ tos_cache_clean_all();
+#endif
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_arch_store_modes_regs
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) mem: addr points to buf start
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: addr: changed addr
+* ÆäËü˵Ã÷: This function is used for linux clean caches
+*******************************************************************************/
+char *ramdump_arch_store_modes_regs(char *mem)
+{
+ // store privileged regs
+ mem = arm_store_sys_regs(mem);
+
+ // store usr regs, user app is running in svc mod
+ mem = arm_store_cur_regs(mem);
+
+ return mem;
+}
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_arch_store_mm_regs
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) mem: addr points to buf start
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: addr: changed addr
+* ÆäËü˵Ã÷: This function is used for linux clean caches
+*******************************************************************************/
+char *ramdump_arch_store_mm_regs(char *mem)
+{
+#ifdef __USE_MMU__
+
+ mem += sprintf(mem, "per.s c15:0x1 %%long %#lx\r\n", armv7_get_SCTLR());
+ mem += sprintf(mem, "per.s c15:0x2 %%long %#lx\r\n", armv7_get_TTBR0());
+ mem += sprintf(mem, "per.s c15:0x102 %%long %#lx\r\n", armv7_get_TTBR1());
+ mem += sprintf(mem, "per.s c15:0x202 %%long %#lx\r\n", armv7_get_TTBCR());
+ mem += sprintf(mem, "per.s c15:0x3 %%long %#lx\r\n", armv7_get_DACR());
+
+#elif defined (__USE_MPU__) //#ifdef __USE_MMU__
+
+ unsigned long i = 0;
+
+ mem += sprintf(mem, "per.s c15:0x4 %%long %#lx\r\n", (unsigned long)((armr7_mpu_region_get_max_nr() << MPU_TYPE_REGISTER_DREGION_POS)));
+ for(i = 0; i < armr7_mpu_region_get_max_nr(); i++)
+ {
+ mem += sprintf(mem, "per.s c15:0x26 %%long %#lx\r\n", (unsigned long)i);
+ armr7_mpu_region_set_nr(i);
+ mem += sprintf(mem, "per.s c15:0x16 %%long %#lx\r\n", (unsigned long)(armr7_mpu_region_get_base()));
+ mem += sprintf(mem, "per.s c15:0x216 %%long %#lx\r\n", (unsigned long)(armr7_mpu_region_get_size()));
+ mem += sprintf(mem, "per.s c15:0x416 %%long %#lx\r\n", (unsigned long)(armr7_mpu_region_get_attr()));
+ }
+
+ /* DFSR/DFAR IFSR/IFAR */
+ mem += sprintf(mem, "per.s c15:0x5 %%long %#lx\r\n", (unsigned long)(armr7_mpu_get_DFSR()));
+ mem += sprintf(mem, "per.s c15:0x6 %%long %#lx\r\n", (unsigned long)(armr7_mpu_get_DFAR()));
+ mem += sprintf(mem, "per.s c15:0x105 %%long %#lx\r\n", (unsigned long)(armr7_mpu_get_IFSR()));
+ mem += sprintf(mem, "per.s c15:0x206 %%long %#lx\r\n", (unsigned long)(armr7_mpu_get_IFAR()));
+
+#endif //#ifdef __USE_MMU__
+
+ return mem;
+}
+
+unsigned long ramdump_arch_get_pc(unsigned int mode)
+{
+ unsigned long pc;
+#ifdef _OS_TOS
+
+ switch (mode){
+ case CYGNUM_HAL_VECTOR_UNDEF_INSTRUCTION:
+ pc = arm_all_modes_regs.udf.lr;
+ break;
+ case CYGNUM_HAL_VECTOR_ABORT_PREFETCH:
+ pc = arm_all_modes_regs.abt.lr;
+ break;
+ case CYGNUM_HAL_VECTOR_ABORT_DATA:
+ pc = arm_all_modes_regs.abt.lr;
+ break;
+ default:
+ pc = arm_all_modes_regs.svc.lr;
+ break;
+ }
+#endif
+ return pc;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/ramdump_v7_asm.S b/cp/ps/plat/src/oss/sup/src/ramdump_v7_asm.S
new file mode 100644
index 0000000..7125967
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/ramdump_v7_asm.S
@@ -0,0 +1,102 @@
+/*******************************************************************************
+* °æȨËùÓÐ (C)2015, ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾¡£
+*
+* ÎļþÃû³Æ: ramdump_v7_asm.S
+* Îļþ±êʶ: ramdump_v7_asm.S
+* ÄÚÈÝÕªÒª:
+*
+* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+* ------------------------------------------------------------------------------
+* 2016/06/20 V1.0 Create ÕÔ¾ü¿ü ´´½¨
+*
+*******************************************************************************/
+
+/*******************************************************************************
+* Í·Îļþ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ³£Á¿¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ºê¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýÉùÃ÷ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¾Ö²¿¾²Ì¬±äÁ¿¶¨Òå *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Ö±äÁ¿¶¨Òå *
+*******************************************************************************/
+.extern arm_all_modes_regs
+
+.global ramdump_arch_save_all_regs
+.global armv7_clean_dcache_l1
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ *
+*******************************************************************************/
+
+/*******************************************************************************
+* È«¾Öº¯ÊýʵÏÖ *
+*******************************************************************************/
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_arch_save_all_regs
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý)
+* (´«³ö²ÎÊý)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷: This function is used for linux ramdump registers recover
+* usr mode doesn`t need to store,we have special handle
+*******************************************************************************/
+.text
+.balign 4
+.type ramdump_arch_save_all_regs, %function
+ramdump_arch_save_all_regs:
+ push {r14}
+ ldr r14, =arm_all_modes_regs
+ stm r14!, {r0-r12} /* ±£´ær0-r12 */
+ mov r0, r14 /* ±£´ær14ÖÁr0£¬ºóÐøÒÔr0Ϊ»ùµØַѹջ */
+ ldr r14, [r13], #4 /* »¹Ôr13,r14 */
+ mrs r1, CPSR /* ±£´æcpsrÖÁr1 */
+ msr CPSR_c, #0xdf /* SYS mode */
+ stm r0!, {r13, r14} /* ½«{r13,r14}ÈëÕ» */
+//mrs r2, SPSR
+ str r2, [r0], #4 /* ½«SPSRÈëÕ» */
+ msr CPSR_c, #0xd3 /* svc mode */
+ stm r0!, {r13, r14} /* ½«{r13,r14} */
+ mrs r2, SPSR
+ str r2, [r0], #4 /* ½«SPSRÈëÕ» */
+ msr CPSR_c, #0xd7 /* ABT mode */
+ mrs r2, SPSR
+ stm r0!, {r13, r14}
+ str r2, [r0], #4
+ msr CPSR_c, #0xdb /* UND mode */
+ mrs r2, SPSR
+ stm r0!, {r13, r14}
+ str r2, [r0], #4
+ msr CPSR_c, #0xd2 /* IRQ mode */
+ mrs r2, SPSR
+ stm r0!, {r13, r14}
+ str r2, [r0], #4
+ msr CPSR_c, #0xd1 /* FIQ mode */
+ mrs r2, SPSR
+ stm r0!, {r8-r14}
+ str r2, [r0], #4
+ msr CPSR_c, r1 /* »¹ÔCPRS */
+ ldr r14, =arm_all_modes_regs /* »¹Ô¼Ä´æÆ÷ */
+ ldm r14!, {r0-r12} /* »¹Ôr0-r12£¬r13µÄֵ֮ǰÒÑ»¹Ô */
+ ldmdb r13, {R14} /* »¹Ôr14 */
+ bx r14 /* ·µ»Ø */
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_agent_entry.c b/cp/ps/plat/src/oss/sup/src/sup_agent_entry.c
new file mode 100644
index 0000000..5224c10
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_agent_entry.c
@@ -0,0 +1,222 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+
+#ifdef _USE_MONITOR
+/**************************************************************************************************
+* includeÇø
+***************************************************************************************************/
+#include "oss_api.h"
+#include "sup_agent.h"
+#include "sup_agent_toolkit.h"
+#include "sup_agent_uemessage.h"
+#include "sup_agent_pcmessage.h"
+#include "commgt_api.h"
+#include "drv_api.h"
+
+/**************************************************************************************************
+* ³£Á¿¶¨ÒåÇø
+***************************************************************************************************/
+
+/**************************************************************************************************
+* staticº¯ÊýÉùÃ÷Çø
+***************************************************************************************************/
+#ifdef _USE_WINCOMM_SERVER
+static VOID zOss_MonitorAgt_CommCallBack( UINT32 msgID, const UINT8 * msg, UINT32 msgLen );
+#else
+static VOID zOss_MonitorAgt_CommCallBack( UINT32 msgID, const UINT8 * msg, UINT16 msgLen );
+#endif
+
+/**************************************************************************************************
+* º¯ÊýʵÏÖÇø
+***************************************************************************************************/
+
+/**************************************************************************************************
+ º¯ÊýÃû £ºOsAgt_MessageRelease
+ ¹¦ÄÜ £ºÓÃÓÚÊÍ·ÅÊÕµ½µÄÏûÏ¢ÖÐÉêÇëµÄÄÚ´æ
+ ÊäÈë²ÎÊý £ºmsg_id Ä£¿éÊÕµ½µÄÏûÏ¢µÄID
+ buf Ö¸ÏòÄ£¿éÊÕµ½µÄÏûÏ¢µÄÄÚÈݵÄÖ¸Õë
+ Êä³ö²ÎÊý £ºÎÞ
+ ·µ»Øֵ˵Ã÷ £ºVOID
+ ÆäËû˵Ã÷ £º
+ --------------------------------------------------------------------------------------------------
+ ÐÞ¸ÄÈÕÆÚ °æ±¾ ÐÞ¸ÄÈË ÐÞ¸ÄÔÒò¼°ÄÚÈÝ
+ **************************************************************************************************/
+VOID zOss_MonitorAgt_MessageRelease(UINT32 msg_id, UINT8 *buf)
+{
+ switch(msg_id)
+ {
+ case OSS_MON_THREAD:
+ {
+ zOss_RetUB(((T_ZOss_Mon_Thread*)buf)->ele);
+ }
+ break;
+
+ case OSS_MON_TIMER:
+ {
+ zOss_RetUB(((T_ZOss_Mon_Timer*)buf)->ele);
+ }
+ break;
+
+ case OSS_MON_TASK:
+ {
+ zOss_RetUB(((T_ZOss_Mon_Task*)buf)->ele);
+ }
+ break;
+
+ case OSS_MON_POOL_ALLOC:
+ {
+ zOss_Free(((T_ZOss_Mon_Pool_Alloc*)buf)->ele);
+ }
+ break;
+
+ case OSS_MON_POOL_LEAK:
+ {
+ zOss_Free(((T_ZOss_Mon_Pool_Leak*)buf)->ele);
+ }
+ break;
+
+ case OSS_MON_GET_VAR_ACK:
+ {
+ zOss_RetUB(((T_ZOss_Mon_Get_Var_Ack*)buf)->value);
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+/**************************************************************************************************
+ º¯ÊýÃû £ºzOsAgt_Task
+ ¹¦ÄÜ £ºOsAgtÄ£¿éÈë¿Úº¯Êý
+ ÊäÈë²ÎÊý £ºstate Ä£¿é״̬
+ msg_id Ä£¿éÊÕµ½µÄÏûÏ¢µÄID
+ buf Ö¸ÏòÄ£¿éÊÕµ½µÄÏûÏ¢µÄÄÚÈݵÄÖ¸Õë
+ msg_len Ä£¿éÊÕµ½µÄÏûÏ¢µÄ³¤¶È
+ private_data Ä£¿é˽ÓÐÊý¾ÝÇø
+ Êä³ö²ÎÊý £ºÎÞ
+ ·µ»Øֵ˵Ã÷ £ºVOID
+ ÆäËû˵Ã÷ £º
+ --------------------------------------------------------------------------------------------------
+ ÐÞ¸ÄÈÕÆÚ °æ±¾ ÐÞ¸ÄÈË ÐÞ¸ÄÔÒò¼°ÄÚÈÝ
+ **************************************************************************************************/
+VOID zOss_MonitorAgt_Task(UINT8 state, UINT32 msg_id, UINT8 *buf, UINT16 msg_len, UINT8 *private_data)
+{
+ switch(state)
+ {
+ case ZOSS_STATUS_INIT:
+ {
+ switch(msg_id)
+ {
+ case EV_INIT:
+ break;
+
+ case EV_POWERON:
+ {
+ #ifdef _USE_WINCOMM_SERVER
+ if (0 == zTools_CommReg(SUBMDL_MONAGENT, ZDRV_DEV_UART_0, zOss_MonitorAgt_CommCallBack))
+ #else
+ if (0 == zOss_CommReg(SUBMDL_MONAGENT, ZDRV_DEV_UART_0, zOss_MonitorAgt_CommCallBack))
+ #endif
+ {
+ zOss_SetState(ZOSS_STATUS_WORK); /*½«ÈÎÎñÉèΪ¹¤×÷̬*/
+ zOss_MonitorAgt_SetOsTaskId(zOss_GetTaskID(OS_TASK_NAME));
+ zOss_MonitorAgt_InitUeMessage();
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+ break;
+
+ case ZOSS_STATUS_WORK:
+ {
+ zOss_MonitorAgt_UeMessageHandler(msg_id, buf);
+ zOss_MonitorAgt_MessageRelease(msg_id, buf);
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+/**************************************************************************************************
+ º¯ÊýÃû £ºzOsAgt_CommCallBack
+ ¹¦ÄÜ £ºOsAgtÄ£¿éÌṩ¸øCOMMÄ£¿éµÄ»Øµ÷º¯Êý£¬ÓÃÀ´½ÓÊÕÀ´×ÔPC²àµÄÏûÏ¢
+ ÊäÈë²ÎÊý £ºmsgID ½ÓÊÕµ½µÄÏûÏ¢ID£¬¼´COMMÏûϢͷ²¿ÖеÄÏûÏ¢ÀàÐÍ
+ ms Ö¸ÏòÄ£¿éÊÕµ½µÄÏûÏ¢µÄÄÚÈݵÄÖ¸Õë
+ msgLen Ä£¿éÊÕµ½µÄÏûÏ¢µÄ³¤¶È
+ Êä³ö²ÎÊý £ºÎÞ
+ ·µ»Øֵ˵Ã÷ £ºVOID
+ ÆäËû˵Ã÷ £º
+ --------------------------------------------------------------------------------------------------
+ ÐÞ¸ÄÈÕÆÚ °æ±¾ ÐÞ¸ÄÈË ÐÞ¸ÄÔÒò¼°ÄÚÈÝ
+ **************************************************************************************************/
+#ifdef _USE_WINCOMM_SERVER
+static VOID zOss_MonitorAgt_CommCallBack( UINT32 msgID, const UINT8 * msg, UINT32 msgLen )
+#else
+static VOID zOss_MonitorAgt_CommCallBack( UINT32 msgID, const UINT8 * msg, UINT16 msgLen )
+#endif
+{
+ BYTE toolMsg = *msg;
+
+ switch (toolMsg)
+ {
+ case PC_AGT_ACK:
+ zOss_MonitorAgt_PcAckReq();
+ break;
+ case PC_AGT_SET_VARIABLE: //set variable
+ zOss_MonitorAgt_PcSetValueReq(msgLen, (UINT8 *)msg);
+ break;
+
+ case PC_AGT_GET_VARIABLE:
+ zOss_MonitorAgt_PcGetValueReq(msgLen, (UINT8 *)msg);
+ break;
+
+ case PC_AGT_SNAPSHOT://snapshot
+ zOss_MonitorAgt_PcSnapshotReq(*(msg + 1));
+ break;
+
+ case PC_AGT_STOP:
+ zOss_MonitorAgt_PcStop();
+ break;
+
+ case PC_AGT_START:
+ zOss_MonitorAgt_PcStart();
+ break;
+
+ default:
+ break;
+ }
+}
+
+#endif
+
+
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_agent_osinfopack.c b/cp/ps/plat/src/oss/sup/src/sup_agent_osinfopack.c
new file mode 100644
index 0000000..b672fac
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_agent_osinfopack.c
@@ -0,0 +1,216 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+
+#ifdef _USE_MONITOR
+/**************************************************************************************************
+* includeÇø
+***************************************************************************************************/
+#include "sup_agent_osinfopack.h"
+#include "sup_agent_toolkit.h"
+
+/**************************************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+***************************************************************************************************/
+typedef struct
+{
+ UINT8 vistPermission;
+ const CHAR* description;
+}T_Mmu_VistPermission;
+
+/**************************************************************************************************
+* ³£Á¿¶¨ÒåÇø
+***************************************************************************************************/
+#define NumericToByteArray(array, numeric) zOss_Memcpy(array, &numeric, sizeof(numeric))
+
+static char s_timerExpiryTable[TIMER_EXPIRY_NUM][TIMER_EXPIRY_LEN] = {"no", "yes"};
+static char s_eventTable[EVENT_NUM][EVENT_LEN] = {"thread swapin",
+ "thread swapout",
+ "dsr swapin",
+ "dsr swapout"};
+static char s_taskStatusTable[TASK_STATUS_NUM][TASK_STATUS_LEN] = {"stop",
+ "idle",
+ "ready",
+ "run"};
+
+static T_Mmu_VistPermission s_mmuVistPermissionTable[] = { {1, "rw, nocache"},
+ {2, "ro, nocache"},
+ {9, "rw, writethrough"},
+ {10, "ro, writethrough"},
+ {13, "rw, writeback"},
+ {14, "ro, writeback"}};
+
+static char s_threadStatusTable[THREAD_STATUS_NUM][THREAD_STATUS_LEN] = {"running", "ready", "waiting"};
+
+/**************************************************************************************************
+
+* º¯ÊýʵÏÖÇø
+
+***************************************************************************************************/
+static char* zOss_MonitorAgt_GetMmuPermissonDescription(UINT8 permission)
+{
+ int i = 0;
+ for (i=0; i < MMU_PERMISSION_NUM; i++)
+ {
+ if (s_mmuVistPermissionTable[i].vistPermission == permission)
+ return (char *)s_mmuVistPermissionTable[i].description;
+ }
+
+ return (char *)"";
+}
+
+VOID zOss_MonitorAgt_PackVersion(UINT8* code, T_ZOss_Mon_Version* version)
+{
+ T_Version packVersion = {0};
+ zOss_MonitorAgt_CharToByteArray(packVersion.version, version->version, VERSION_LEN);
+ NumericToByteArray(code, packVersion);
+}
+
+VOID zOss_MonitorAgt_PackFrequency(UINT8* code, T_ZOss_Mon_Cpu_Frequency* frequency)
+{
+ T_Frequency packFreq = {0};
+ //memcpy(packFreq.feq, &frequency->frequency, sizeof(frequency->frequency));
+ NumericToByteArray(packFreq.feq, frequency->frequency);
+ NumericToByteArray(code, packFreq);
+}
+
+VOID zOss_MonitorAgt_PackCpuLoad(UINT8* code, T_ZOss_Mon_Cpu_Load* cpuLoad)
+{
+ T_CpuLoad packCpuLoad = {0};
+ NumericToByteArray(packCpuLoad.load, cpuLoad->load);
+ NumericToByteArray(code, packCpuLoad);
+}
+
+VOID zOss_MonitorAgt_PackPoolEle(UINT8* code, T_ZOss_Mon_Pool_Ele* pool_ele)
+{
+ T_Pool_Ele packPoolEle = {0};
+ NumericToByteArray(packPoolEle.size, pool_ele->size);
+ NumericToByteArray(packPoolEle.total, pool_ele->total);
+ NumericToByteArray(packPoolEle.used, pool_ele->used);
+ NumericToByteArray(packPoolEle.maxUsed, pool_ele->max_used);
+ NumericToByteArray(code, packPoolEle);
+}
+
+VOID zOss_MonitorAgt_PackPoolAllocEle(UINT8* code, T_ZOss_Mon_Pool_Alloc_Ele* pool_alloc_ele)
+{
+ T_Pool_Alloc_Ele packPoolAllocEle = {0};
+ NumericToByteArray(packPoolAllocEle.address, pool_alloc_ele->addr);
+ NumericToByteArray(packPoolAllocEle.owner, pool_alloc_ele->owner);
+ NumericToByteArray(packPoolAllocEle.timeStamp, pool_alloc_ele->timestamp);
+ zOss_MonitorAgt_FileNameToByteArray(packPoolAllocEle.file, pool_alloc_ele->file, FILE_LEN);
+ NumericToByteArray(packPoolAllocEle.line, pool_alloc_ele->line);
+ NumericToByteArray(code, packPoolAllocEle);
+}
+
+VOID zOss_MonitorAgt_PackPoolLeakEle(UINT8* code, T_ZOss_Mon_Pool_Leak_Ele* pool_leak_ele)
+{
+ T_Pool_Leak_Ele packPoolLeakEle = {0};
+ NumericToByteArray(packPoolLeakEle.address, pool_leak_ele->addr);
+ NumericToByteArray(packPoolLeakEle.owner, pool_leak_ele->owner);
+ NumericToByteArray(packPoolLeakEle.timeStamp, pool_leak_ele->timestamp);
+ zOss_MonitorAgt_FileNameToByteArray(packPoolLeakEle.file, pool_leak_ele->file, FILE_LEN);
+ NumericToByteArray(packPoolLeakEle.line, pool_leak_ele->line);
+ NumericToByteArray(code, packPoolLeakEle);
+}
+
+VOID zOss_MonitorAgt_PackHeap(UINT8* code, T_ZOss_Mon_Heap* heap)
+{
+ T_Heap packHeap = {0};
+ NumericToByteArray(packHeap.base, heap->base);
+ NumericToByteArray(packHeap.size, heap->size);
+ NumericToByteArray(packHeap.used, heap->used);
+ NumericToByteArray(code, packHeap);
+}
+
+VOID zOss_MonitorAgt_PackThreadEle(UINT8* code, T_ZOss_Mon_Thread_Ele* thread_ele)
+{
+ T_Thread_Ele packThreadEle = {0};
+ NumericToByteArray(packThreadEle.handle, thread_ele->handle);
+ NumericToByteArray(packThreadEle.msg_no, thread_ele->msg_num);
+ zOss_MonitorAgt_CharToByteArray(packThreadEle.status, s_threadStatusTable[thread_ele->status/2], THREAD_STATUS_LEN);
+ NumericToByteArray(packThreadEle.priority, thread_ele->priority);
+ NumericToByteArray(packThreadEle.stack_used, thread_ele->stack_used);
+ NumericToByteArray(packThreadEle.stack_max_used, thread_ele->stack_max_used);
+ NumericToByteArray(packThreadEle.cpu_load, thread_ele->cpu_load);
+ zOss_MonitorAgt_CharToByteArray(packThreadEle.name, thread_ele->name, THREAD_NAME_LEN);
+ NumericToByteArray(code, packThreadEle);
+}
+
+VOID zOss_MonitorAgt_PackTaskEle(UINT8* code, T_ZOss_Mon_Task_Ele* task_ele)
+{
+ T_Task_Ele packTaskEle = {0};
+ NumericToByteArray(packTaskEle.handle, task_ele->handle);
+ NumericToByteArray(packTaskEle.thread_handle, task_ele->thread_handle);
+ zOss_MonitorAgt_CharToByteArray(packTaskEle.status, s_taskStatusTable[task_ele->status - 1], TASK_STATUS_LEN);
+ zOss_MonitorAgt_CharToByteArray(packTaskEle.name, task_ele->name, TASK_NAME_LEN);
+ NumericToByteArray(code, packTaskEle);
+}
+
+VOID zOss_MonitorAgt_PackEventEle(UINT8* code, T_ZOss_Mon_Event_Ele* event_ele)
+{
+ T_Event_Ele packEventEle = {0};
+ zOss_MonitorAgt_CharToByteArray(packEventEle.event, s_eventTable[event_ele->event], EVENT_LEN);
+ NumericToByteArray(packEventEle.handle, event_ele->handle);
+ NumericToByteArray(packEventEle.tickstamp, event_ele->tickstamp);
+ zOss_MonitorAgt_CharToByteArray(packEventEle.name, event_ele->name, EVENT_NAME_LEN);
+ NumericToByteArray(code, packEventEle);
+}
+
+VOID zOss_MonitorAgt_PackMsgEle(UINT8* code, T_ZOss_Mon_Msg_Ele* msg_ele)
+{
+ T_Msg_Ele packMsgEle = {0};
+ NumericToByteArray(packMsgEle.msgId, msg_ele->msgId);
+ NumericToByteArray(packMsgEle.address, msg_ele->ptr);
+ NumericToByteArray(packMsgEle.size, msg_ele->size);
+ zOss_MonitorAgt_CharToByteArray(packMsgEle.sender, msg_ele->sender, SENDER_NAME_LEN);
+ zOss_MonitorAgt_CharToByteArray(packMsgEle.receiver, msg_ele->receiver, RECEIVER_NAME_LEN);
+ NumericToByteArray(packMsgEle.timestamp, msg_ele->timestamp);
+ NumericToByteArray(code, packMsgEle);
+}
+
+VOID zOss_MonitorAgt_PackTimerEle(UINT8* code, T_ZOss_Mon_Timer_Ele* timer_ele)
+{
+ T_Timer_Ele packTimerEle = {0};
+ NumericToByteArray(packTimerEle.start_time, timer_ele->start_time);
+ NumericToByteArray(packTimerEle.expire_time, timer_ele->expire_time);
+ NumericToByteArray(packTimerEle.callback_func, timer_ele->callback_func);
+ zOss_MonitorAgt_CharToByteArray(packTimerEle.is_period, s_timerExpiryTable[timer_ele->is_period], TIMER_EXPIRY_LEN);
+ NumericToByteArray(packTimerEle.handle, timer_ele->handle);
+ NumericToByteArray(code, packTimerEle);
+}
+
+VOID zOss_MonitorAgt_PackMmuEle(UINT8* code, T_ZOss_Mon_Mmu_Ele* mmu_ele)
+{
+ T_Mmu_Ele packMmuEle = {0};
+ NumericToByteArray(packMmuEle.vir_addr, mmu_ele->vir_addr);
+ NumericToByteArray(packMmuEle.phy_addr, mmu_ele->phy_addr);
+ NumericToByteArray(packMmuEle.size, mmu_ele->size);
+ zOss_MonitorAgt_CharToByteArray(packMmuEle.attr, zOss_MonitorAgt_GetMmuPermissonDescription(mmu_ele->attr), MMU_PERMISSION_LEN);
+ zOss_MonitorAgt_CharToByteArray(packMmuEle.name, mmu_ele->name, MMU_NAME_LEN);
+ NumericToByteArray(code, packMmuEle);
+}
+
+#endif
+
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_agent_pcmessage.c b/cp/ps/plat/src/oss/sup/src/sup_agent_pcmessage.c
new file mode 100644
index 0000000..497bc6a
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_agent_pcmessage.c
@@ -0,0 +1,177 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+
+#ifdef _USE_MONITOR
+/**************************************************************************************************
+* includeÇø
+***************************************************************************************************/
+#include "oss_api.h"
+#include "sup_agent.h"
+#include "sup_agent_pcmessage.h"
+#include "sup_agent_toolkit.h"
+#include "sup_agent_status.h"
+#ifdef _USE_WINCOMM_SERVER
+#include "commgt_api.h"
+#endif
+
+/**************************************************************************************************
+* È«¾Ö±äÁ¿¶¨ÒåÇø
+***************************************************************************************************/
+static unsigned int s_openFlg = OSS_MON_FLAG_OFF;
+
+/**************************************************************************************************
+* º¯ÊýʵÏÖÇø
+***************************************************************************************************/
+VOID zOss_MonitorAgt_PcAckReq(VOID)
+{
+ UINT8 cnf[2] = {0};
+ #ifdef _USE_WINCOMM_SERVER
+ VOID *buffer = NULL;
+ #endif
+
+ cnf[0] = AGT_PC_ACK;
+ cnf[1] = (BYTE)s_openFlg;
+ #ifdef _USE_WINCOMM_SERVER
+ buffer = zOss_Malloc(sizeof(cnf));
+ if(buffer != NULL)
+ {
+ zOss_Memcpy(buffer, cnf, sizeof(cnf));
+ zOss_MonitorAgt_SendDataToPcTool(buffer, 2);
+ }
+ #else
+ zOss_MonitorAgt_SendDataToPcTool((UINT8*)cnf, 2);
+ #endif
+}
+
+#ifdef _USE_WINCOMM_SERVER
+VOID zOss_MonitorAgt_PcSetValueReq(UINT32 len, BYTE* buf)
+#else
+VOID zOss_MonitorAgt_PcSetValueReq(UINT16 len, BYTE* buf)
+#endif
+{
+ T_ZOss_Mon_Set_Var* Msg = (T_ZOss_Mon_Set_Var*)zOss_GetUB(sizeof(*Msg));
+ zOss_Memcpy(&Msg->base, &buf[1], sizeof(Msg->base));
+ zOss_Memcpy(&Msg->size, &buf[5], sizeof(Msg->size));
+ Msg->value = (BYTE*)zOss_GetUB(Msg->size);
+ zOss_Memcpy(Msg->value, &buf[9], Msg->size);
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_SET_VAR, sizeof(T_ZOss_Mon_Set_Var), (BYTE*)(Msg));
+}
+
+#ifdef _USE_WINCOMM_SERVER
+VOID zOss_MonitorAgt_PcGetValueReq(UINT32 len, BYTE* buf)
+#else
+VOID zOss_MonitorAgt_PcGetValueReq(UINT16 len, BYTE* buf)
+#endif
+{
+ T_ZOss_Mon_Get_Var_Req* Msg = ZOSS_NULL;
+
+ if (zOss_MonitorAgt_CheckReceiveMessage(PC_TOOL_WINDOW_VARIABLE) == OsAgt_Status_Ok)
+ {
+ Msg = (T_ZOss_Mon_Get_Var_Req*)zOss_GetUB(sizeof(*Msg));
+ zOss_Memcpy(&Msg->base, &buf[1], sizeof(Msg->base));
+ zOss_Memcpy(&Msg->size, &buf[5], sizeof(Msg->size));
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_GET_VAR_REQ, sizeof(T_ZOss_Mon_Get_Var_Req), (BYTE*)(Msg));
+ }
+}
+
+static VOID zOss_MonitorAgt_SendOsReq(UINT8 msgId)
+{
+ switch (msgId)
+ {
+ case AGT_PC_WINDOW_INFO_THREAD:
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_THREAD, 0, ZOSS_NULL);
+ break;
+ case AGT_PC_WINDOW_INFO_EVENT:
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_EVENT, 0, ZOSS_NULL);
+ break;
+ case AGT_PC_WINDOW_INFO_TIMER:
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_TIMER, 0, ZOSS_NULL);
+ break;
+ case AGT_PC_WINDOW_INFO_TASK:
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_TASK, 0, ZOSS_NULL);
+ break;
+ case AGT_PC_WINDOW_INFO_RAMLOG:
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_RAMLOG, 0, ZOSS_NULL);
+ break;
+ case AGT_PC_WINDOW_INFO_POOL:
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_POOL_ALLOC, 0, ZOSS_NULL);
+ break;
+ case AGT_PC_WINDOW_INFO_MMU:
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_MMU, 0, ZOSS_NULL);
+ break;
+ case AGT_PC_WINDOW_INFO_MSG:
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_MSG, 0, ZOSS_NULL);
+ break;
+ case AGT_PC_WINDOW_INFO_POOLLEAK:
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_POOL_LEAK, 0, ZOSS_NULL);
+ break;
+ case AGT_PC_WINDOW_INFO_MEM:
+ {
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_HEAP, 0, ZOSS_NULL);
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_POOL, 0, ZOSS_NULL);
+ }
+ break;
+ case AGT_PC_WINDOW_INFO_CPU:
+ {
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_CPU_FREQUENCY, 0, ZOSS_NULL);
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_CPU_LOAD, 0, ZOSS_NULL);
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_VERSION, 0, ZOSS_NULL);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+VOID zOss_MonitorAgt_PcSnapshotReq(UINT8 msgId)
+{
+ if (s_openFlg == OSS_MON_FLAG_OFF)
+ {
+ return;
+ }
+ if (zOss_MonitorAgt_CheckReceiveMessage(msgId) == OsAgt_Status_Ok)
+ {
+ zOss_MonitorAgt_SendOsReq(msgId);
+ }
+}
+
+VOID zOss_MonitorAgt_PcStop(VOID)
+{
+ T_ZOss_Mon_Set_Flag* Msg = (T_ZOss_Mon_Set_Flag*)zOss_GetUB(sizeof(*Msg));
+ s_openFlg = OSS_MON_FLAG_OFF;
+ Msg->flag = s_openFlg;
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_SET_FLAG, sizeof(T_ZOss_Mon_Set_Flag), (BYTE*)(Msg));
+}
+
+VOID zOss_MonitorAgt_PcStart(VOID)
+{
+ T_ZOss_Mon_Set_Flag* Msg = (T_ZOss_Mon_Set_Flag*)zOss_GetUB(sizeof(*Msg));
+ s_openFlg = OSS_MON_FLAG_ON;
+ Msg->flag = s_openFlg;
+ zOss_MonitorAgt_SendMsgToOs(OSS_MON_SET_FLAG, sizeof(T_ZOss_Mon_Set_Flag), (BYTE*)(Msg));
+}
+
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_agent_status.c b/cp/ps/plat/src/oss/sup/src/sup_agent_status.c
new file mode 100644
index 0000000..da244f2
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_agent_status.c
@@ -0,0 +1,212 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+
+#ifdef _USE_MONITOR
+/**************************************************************************************************
+* includeÇø
+***************************************************************************************************/
+#include "sup_agent_status.h"
+#include "sup_agent.h"
+
+/**************************************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+***************************************************************************************************/
+typedef struct
+{
+ UINT32 msgId;
+ UINT32 count;
+
+}T_OsAgt_Status;
+
+typedef struct
+{
+ UINT32 pcMsgId;
+ UINT32 ueMsgId;
+
+}T_OsAgt_MsgIdMap;
+
+/**************************************************************************************************
+* ³£Á¿¶¨ÒåÇø
+***************************************************************************************************/
+#define INVLID_STATUS_VALUE 0xFFFFFFFF
+#define INVLID_MESSAGE_ID 0xFFFFFFFF
+
+static T_OsAgt_MsgIdMap g_MsgIdMap[] =
+{
+ { PC_TOOL_WINDOW_CPU, OSS_MON_VERSION},
+
+ { PC_TOOL_WINDOW_THREAD, OSS_MON_THREAD},
+ { PC_TOOL_WINDOW_EVENT, OSS_MON_EVENT},
+ { PC_TOOL_WINDOW_TIMER, OSS_MON_TIMER},
+ { PC_TOOL_WINDOW_TASK, OSS_MON_TASK},
+ { PC_TOOL_WINDOW_RAMLOG, OSS_MON_RAMLOG},
+ { PC_TOOL_WINDOW_POOL, OSS_MON_POOL_ALLOC},
+ { PC_TOOL_WINDOW_MMU, OSS_MON_MMU},
+ { PC_TOOL_WINDOW_MSG, OSS_MON_MSG},
+ { PC_TOOL_WINDOW_POOLLEAK, OSS_MON_POOL_LEAK},
+ { PC_TOOL_WINDOW_VARIABLE, OSS_MON_GET_VAR_ACK},
+
+ { PC_TOOL_WINDOW_MEM, OSS_MON_HEAP},
+ { PC_TOOL_WINDOW_MEM, OSS_MON_POOL},
+
+ { PC_TOOL_WINDOW_CPU, OSS_MON_CPU_LOAD},
+ { PC_TOOL_WINDOW_CPU, OSS_MON_CPU_FREQUENCY}
+};
+
+#define UE_MSG_NUM (sizeof(g_MsgIdMap)/sizeof(T_OsAgt_MsgIdMap))
+
+/**************************************************************************************************
+* staticº¯ÊýÉùÃ÷Çø
+***************************************************************************************************/
+static UINT32 zOss_MonitorAgt_GetStatusCount(UINT32 msgId);
+static VOID zOss_MonitorAgt_SetStatusCount(UINT32 msgId);
+
+/**************************************************************************************************
+* È«¾Ö±äÁ¿¶¨ÒåÇø
+***************************************************************************************************/
+static T_OsAgt_Status g_Status[PC_WINDOW_NUM] =
+{
+ { PC_TOOL_WINDOW_THREAD, 0}, //1
+ { PC_TOOL_WINDOW_EVENT, 0}, //1
+ { PC_TOOL_WINDOW_TIMER, 0}, //1
+ { PC_TOOL_WINDOW_TASK, 0}, //1
+ { PC_TOOL_WINDOW_RAMLOG, 0}, //1
+ { PC_TOOL_WINDOW_POOL, 0}, //1
+ { PC_TOOL_WINDOW_MMU, 0}, //1
+ { PC_TOOL_WINDOW_MSG, 0}, //1
+ { PC_TOOL_WINDOW_POOLLEAK, 0}, //1
+ { PC_TOOL_WINDOW_VARIABLE, 0}, //1
+ { PC_TOOL_WINDOW_MEM, 0}, //2
+ { PC_TOOL_WINDOW_CPU, 0}, //2
+};
+
+/**************************************************************************************************
+* º¯ÊýʵÏÖÇø
+***************************************************************************************************/
+static UINT32 zOss_MonitorAgt_GetUeMessageNum(UINT32 msgId)
+{
+ UINT32 i = 0;
+ UINT32 count = 0;
+ for(i = 0; i < UE_MSG_NUM; i++)
+ {
+ if(g_MsgIdMap[i].pcMsgId == msgId)
+ {
+ count++;
+ }
+ }
+
+ return count;
+}
+
+static UINT32 zOss_MonitorAgt_GetPcMessageId(UINT32 ueMsgId)
+{
+ UINT32 pcMsgId = INVLID_MESSAGE_ID;
+ UINT32 i = 0;
+ for(i = 0; i < UE_MSG_NUM; i++)
+ {
+ if(g_MsgIdMap[i].ueMsgId == ueMsgId)
+ {
+ pcMsgId = g_MsgIdMap[i].pcMsgId;
+ break;
+ }
+ }
+
+return pcMsgId;
+}
+
+static VOID zOss_MonitorAgt_ReduceStatusCount(UINT32 msgId)
+{
+ int i = 0;
+ for(i = 0; i < PC_WINDOW_NUM; i++)
+ {
+ if(g_Status[i].msgId == msgId)
+ {
+ g_Status[i].count--;
+ break;
+ }
+ }
+}
+
+static VOID zOss_MonitorAgt_SetStatusCount(UINT32 msgId)
+{
+ int i = 0;
+ UINT32 count = zOss_MonitorAgt_GetUeMessageNum(msgId);
+
+ for(i = 0; i < PC_WINDOW_NUM; i++)
+ {
+ if(g_Status[i].msgId == msgId)
+ {
+ g_Status[i].count = count;
+ break;
+ }
+ }
+}
+
+static UINT32 zOss_MonitorAgt_GetStatusCount(UINT32 msgId)
+{
+ int i = 0;
+
+ for(i = 0; i < PC_WINDOW_NUM; i++)
+ {
+ if(g_Status[i].msgId == msgId)
+ {
+ return g_Status[i].count;
+ }
+ }
+
+ return INVLID_STATUS_VALUE;
+}
+
+OsAgt_Status zOss_MonitorAgt_CheckReceiveMessage(UINT32 msgId)
+{
+ if(zOss_MonitorAgt_GetStatusCount(msgId) == 0)
+ {
+ zOss_MonitorAgt_SetStatusCount(msgId);
+ return OsAgt_Status_Ok;
+ }
+ else
+ {
+ //discard received pc message
+ return OsAgt_Status_Error;
+ }
+}
+
+OsAgt_Status zOss_MonitorAgt_CheckReplyMessage(UINT32 ueMsgId)
+{
+ UINT32 pcMsgId = zOss_MonitorAgt_GetPcMessageId(ueMsgId);
+
+ zOss_MonitorAgt_ReduceStatusCount(pcMsgId);
+ if(zOss_MonitorAgt_GetStatusCount(pcMsgId) == 0)
+ {
+ //send message to pc
+ return OsAgt_Status_Ok;
+ }
+ else
+ {
+ return OsAgt_Status_Error;
+ }
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_agent_toolkit.c b/cp/ps/plat/src/oss/sup/src/sup_agent_toolkit.c
new file mode 100644
index 0000000..8103c11
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_agent_toolkit.c
@@ -0,0 +1,154 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+
+#ifdef _USE_MONITOR
+/**************************************************************************************************
+* includeÇø
+***************************************************************************************************/
+#include "sup_agent_toolkit.h"
+#include "commgt_api.h"
+#ifdef _USE_WINCOMM_SERVER
+#include "tools.h"
+#endif
+
+/**************************************************************************************************
+* ³£Á¿¶¨ÒåÇø
+***************************************************************************************************/
+//wincommÍ·²¿ÏûÏ¢ÖеÄMsgType¶¨Òå
+#define WINCOMM_MSG_HEAD_TYPE_DATA 1
+
+//Ä£¿éºÅ¶¨Òå
+#define PC_TOOL_MODULE_ID 155
+#define PC_TOOL_SUB_MODULE_ID 1
+#define AGT_SUB_MODULE_ID SUBMDL_MONAGENT
+
+//Êý¾Ý·Ö¶ÎÍ·²¿³¤¶È
+#define DATA_SEG_HEAD_LEN 3
+
+//×î´ó·¢ËÍÊý¾Ý³¤¶È£¬wincommÖ§³Ö64kº¬wincomm×Ô¼º·â×°µÄÍ·²¿£¬ÕâÀïÁôÒ»µãÔ¤Áô¸øwincommÍ·²¿
+#define DATA_MAX_LEN 0xf000
+static ZOSS_TASK_ID s_osTaskId = NULL;
+
+#define SEND_DATA_OK 0
+#define SEND_DATA_ERR 1
+
+static int zOss_MonitorAgt_SendDataSeg(BYTE msgId, BYTE curSeg, BYTE maxSeg, UINT8* curDataPtr, UINT16 dataLen);
+
+/**************************************************************************************************
+* º¯ÊýʵÏÖÇø
+***************************************************************************************************/
+VOID zOss_MonitorAgt_SetOsTaskId(ZOSS_TASK_ID taskId)
+{
+ s_osTaskId = taskId;
+}
+
+VOID zOss_MonitorAgt_SendMsgToOs(UINT32 id, UINT16 len, UINT8* buf)
+{
+ zOss_TaskSendData(id, buf, len, s_osTaskId);
+}
+
+VOID zOss_MonitorAgt_CharToByteArray(char* array, const char* charStr, DWORD maxLen)
+{
+ DWORD strenLen = strlen(charStr);
+
+ if (strenLen > maxLen)
+ {
+ strenLen = maxLen;
+ }
+ zOss_Memcpy(array, charStr, strenLen);
+}
+
+VOID zOss_MonitorAgt_FileNameToByteArray(char* array, const char* charStr, DWORD maxLen)
+{
+ UINT32 pos = 0;
+ DWORD strenLen = strlen(charStr);
+
+ if (strenLen > maxLen)
+ {
+ pos = strenLen - maxLen;
+ strenLen = maxLen;
+ }
+
+ zOss_Memcpy(array, charStr + pos, strenLen);
+}
+
+VOID zOss_MonitorAgt_SendDataToPcTool(UINT8* buf, UINT32 len)
+{
+ #ifdef _USE_WINCOMM_SERVER
+ UINT8* curPtr = buf + 1;
+ UINT16 maxDataLen = DATA_MAX_LEN - DATA_SEG_HEAD_LEN;
+ UINT32 dataLen = len - 1;
+ UINT16 dataLenTemp;
+ UINT32 segNum = (dataLen % maxDataLen) >0 ? dataLen / maxDataLen + 1 : dataLen / maxDataLen;
+ int i;
+ if (buf == NULL)
+ {
+ return;
+ }
+ for (i=1;i<=segNum;i++)
+ {
+ dataLenTemp = dataLen > maxDataLen? maxDataLen : dataLen;
+ if (SEND_DATA_ERR == zOss_MonitorAgt_SendDataSeg(buf[0], i, segNum, curPtr, dataLenTemp))
+ {
+ break;
+ }
+ dataLen = dataLen - dataLenTemp;
+ curPtr = curPtr + dataLenTemp;
+ }
+ zOss_Free(buf);
+ #else
+ zOss_SendToPC(WINCOMM_MSG_HEAD_TYPE_DATA, buf, len, PC_TOOL_MODULE_ID, PC_TOOL_SUB_MODULE_ID, AGT_SUB_MODULE_ID);
+ #endif
+}
+
+
+int zOss_MonitorAgt_SendDataSeg(BYTE msgId, BYTE curSeg, BYTE maxSeg, UINT8* curDataPtr, UINT16 dataLen)
+{
+ UINT32 uRet = ZOSS_ERROR;
+ UINT8* sendBuf = Comm_Malloc(DATA_SEG_HEAD_LEN + dataLen);
+ if (sendBuf == NULL)
+ {
+ return SEND_DATA_ERR;
+ }
+ sendBuf[0] = msgId;
+ sendBuf[1] = curSeg;
+ sendBuf[2] = maxSeg;
+ if (dataLen != 0)
+ {
+ zOss_Memcpy(sendBuf + DATA_SEG_HEAD_LEN, curDataPtr, dataLen);
+ }
+ uRet = zTools_SendData(sendBuf, DATA_SEG_HEAD_LEN + dataLen, PC_TOOL_MODULE_ID, PC_TOOL_SUB_MODULE_ID, AGT_SUB_MODULE_ID);
+ if(uRet != ZOSS_SUCCESS)
+ {
+ Comm_Free(sendBuf);
+ return SEND_DATA_ERR;
+ }
+ return SEND_DATA_OK;
+}
+#endif
+
+
+
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_agent_uemessage.c b/cp/ps/plat/src/oss/sup/src/sup_agent_uemessage.c
new file mode 100644
index 0000000..8a0a652
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_agent_uemessage.c
@@ -0,0 +1,912 @@
+/**************************************************************************************************
+*
+* Copyright(c) 2012 ZTE Corporation
+*
+***************************************************************************************************
+* °æ±¾ËùÓÐ: ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾ ÊÖ»úÊÂÒµ²¿ Èí¼þ¿ª·¢Áù²¿
+* Ä£ ¿é Ãû: OS¸ú×Ù¹¤¾ßUE²à´úÀí
+* ÎÄ ¼þ Ãû:
+* Îļþ±êʶ:
+* Ïà¹ØÎļþ:
+* ʵÏÖ¹¦ÄÜ:
+* ×÷ Õß:
+* °æ ±¾:
+* Íê³ÉÈÕÆÚ:
+* ÆäËû˵Ã÷:
+***************************************************************************************************/
+
+/**************************************************************************************************
+* Ð޸ļǼ:
+* ÈÕ ÆÚ:
+* ÐÞ ¸Ä ºÅ:
+* ÐÞ ¸Ä ÈË:
+* ÄÚ ÈÝ:
+***************************************************************************************************/
+#ifdef _USE_MONITOR
+
+/**************************************************************************************************
+* includeÇø
+***************************************************************************************************/
+#include "sup_agent_uemessage.h"
+#include "sup_agent.h"
+#include "sup_agent_osinfopack.h"
+#include "sup_agent_status.h"
+#include "sup_agent_toolkit.h"
+#ifdef _USE_WINCOMM_SERVER
+#include "commgt_api.h"
+#endif
+
+/**************************************************************************************************
+* ³£Á¿¶¨ÒåÇø
+***************************************************************************************************/
+#define HEADER_LEN (1)
+
+/**************************************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+***************************************************************************************************/
+typedef VOID (*UeMessageCallBack)(PBYTE buf, UINT32 len);
+
+typedef struct
+{
+ UINT32 length;
+ UINT8* buffer;
+}T_BufferInfo;
+
+typedef VOID(*ConstructWindow)(VOID);
+
+typedef struct
+{
+ T_BufferInfo heap;
+ T_BufferInfo pool;
+ T_BufferInfo cpuLoad;
+ T_BufferInfo cpuFrequency;
+ T_BufferInfo version;
+ UeMessageCallBack send;
+
+}T_UeMessage;
+
+/**************************************************************************************************
+* staticº¯ÊýÉùÃ÷Çø
+***************************************************************************************************/
+static T_UeMessage s_ueMessage;
+
+static VOID ConstructTwoMessageWindow(int windowId, T_BufferInfo* info1, T_BufferInfo* info2);
+static VOID ConstructThreeMessageWindow(int windowId, T_BufferInfo* info1, T_BufferInfo* info2, T_BufferInfo* info3);
+
+static VOID SendReplyMessage(UINT32 msgId, ConstructWindow func);
+
+static T_BufferInfo* GetHeap(VOID);
+static T_BufferInfo* GetPool(VOID);
+static T_BufferInfo* GetCpuLoad(VOID);
+static T_BufferInfo* GetCpuFrequency(VOID);
+static T_BufferInfo* GetUeVersion(VOID);
+
+static VOID ConstructMemWindowInfo(VOID);
+static VOID ConstructCpuWindowInfo(VOID);
+
+
+//thread window
+static OsAgt_Status ReceiveThreadInfo(UINT32 msgId, T_ZOss_Mon_Thread* message);
+
+//event window
+static OsAgt_Status ReceiveEventInfo(UINT32 msgId, T_ZOss_Mon_Event* message);
+
+//timer window
+static OsAgt_Status ReceiveTimerInfo(UINT32 msgId, T_ZOss_Mon_Timer* message);
+
+//task window
+static OsAgt_Status ReceiveTaskInfo(UINT32 msgId, T_ZOss_Mon_Task* message);
+
+//Ram log window
+static OsAgt_Status ReceiveRamLog(UINT32 msgId, T_ZOss_Mon_Ramlog* message);
+
+//pool alloc window
+static OsAgt_Status ReceivePoolAllocInfo(UINT32 msgId, T_ZOss_Mon_Pool_Alloc* message);
+
+//mmu window
+static OsAgt_Status ReceiveMmuInfo(UINT32 msgId, T_ZOss_Mon_Mmu* message);
+
+//message window
+static OsAgt_Status ReceiveMsgInfo(UINT32 msgId, T_ZOss_Mon_Msg* message);
+
+//Pool Leak window
+static OsAgt_Status ReceivePoolLeakInfo(UINT32 msgId, T_ZOss_Mon_Pool_Leak* message);
+
+//Variable window
+static OsAgt_Status ReceiveVariable(UINT32 msgId, T_ZOss_Mon_Get_Var_Ack* message);
+
+//Mem window
+static OsAgt_Status ReceiveHeap(T_ZOss_Mon_Heap* message);
+static OsAgt_Status ReceivePool(T_ZOss_Mon_Pool* message);
+static VOID SendMemWindowInfo(UINT32 msgId);
+
+//cpu window
+static OsAgt_Status ReceiveVersion(UINT32 msgId, T_ZOss_Mon_Version* message);
+static OsAgt_Status ReceiveCpuLoad(T_ZOss_Mon_Cpu_Load* message);
+static OsAgt_Status ReceiveCpuFrequency(T_ZOss_Mon_Cpu_Frequency* message);
+static VOID SendCpuWindowInfo(UINT32 msgId);
+
+
+/**************************************************************************************************
+* º¯ÊýʵÏÖÇø
+***************************************************************************************************/
+static T_BufferInfo* GetHeap(VOID)
+{
+ return &(s_ueMessage.heap);
+}
+
+static T_BufferInfo* GetPool(VOID)
+{
+ return &(s_ueMessage.pool);
+}
+
+static T_BufferInfo* GetCpuLoad(VOID)
+{
+ return &(s_ueMessage.cpuLoad);
+}
+
+static T_BufferInfo* GetCpuFrequency(VOID)
+{
+ return &(s_ueMessage.cpuFrequency);
+}
+
+static T_BufferInfo* GetUeVersion(VOID)
+{
+ return &(s_ueMessage.version);
+}
+
+static VOID ConstructTwoMessageWindow(int windowId, T_BufferInfo* info1, T_BufferInfo* info2)
+{
+ UINT8* temp = NULL;
+ T_BufferInfo window = {0};
+ window.length =info1->length + info2->length + HEADER_LEN;
+ #ifdef _USE_WINCOMM_SERVER
+ window.buffer = zOss_Malloc(window.length);
+ #else
+ window.buffer = zOss_Malloc(window.length);
+ #endif
+ if(window.buffer != NULL)
+ {
+ temp = window.buffer;
+ *temp = (UINT8)windowId;
+
+ temp += HEADER_LEN;
+ zOss_Memcpy(temp, info1->buffer, info1->length);
+
+ temp += info1->length;
+ zOss_Memcpy(temp, info2->buffer, info2->length);
+ }
+
+ s_ueMessage.send((BYTE*)window.buffer, (WORD)window.length);
+
+ zOss_Free(info1->buffer);
+ zOss_Free(info2->buffer);
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(window.buffer);
+ #endif
+}
+
+static VOID ConstructThreeMessageWindow(int windowId, T_BufferInfo* info1, T_BufferInfo* info2, T_BufferInfo* info3)
+{
+ UINT8* temp = NULL;
+ T_BufferInfo window = {0};
+ window.length =info1->length + info2->length + info3->length + HEADER_LEN;
+ #ifdef _USE_WINCOMM_SERVER
+ window.buffer = zOss_Malloc(window.length);
+ #else
+ window.buffer = zOss_Malloc(window.length);
+ #endif
+ if(window.buffer != NULL)
+ {
+ temp = window.buffer;
+ *temp = (UINT8)windowId;
+
+ temp += HEADER_LEN;
+ zOss_Memcpy(temp, info1->buffer, info1->length);
+
+ temp += info1->length;
+ zOss_Memcpy(temp, info2->buffer, info2->length);
+
+ temp += info2->length;
+ zOss_Memcpy(temp, info3->buffer, info3->length);
+ }
+
+ s_ueMessage.send((BYTE*)window.buffer, (WORD)window.length);
+
+ zOss_Free(info1->buffer);
+ zOss_Free(info2->buffer);
+ zOss_Free(info3->buffer);
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(window.buffer);
+ #endif
+}
+
+static VOID SendReplyMessage(UINT32 msgId, ConstructWindow func)
+{
+ if(zOss_MonitorAgt_CheckReplyMessage(msgId) == OsAgt_Status_Ok)
+ {
+ func();
+ }
+}
+
+static VOID ConstructMemWindowInfo(VOID)
+{
+ ConstructTwoMessageWindow(AGT_PC_WINDOW_INFO_MEM, GetHeap(), GetPool());
+}
+
+static VOID ConstructCpuWindowInfo(VOID)
+{
+ ConstructThreeMessageWindow(AGT_PC_WINDOW_INFO_CPU, GetCpuLoad(), GetCpuFrequency(), GetUeVersion());
+}
+
+//version
+static OsAgt_Status ReceiveVersion(UINT32 msgId, T_ZOss_Mon_Version* message)
+{
+ T_BufferInfo* bufferInfo = &(s_ueMessage.version);
+
+ if(message == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo->length = sizeof(T_Version);
+ bufferInfo->buffer = zOss_Malloc(bufferInfo->length);
+
+ if(bufferInfo->buffer != NULL)
+ {
+ zOss_MonitorAgt_PackVersion(bufferInfo->buffer, message);
+ }
+
+ return OsAgt_Status_Ok;
+}
+
+
+//thread
+static OsAgt_Status ReceiveThreadInfo(UINT32 msgId, T_ZOss_Mon_Thread* message)
+{
+ T_BufferInfo bufferInfo = {0};
+ UINT8* temp = NULL;
+ UINT32 index = 0;
+ UINT32 length = sizeof(T_Thread_Ele);
+
+ if (zOss_MonitorAgt_CheckReplyMessage(msgId) != OsAgt_Status_Ok)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ if(message == NULL || message->num == 0 || message->ele == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo.length = (UINT32)(length * message->num + HEADER_LEN);
+ #ifdef _USE_WINCOMM_SERVER
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #else
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #endif
+
+ if(bufferInfo.buffer != NULL)
+ {
+ *(bufferInfo.buffer) = AGT_PC_WINDOW_INFO_THREAD;
+ temp = bufferInfo.buffer + HEADER_LEN;
+ for(index = 0; index < message->num; index++)
+ {
+ zOss_MonitorAgt_PackThreadEle(temp, &(message->ele[index]));
+ temp += length;
+ }
+ }
+
+ s_ueMessage.send(bufferInfo.buffer, bufferInfo.length);
+
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(bufferInfo.buffer);
+ #endif
+
+ return OsAgt_Status_Ok;
+}
+
+//event
+static OsAgt_Status ReceiveEventInfo(UINT32 msgId, T_ZOss_Mon_Event* message)
+{
+ T_BufferInfo bufferInfo = {0};
+ UINT8* temp = NULL;
+ UINT32 index = 0;
+ UINT32 length = sizeof(T_Event_Ele);
+
+ if (zOss_MonitorAgt_CheckReplyMessage(msgId) != OsAgt_Status_Ok)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ if(message == NULL || message->num == 0 || message->ele == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo.length = (UINT32)(length * message->num + HEADER_LEN);
+
+ #ifdef _USE_WINCOMM_SERVER
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #else
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #endif
+
+ if(bufferInfo.buffer != NULL)
+ {
+ *(bufferInfo.buffer) = AGT_PC_WINDOW_INFO_EVENT;
+ temp = bufferInfo.buffer + HEADER_LEN;
+ for(index = 0; index < message->num; index++)
+ {
+ zOss_MonitorAgt_PackEventEle(temp, &(message->ele[index]));
+ temp += length;
+ }
+ }
+
+ s_ueMessage.send(bufferInfo.buffer, bufferInfo.length);
+
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(bufferInfo.buffer);
+ #endif
+
+ return OsAgt_Status_Ok;
+}
+
+//timer
+static OsAgt_Status ReceiveTimerInfo(UINT32 msgId, T_ZOss_Mon_Timer* message)
+{
+ T_BufferInfo bufferInfo = {0};
+ UINT8* temp = NULL;
+ UINT32 index = 0;
+ UINT32 length = sizeof(T_Timer_Ele);
+
+ if (zOss_MonitorAgt_CheckReplyMessage(msgId) != OsAgt_Status_Ok)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ if(message == NULL || message->num == 0 || message->ele == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo.length = (UINT32)(length * message->num + HEADER_LEN);
+ #ifdef _USE_WINCOMM_SERVER
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #else
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #endif
+
+ if(bufferInfo.buffer != NULL)
+ {
+ *(bufferInfo.buffer) = AGT_PC_WINDOW_INFO_TIMER;
+ temp = bufferInfo.buffer + HEADER_LEN;
+ for(index = 0; index < message->num; index++)
+ {
+ zOss_MonitorAgt_PackTimerEle(temp, &(message->ele[index]));
+ temp += length;
+ }
+ }
+
+ s_ueMessage.send(bufferInfo.buffer, bufferInfo.length);
+
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(bufferInfo.buffer);
+ #endif
+
+ return OsAgt_Status_Ok;
+}
+
+//task
+static OsAgt_Status ReceiveTaskInfo(UINT32 msgId, T_ZOss_Mon_Task* message)
+{
+ T_BufferInfo bufferInfo = {0};
+ UINT8* temp = NULL;
+ UINT32 index = 0;
+ UINT32 length = sizeof(T_Task_Ele);
+
+ if (zOss_MonitorAgt_CheckReplyMessage(msgId) != OsAgt_Status_Ok)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ if(message == NULL || message->num == 0 || message->ele == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo.length = (UINT32)(length * message->num + HEADER_LEN);
+ #ifdef _USE_WINCOMM_SERVER
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #else
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #endif
+
+ if(bufferInfo.buffer != NULL)
+ {
+ *(bufferInfo.buffer) = AGT_PC_WINDOW_INFO_TASK;
+ temp = bufferInfo.buffer + HEADER_LEN;
+ for(index = 0; index < message->num; index++)
+ {
+ zOss_MonitorAgt_PackTaskEle(temp, &(message->ele[index]));
+ temp += length;
+ }
+ }
+
+ s_ueMessage.send(bufferInfo.buffer, bufferInfo.length);
+
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(bufferInfo.buffer);
+ #endif
+
+ return OsAgt_Status_Ok;
+}
+
+
+//Ram log
+static OsAgt_Status ReceiveRamLog(UINT32 msgId, T_ZOss_Mon_Ramlog* message)
+{
+ T_BufferInfo bufferInfo = {0};
+
+ if (zOss_MonitorAgt_CheckReplyMessage(msgId) != OsAgt_Status_Ok)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ if(message == NULL || message->ramlog == NULL || message->size == 0)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo.length = (UINT32)(message->size + HEADER_LEN);
+ #ifdef _USE_WINCOMM_SERVER
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #else
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #endif
+
+ if(bufferInfo.buffer != NULL)
+ {
+ *(bufferInfo.buffer) = AGT_PC_WINDOW_INFO_RAMLOG;
+ zOss_Memcpy(bufferInfo.buffer + HEADER_LEN, message->ramlog, message->size);
+ }
+
+ s_ueMessage.send(bufferInfo.buffer, bufferInfo.length);
+
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(bufferInfo.buffer);
+ #endif
+
+ return OsAgt_Status_Ok;
+}
+
+//pool alloc
+static OsAgt_Status ReceivePoolAllocInfo(UINT32 msgId, T_ZOss_Mon_Pool_Alloc* message)
+{
+ T_BufferInfo bufferInfo = {0};
+ UINT8* temp = NULL;
+ UINT32 index = 0;
+ UINT32 length = sizeof(T_Pool_Alloc_Ele);
+
+ if (zOss_MonitorAgt_CheckReplyMessage(msgId) != OsAgt_Status_Ok)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ if(message == NULL || message->num == 0 || message->ele == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo.length = (UINT32)(length * message->num + HEADER_LEN);
+ #ifdef _USE_WINCOMM_SERVER
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #else
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #endif
+
+ if(bufferInfo.buffer != NULL)
+ {
+ *(bufferInfo.buffer) = AGT_PC_WINDOW_INFO_POOL;
+ temp = bufferInfo.buffer + HEADER_LEN;
+ for(index = 0; index < message->num; index++)
+ {
+ zOss_MonitorAgt_PackPoolAllocEle(temp, &(message->ele[index]));
+ temp += length;
+ }
+ }
+
+ s_ueMessage.send(bufferInfo.buffer, bufferInfo.length);
+
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(bufferInfo.buffer);
+ #endif
+
+ return OsAgt_Status_Ok;
+}
+
+//mmu
+static OsAgt_Status ReceiveMmuInfo(UINT32 msgId, T_ZOss_Mon_Mmu* message)
+{
+ T_BufferInfo bufferInfo = {0};
+ UINT8* temp = NULL;
+ UINT32 index = 0;
+ UINT32 length = sizeof(T_Mmu_Ele);
+
+ if (zOss_MonitorAgt_CheckReplyMessage(msgId) != OsAgt_Status_Ok)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ if(message == NULL || message->num == 0 || message->ele == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo.length = (UINT32)(length * message->num + HEADER_LEN);
+ #ifdef _USE_WINCOMM_SERVER
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #else
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #endif
+
+ if(bufferInfo.buffer != NULL)
+ {
+ *(bufferInfo.buffer) = AGT_PC_WINDOW_INFO_MMU;
+ temp = bufferInfo.buffer + HEADER_LEN;
+ for(index = 0; index < message->num; index++)
+ {
+ zOss_MonitorAgt_PackMmuEle(temp, &(message->ele[index]));
+ temp += length;
+ }
+ }
+
+ s_ueMessage.send(bufferInfo.buffer, bufferInfo.length);
+
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(bufferInfo.buffer);
+ #endif
+
+ return OsAgt_Status_Ok;
+}
+
+//message
+static OsAgt_Status ReceiveMsgInfo(UINT32 msgId, T_ZOss_Mon_Msg* message)
+{
+ T_BufferInfo bufferInfo = {0};
+ UINT8* temp = NULL;
+ UINT32 index = 0;
+ UINT32 length = sizeof(T_Msg_Ele);
+
+ if (zOss_MonitorAgt_CheckReplyMessage(msgId) != OsAgt_Status_Ok)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ if(message == NULL || message->num == 0 || message->ele == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo.length = (UINT32)(length * message->num + HEADER_LEN);
+ #ifdef _USE_WINCOMM_SERVER
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #else
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #endif
+
+ if(bufferInfo.buffer != NULL)
+ {
+ *(bufferInfo.buffer) = AGT_PC_WINDOW_INFO_MSG;
+ temp = bufferInfo.buffer + HEADER_LEN;
+ for(index = 0; index < message->num; index++)
+ {
+ zOss_MonitorAgt_PackMsgEle(temp, &(message->ele[index]));
+ temp += length;
+ }
+ }
+
+ s_ueMessage.send(bufferInfo.buffer, bufferInfo.length);
+
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(bufferInfo.buffer);
+ #endif
+
+ return OsAgt_Status_Ok;
+}
+
+//Pool Leak
+static OsAgt_Status ReceivePoolLeakInfo(UINT32 msgId, T_ZOss_Mon_Pool_Leak* message)
+{
+ T_BufferInfo bufferInfo = {0};
+ UINT8* temp = NULL;
+ UINT32 index = 0;
+ UINT32 length = sizeof(T_Pool_Leak_Ele);
+
+ if (zOss_MonitorAgt_CheckReplyMessage(msgId) != OsAgt_Status_Ok)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ if(message == NULL || message->num == 0 || message->ele == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo.length = (UINT32)(length * message->num + HEADER_LEN);
+ #ifdef _USE_WINCOMM_SERVER
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #else
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #endif
+
+ if(bufferInfo.buffer != NULL)
+ {
+ *(bufferInfo.buffer) = AGT_PC_WINDOW_INFO_POOLLEAK;
+ temp = bufferInfo.buffer + HEADER_LEN;
+ for(index = 0; index < message->num; index++)
+ {
+ zOss_MonitorAgt_PackPoolLeakEle(temp, &(message->ele[index]));
+ temp += length;
+ }
+ }
+
+ s_ueMessage.send(bufferInfo.buffer, bufferInfo.length);
+
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(bufferInfo.buffer);
+ #endif
+
+ return OsAgt_Status_Ok;
+}
+
+
+//Variable
+static OsAgt_Status ReceiveVariable(UINT32 msgId, T_ZOss_Mon_Get_Var_Ack* message)
+{
+ T_BufferInfo bufferInfo = {0};
+
+ if (zOss_MonitorAgt_CheckReplyMessage(msgId) != OsAgt_Status_Ok)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ if(message == NULL || message->value == NULL || message->size == 0)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ bufferInfo.length = (UINT32)(message->size + HEADER_LEN);
+ #ifdef _USE_WINCOMM_SERVER
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #else
+ bufferInfo.buffer = zOss_Malloc(bufferInfo.length);
+ #endif
+
+ if(bufferInfo.buffer != NULL)
+ {
+ *(bufferInfo.buffer) = AGT_PC_WINDOW_INFO_VARIABLE;
+ zOss_Memcpy(bufferInfo.buffer + HEADER_LEN, message->value, message->size);
+ }
+
+ s_ueMessage.send(bufferInfo.buffer, bufferInfo.length);
+
+ #ifndef _USE_WINCOMM_SERVER
+ zOss_Free(bufferInfo.buffer);
+ #endif
+
+ return OsAgt_Status_Ok;
+}
+
+
+//Mem
+static OsAgt_Status ReceiveHeap(T_ZOss_Mon_Heap* message)
+{
+ T_BufferInfo* heap = &(s_ueMessage.heap);
+
+ if(message == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ heap->length = sizeof(T_Heap);
+ heap->buffer = zOss_Malloc(heap->length);
+ if(heap->buffer != NULL)
+ {
+ zOss_MonitorAgt_PackHeap(heap->buffer, message);
+ }
+
+ return OsAgt_Status_Ok;
+}
+
+static OsAgt_Status ReceivePool(T_ZOss_Mon_Pool* message)
+{
+ BYTE* temp = NULL;
+ unsigned int index = 0;
+ UINT32 length = sizeof(T_Pool_Ele);
+ T_BufferInfo* pool = &(s_ueMessage.pool);
+
+ if(message == NULL || message->num == 0 || message->ele == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ pool->length = (UINT32)(message->num*length);
+ pool->buffer = zOss_Malloc(pool->length);
+ if(pool->buffer != NULL)
+ {
+ temp = pool->buffer;
+ for(index = 0; index < message->num; index++)
+ {
+ zOss_MonitorAgt_PackPoolEle(temp, &(message->ele[index]));
+ temp += length;
+ }
+ }
+
+ return OsAgt_Status_Ok;
+}
+
+
+
+static VOID SendMemWindowInfo(UINT32 msgId)
+{
+ SendReplyMessage(msgId, ConstructMemWindowInfo);
+}
+
+//cpu
+static OsAgt_Status ReceiveCpuLoad(T_ZOss_Mon_Cpu_Load* message)
+{
+ T_BufferInfo* cpuLoad = &(s_ueMessage.cpuLoad);
+
+ if(message == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ cpuLoad->length = sizeof(T_CpuLoad);
+ cpuLoad->buffer = zOss_Malloc(cpuLoad->length);
+ if(cpuLoad->buffer != NULL)
+ {
+ zOss_MonitorAgt_PackCpuLoad(cpuLoad->buffer, message);
+ }
+
+ return OsAgt_Status_Ok;
+}
+
+static OsAgt_Status ReceiveCpuFrequency(T_ZOss_Mon_Cpu_Frequency* message)
+{
+ T_BufferInfo* cpuFrequency = &(s_ueMessage.cpuFrequency);
+
+ if(message == NULL)
+ {
+ return OsAgt_Status_Error;
+ }
+
+ cpuFrequency->length = sizeof(T_Frequency);
+ cpuFrequency->buffer = zOss_Malloc(cpuFrequency->length);
+ if(cpuFrequency->buffer != NULL)
+ {
+ zOss_MonitorAgt_PackFrequency(cpuFrequency->buffer, message);
+ }
+
+ return OsAgt_Status_Ok;
+}
+
+
+static VOID SendCpuWindowInfo(UINT32 msgId)
+{
+ SendReplyMessage(msgId, ConstructCpuWindowInfo);
+}
+
+
+VOID zOss_MonitorAgt_InitUeMessage()
+{
+ zOss_Memset(&s_ueMessage, 0, sizeof(s_ueMessage));
+ s_ueMessage.send = zOss_MonitorAgt_SendDataToPcTool;
+}
+
+
+VOID zOss_MonitorAgt_UeMessageHandler(UINT32 msgId, UINT8 *buf)
+{
+ OsAgt_Status status = OsAgt_Status_Ok;
+
+ switch(msgId)
+ {
+ case OSS_MON_VERSION:
+ if((status = ReceiveVersion(msgId, (T_ZOss_Mon_Version*)buf)) == OsAgt_Status_Ok)
+ {
+ SendCpuWindowInfo(msgId);
+ }
+ break;
+
+ case OSS_MON_THREAD:
+ ReceiveThreadInfo(msgId, (T_ZOss_Mon_Thread*)buf);
+ break;
+
+ case OSS_MON_EVENT:
+ ReceiveEventInfo(msgId, (T_ZOss_Mon_Event*)buf);
+ break;
+
+ case OSS_MON_TIMER:
+ ReceiveTimerInfo(msgId, (T_ZOss_Mon_Timer*)buf);
+ break;
+
+ case OSS_MON_TASK:
+ ReceiveTaskInfo(msgId, (T_ZOss_Mon_Task*)buf);
+ break;
+
+ case OSS_MON_RAMLOG:
+ ReceiveRamLog(msgId, (T_ZOss_Mon_Ramlog*)buf);
+ break;
+
+ case OSS_MON_POOL_ALLOC:
+ ReceivePoolAllocInfo(msgId, (T_ZOss_Mon_Pool_Alloc*)buf);
+ break;
+
+ case OSS_MON_MMU:
+ ReceiveMmuInfo(msgId, (T_ZOss_Mon_Mmu*)buf);
+ break;
+
+ case OSS_MON_MSG:
+ ReceiveMsgInfo(msgId, (T_ZOss_Mon_Msg*)buf);
+ break;
+
+ case OSS_MON_POOL_LEAK:
+ ReceivePoolLeakInfo(msgId, (T_ZOss_Mon_Pool_Leak*)buf);
+ break;
+
+ case OSS_MON_GET_VAR_ACK:
+ ReceiveVariable(msgId, (T_ZOss_Mon_Get_Var_Ack*)buf);
+ break;
+
+ case OSS_MON_HEAP:
+ {
+ if((status = ReceiveHeap((T_ZOss_Mon_Heap*)buf)) == OsAgt_Status_Ok)
+ {
+ SendMemWindowInfo(msgId);
+ }
+ }
+ break;
+
+ case OSS_MON_POOL:
+ {
+ if((status = ReceivePool((T_ZOss_Mon_Pool*)buf)) == OsAgt_Status_Ok)
+ {
+ SendMemWindowInfo(msgId);
+ }
+ }
+ break;
+
+ case OSS_MON_CPU_LOAD:
+ {
+ if((status = ReceiveCpuLoad((T_ZOss_Mon_Cpu_Load*)buf)) == OsAgt_Status_Ok)
+ {
+ SendCpuWindowInfo(msgId);
+ }
+ }
+ break;
+
+ case OSS_MON_CPU_FREQUENCY:
+ {
+ if((status = ReceiveCpuFrequency((T_ZOss_Mon_Cpu_Frequency*)buf)) == OsAgt_Status_Ok)
+ {
+ SendCpuWindowInfo(msgId);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ if(status == OsAgt_Status_Error)
+ {
+ zOss_MonitorAgt_CheckReplyMessage(msgId);
+ }
+
+ return;
+}
+
+#endif
+
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_assert.c b/cp/ps/plat/src/oss/sup/src/sup_assert.c
new file mode 100644
index 0000000..1861b16
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_assert.c
@@ -0,0 +1,83 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_assert.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : ¶ÏÑÔ½Ó¿Ú
+* ×÷ Õß :
+* °æ ±¾ :
+* Íê³ÉÈÕÆÚ :
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* Íⲿº¯ÊýÉùÃ÷Çø
+**************************************************************************/
+#ifdef _OS_TOS
+extern void tos_assert_failed(const char *exp, const char *file, const char *func, int line);
+#elif defined (_OS_LINUX)
+extern void linux_assert_failed(const char *exp, const char *file, const char *func, int line);
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* º¯ÊýÃû³Æ£º EXP_Handler
+* ¹¦ÄÜÃèÊö£º zOss_ASSERT´¦Àí
+* ²ÎÊý˵Ã÷£º pExp:zOss_ASSERTµÄ±í´ïʽ
+ pcFileName£º³ö´íµÄÎļþÃû
+ pcFuncName£º³ö´íµÄº¯ÊýÃû
+ dwLineNum£º ³ö´íËùÔÚµÄÐÐ
+* ·µ »Ø Öµ£º
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID EXP_Handler(const CHAR *pExp, const CHAR *pcFileName, const CHAR *pcFuncName, SINT32 dwLineNum)
+{
+#ifdef _OS_WIN
+ _assert(pExp, (char *)pcFileName, (unsigned int)dwLineNum);
+#elif defined (_OS_OSE)
+ ZOSS_INTR old_intr;
+
+ ZOSS_SAVE_IRQ(old_intr);
+ ose_assertion_failed((char *)pExp, (char *)pcFileName, (unsigned int)dwLineNum);
+ old_intr = old_intr != 0 ? old_intr : 0;
+#elif defined (_OS_TOS)
+ tos_assert_failed((const char *)pExp, pcFileName, pcFuncName, dwLineNum);
+#elif defined (_OS_LINUX)
+ linux_assert_failed((const char *)pExp, pcFileName, pcFuncName, dwLineNum);
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/cp/ps/plat/src/oss/sup/src/sup_crc.c b/cp/ps/plat/src/oss/sup/src/sup_crc.c
new file mode 100644
index 0000000..7ebbf1a
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_crc.c
@@ -0,0 +1,166 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : CrcCheck.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : CRCУÑéµÄʵÏÖÎļþ
+* ×÷ Õß : ÐíÐË¿ü
+* °æ ±¾ :
+* Íê³ÉÈÕÆÚ : 2007-08-31
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001782014
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0002
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-27
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é EC:617001782003
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+/* CRC */
+const UINT8 crctable[256] = /* reversed, 8-bit, poly=0x07 */
+{
+ 0x00, 0x91, 0xe3, 0x72, 0x07, 0x96, 0xe4, 0x75,
+ 0x0e, 0x9f, 0xed, 0x7c, 0x09, 0x98, 0xea, 0x7b,
+ 0x1c, 0x8d, 0xff, 0x6e, 0x1b, 0x8a, 0xf8, 0x69,
+ 0x12, 0x83, 0xf1, 0x60, 0x15, 0x84, 0xf6, 0x67,
+
+ 0x38, 0xa9, 0xdb, 0x4a, 0x3f, 0xae, 0xdc, 0x4d,
+ 0x36, 0xa7, 0xd5, 0x44, 0x31, 0xa0, 0xd2, 0x43,
+ 0x24, 0xb5, 0xc7, 0x56, 0x23, 0xb2, 0xc0, 0x51,
+ 0x2a, 0xbb, 0xc9, 0x58, 0x2d, 0xbc, 0xce, 0x5f,
+
+ 0x70, 0xe1, 0x93, 0x02, 0x77, 0xe6, 0x94, 0x05,
+ 0x7e, 0xef, 0x9d, 0x0c, 0x79, 0xe8, 0x9a, 0x0b,
+ 0x6c, 0xfd, 0x8f, 0x1e, 0x6b, 0xfa, 0x88, 0x19,
+ 0x62, 0xf3, 0x81, 0x10, 0x65, 0xf4, 0x86, 0x17,
+
+ 0x48, 0xd9, 0xab, 0x3a, 0x4f, 0xde, 0xac, 0x3d,
+ 0x46, 0xd7, 0xa5, 0x34, 0x41, 0xd0, 0xa2, 0x33,
+ 0x54, 0xc5, 0xb7, 0x26, 0x53, 0xc2, 0xb0, 0x21,
+ 0x5a, 0xcb, 0xb9, 0x28, 0x5d, 0xcc, 0xbe, 0x2f,
+
+ 0xe0, 0x71, 0x03, 0x92, 0xe7, 0x76, 0x04, 0x95,
+ 0xee, 0x7f, 0x0d, 0x9c, 0xe9, 0x78, 0x0a, 0x9b,
+ 0xfc, 0x6d, 0x1f, 0x8e, 0xfb, 0x6a, 0x18, 0x89,
+ 0xf2, 0x63, 0x11, 0x80, 0xf5, 0x64, 0x16, 0x87,
+
+ 0xd8, 0x49, 0x3b, 0xaa, 0xdf, 0x4e, 0x3c, 0xad,
+ 0xd6, 0x47, 0x35, 0xa4, 0xd1, 0x40, 0x32, 0xa3,
+ 0xc4, 0x55, 0x27, 0xb6, 0xc3, 0x52, 0x20, 0xb1,
+ 0xca, 0x5b, 0x29, 0xb8, 0xcd, 0x5c, 0x2e, 0xbf,
+
+ 0x90, 0x01, 0x73, 0xe2, 0x97, 0x06, 0x74, 0xe5,
+ 0x9e, 0x0f, 0x7d, 0xec, 0x99, 0x08, 0x7a, 0xeb,
+ 0x8c, 0x1d, 0x6f, 0xfe, 0x8b, 0x1a, 0x68, 0xf9,
+ 0x82, 0x13, 0x61, 0xf0, 0x85, 0x14, 0x66, 0xf7,
+
+ 0xa8, 0x39, 0x4b, 0xda, 0xaf, 0x3e, 0x4c, 0xdd,
+ 0xa6, 0x37, 0x45, 0xd4, 0xa1, 0x30, 0x42, 0xd3,
+ 0xb4, 0x25, 0x57, 0xc6, 0xb3, 0x22, 0x50, 0xc1,
+ 0xba, 0x2b, 0x59, 0xc8, 0xbd, 0x2c, 0x5e, 0xcf
+};
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºComm_CrcCalc
+* ¹¦ÄÜÃèÊö£º¸ù¾Ý¸ø¶¨µÄÊý¾Ý¼ÆËãCRCУÑéÂë
+* ²ÎÊý˵Ã÷£º(IN)
+ buf:ÊäÈ뻺³åÇø
+ len:ÊäÈ뻺³åÇøµÄ³¤¶È
+ (OUT)
+* ·µ »Ø Öµ£º¼ÆËã³öµÄУÑéÂë
+* ÆäËû˵Ã÷£ºÎÞ
+**************************************************************************/
+UINT8 Comm_CrcCalc(const UINT8 *buf, UINT8 len)
+{
+ UINT8 fcs = 0xff;
+
+ if (buf != NULL)
+ {
+ while (len--)
+ {
+ fcs = crctable[fcs ^ *buf++];
+ }
+
+ return (UINT8)(0xff - fcs);
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºComm_CrcCheck
+* ¹¦ÄÜÃèÊö£ºCRCУÑ麯Êý
+* ²ÎÊý˵Ã÷£º(IN)
+ buf:Êý¾Ý»º³åÇø
+ len:»º³åÇøÊý¾Ý³¤¶È
+ crc:УÑéÂë
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»Ø0£¬·ñÔò·µ»Ø-1.
+* ÆäËû˵Ã÷£º
+**************************************************************************/
+SINT32 Comm_CrcCheck(UINT8 *buf, UINT8 len, UINT8 crc)
+{
+ UINT8 fcs = 0xff;
+
+ zOss_AssertEx(buf != NULL, -1);
+
+ while (len--)
+ {
+ fcs = crctable[fcs ^ *buf++];
+ }
+ fcs = crctable[fcs ^ crc];
+
+ return (fcs == 0xcf ? 0 : -1);
+}
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_except.c b/cp/ps/plat/src/oss/sup/src/sup_except.c
new file mode 100644
index 0000000..43520fe
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_except.c
@@ -0,0 +1,369 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_except.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : Òì³£¹ÜÀíÄ£¿é
+* ×÷ Õß : ÏÄйú
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2007/08/01
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : ÖܹúÆÂ
+* °æ ±¾ ºÅ : V1.1
+* ÐÞ¸ÄÈÕÆÚ : 2007/09/03
+* ÐÞ¸ÄÄÚÈÝ : Ôö¼Ó½Ó¿Úº¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0002
+* ÐÞ ¸Ä ÈË : dengningkun
+* ÐÞ¸ÄÈÕÆÚ : 2012/9/27
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT¼ì²é EC:617001782169
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0003
+* ÐÞ ¸Ä ÈË : dengningkun
+* ÐÞ¸ÄÈÕÆÚ : 2012/10/10
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é EC:617001782205
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+
+#include "oss_api.h"
+#include "osa.h"
+#include "sup.h"
+#include "sup_except.h"
+#include "ThreadPriority.h"
+#ifdef _USE_WDT_RST
+#include "drvs_wdt.h"
+#include "sys_func_atcfg.h"
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* Íⲿº¯ÊýÉùÃ÷Çø
+**************************************************************************/
+#ifdef _OS_TOS
+extern FLOAT Osa_GetProcessCPU(ZOSS_THREAD_ID thread_id);
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#ifdef _USE_WDT_RST
+#define TRACE_WATCHDOG_FEED_PERIOD 1000
+#define TRACE_WATCHDOG_FEED_VALUE 5000
+#endif
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+#ifndef _USE_PSM
+#if defined (_OS_WIN) || defined (_OS_OSE)
+static VOID Excep_IdleThread(SINT32 ingore);
+#endif
+#endif
+#ifdef _USE_WDT_RST
+static VOID Excep_WatchDogCallBack(SINT32 args);
+#endif
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+ZOSS_TASK_ID gExcep_DaemonTask = ZOSS_INVALID_TASK_ID;
+
+static T_EXCEP_PARAM *gExcep_Param = NULL;
+
+#ifdef _USE_WDT_RST
+static ZOSS_TIMER_ID gTrace_WatchDogTimerID = NULL;
+#endif
+/* ÒÆÖ² */
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+/* ÒÆ Ö² */
+#ifndef _USE_PSM
+#if defined (_OS_WIN) || defined (_OS_OSE)
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Excep_IdleThread
+* ¹¦ÄÜÃèÊö£º
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID Excep_IdleThread(SINT32 ingore)
+{
+#ifdef _OS_OSE
+ UINT32 dwZero=0;
+ SINT32 i = 0;
+
+ for(;;)
+ {
+ i++;
+ if (!(i%3000000))
+ {
+ SYSTIME_Init();
+ }
+ }
+#elif defined (_OS_TOS)
+ for(;;)
+ ;
+#elif defined (_OS_LINUX)
+ for(;;)
+ ;
+#endif
+}
+#endif
+#endif
+#ifdef _USE_WDT_RST
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Excep_WatchDogCallBack
+* ¹¦ÄÜÃèÊö£º ¶¨Ê±Æ÷ι¹·»Øµ÷º¯Êý
+* ²ÎÊý˵Ã÷£º args: ¶¨Ê±Æ÷²ÎÊý
+* ·µ »Ø Öµ£º VOID
+* ÆäËü˵Ã÷£º VOID
+**************************************************************************/
+static VOID Excep_WatchDogCallBack(SINT32 args)
+{
+ zDrvWdt_FeedDog(TRACE_WATCHDOG_FEED_VALUE);
+}
+#endif
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Excep_Init
+* ¹¦ÄÜÃèÊö£º Ò쳣ģ¿é³õʼ»¯
+* ²ÎÊý˵Ã÷£º ÎÞ
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS£¬Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 EXCEP_Init(VOID)
+{
+#if defined(_USE_WDT_RST)
+ UINT32 nRet = ZOSS_ERROR;
+ UINT32 flag = 0;
+
+ flag = zOss_GetExceptResetFlag();
+ if (flag == EXCEPT_RESET_ENABLE)
+ {
+ gTrace_WatchDogTimerID = zOss_CreateTimer("WatchDogTimer",
+ (ZOSS_TIMER_FUN)Excep_WatchDogCallBack,
+ (SINT32)0,
+ TRUE);
+ zOss_AssertEx(NULL != gTrace_WatchDogTimerID, ZOSS_ERROR);
+
+ nRet = zOss_StartTimer(gTrace_WatchDogTimerID,
+ TRACE_WATCHDOG_FEED_PERIOD,
+ Excep_WatchDogCallBack,
+ 0);
+ zOss_AssertEx(ZOSS_ERROR != nRet, ZOSS_ERROR);
+ }
+ else
+ {
+ zDrvWdt_Stop();
+ }
+#endif
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º EXCEP_StartDaemonTask
+* ¹¦ÄÜÃèÊö£º Æô¶¯ÈÎÎñËÀÑ»·¼à²â
+* ²ÎÊý˵Ã÷£º ÎÞ
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS£¬Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 EXCEP_StartDaemonTask(VOID)
+{
+ T_OSS_PARAM *osscfg = NULL;
+
+ if(THR1_PRI < 1)
+ {
+ return ZOSS_ERROR;
+ }
+
+ osscfg = zOss_GetOssCfg();
+ gExcep_Param = &(osscfg->ExcepCfg);
+ gExcep_DaemonTask = zOss_CreateTask(EXCEP_DAEMONTASKNAME, Excep_DaemonTask, 4 * 1024, THR1_PRI - 1, 2048, 0);
+ if (ZOSS_INVALID_TASK_ID == gExcep_DaemonTask)
+ {
+ return ZOSS_ERROR;
+ }
+ if (ZOSS_ERROR == zOss_TaskSend(EV_POWERON, NULL, 0, gExcep_DaemonTask))
+ {
+ return ZOSS_ERROR;
+ }
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Excep_DaemonTask
+* ¹¦ÄÜÃèÊö£º Ò쳣ģ¿éÊØ»¤ÈÎÎñ
+* ²ÎÊý˵Ã÷£º state:ÈÎÎñ״̬
+ msg_id:ÏûÏ¢ID
+ buf:ÏûÏ¢ÌåÖ¸Õë
+ msg_len:ÏûÏ¢³¤¶È
+ private_data:˽ÓÐÊý¾Ý
+* ·µ »Ø Öµ£º ÎÞ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID Excep_DaemonTask(UINT8 state, UINT32 msg_id, UINT8 *buf, UINT16 msg_len, UINT8 *private_data)
+{
+ ZOSS_TIMER_ID tid = ZOSS_INVALID_TIMER_ID;
+ ZOSS_TASK_ID *task_ids = (ZOSS_TASK_ID *)private_data;
+
+ switch (state)
+ {
+ case ZOSS_STATUS_INIT:
+ {
+ switch (msg_id)
+ {
+ case EV_INIT:
+ {
+ break;
+ }
+ case EV_POWERON:
+ {
+ tid = zOss_SetRelativeTimer(gExcep_Param->DeamonStartTime, EV_ZOSS_EXCEP_WDT_SET, 0);
+ if (ZOSS_INVALID_TIMER_ID == tid)
+ {
+ zOss_ASSERT(0);
+ }
+ if (ZOSS_ERROR == zOss_SetState(ZOSS_STATUS_WORK))
+ {
+ zOss_ASSERT(0);
+ }
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ break;
+ }
+ case ZOSS_STATUS_WORK:
+ {
+ switch (msg_id)
+ {
+ case EV_ZOSS_EXCEP_WDT_SET:
+ {
+ /* ÉèÖÃËÀÑ»·¼ì²â¶¨Ê±Æ÷ */
+ tid = zOss_SetLoopTimer(gExcep_Param->DeadLoopCheckTime, EV_ZOSS_EXCEP_DEADLOOPCHECK, 0);
+ if (ZOSS_INVALID_TIMER_ID == tid)
+ {
+ zOss_ASSERT(0);
+ }
+#ifndef _USE_PSM
+#if defined (_OS_WIN) || defined (_OS_OSE)
+ if (ZOSS_INVALID_THREAD_ID == zOss_CreateThread(EXCEP_IDLETHREADNAME, Excep_IdleThread, 0, 1024, 31, 1, 1))
+ {
+ zOss_ASSERT(0);
+ }
+#endif
+#endif
+ break;
+ }
+ case EV_ZOSS_EXCEP_DEADLOOPCHECK:
+ {
+ UINT32 num = 0;
+ UINT32 i = 0;
+ T_ZOss_TCB *tinfo = NULL;
+
+ num = Sche_DeadLoop(task_ids);
+ while (ZOSS_INVALID_TASK_ID != task_ids[i] && i < num)
+ {
+ /* OSS_DeleteTask(task_ids[i]); */
+ if (NULL == tinfo)
+ {
+ tinfo = (T_ZOss_TCB *)zOss_Malloc(sizeof(T_ZOss_TCB));
+ if (NULL == tinfo)
+ {
+ zOss_AssertExN(NULL != tinfo);
+ }
+ }
+ if (ZOSS_ERROR == zOss_GetTaskInfo(task_ids[i], tinfo))
+ {
+ tinfo->task_name[0] = '\0';
+ }
+ zOss_Printf(SUBMDL_EXCEP, PRINT_LEVEL_ABNORMAL, "dead task found:%p,name:%s\r\n", task_ids[i], tinfo->task_name);
+
+ i++;
+ }
+ if (NULL != tinfo)
+ {
+ zOss_Free(tinfo);
+ }
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ } /* end switch(msg_id) */
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ } /* end switch(state) */
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_GetCPU
+* ¹¦ÄÜÃèÊö£º µÃµ½CPUµÄʹÓÃÂÊ
+* ²ÎÊý˵Ã÷£º ÎÞ
+* ·µ »Ø Öµ£º CPUµÄʹÓÃÂÊ(0-100)
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT8 zOss_GetCPU(VOID)
+{
+#ifdef _OS_OSE
+ UINT8 rate = 0;
+ ZOSS_THREAD_ID t_id = ZOSS_INVALID_THREAD_ID;
+ T_ZOsa_ThreadUserArea *pUa = NULL;
+
+ t_id = zOss_GetThreadIDByName(EXCEP_IDLETHREADNAME);
+ pUa = Osa_GetThreadUserArea(t_id, FALSE);
+ rate = (UINT8)pUa->cpupercent;
+ if (rate > 100)
+ {
+ rate = 0;
+ }
+
+ return (100 - rate);
+#elif defined (_OS_TOS)
+ return (UINT8)(100 - Osa_GetProcessCPU(zOss_GetThreadIDByName(EXCEP_IDLETHREADNAME)));
+#else
+ return 0;
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_except_arm_asm.S b/cp/ps/plat/src/oss/sup/src/sup_except_arm_asm.S
new file mode 100644
index 0000000..ab17053
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_except_arm_asm.S
@@ -0,0 +1,133 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_except_arm_asm.S
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : arm´¦ÀíÆ÷
+* ×÷ Õß : ÁõÑÇÄÏ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2011/12/16
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+
+
+/**************************************************************************
+* È«¾Öº¯ÊýÉùÃ÷
+**************************************************************************/
+.global zOss_RamdumpSaveRegisters
+.global zOss_Cp15ReadControlRegister
+.global zOss_ReadCpsr
+.global zOss_CleanCache
+
+/**************************************************************************
+* Íⲿ±äÁ¿ÉùÃ÷
+**************************************************************************/
+.extern Osa_CoreRegisters
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+ º¯ÊýÃû³Æ£ºzOss_SaveRegisters
+ ¹¦ÄÜÃèÊö£º ±£´æÒì³£·¢ÉúʱËùÓеļĴæÖµÖÁ½á¹¹Ìå±äÁ¿(Osa_CoreRegisters),
+ ÔÚµ÷Óú¯Êý֮ǰÐè½ûÖ¹ËùÓÐÖжÏ
+ ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ (OUT):ÎÞ
+ ·µ »Ø Öµ£º ÎÞ
+ ÆäËü˵Ã÷£º
+ **************************************************************************/
+.text
+.balign 4
+.type zOss_RamdumpSaveRegisters, %function
+zOss_RamdumpSaveRegisters:
+ PUSH {r14}
+ LDR r14, =Osa_CoreRegisters
+ STM r14!, {r0-r12} /* ±£´ær0-r12 */
+ MOV r0, r14 /* ±£´ær14ÖÁr0£¬ºóÐøÒÔr0Ϊ»ùµØַѹջ */
+ LDR r14, [r13], #4 /* »¹Ôr13,r14 */
+ MRS r1, CPSR /* ±£´æcpsrÖÁr1 */
+ MSR CPSR_c, #0xdf /* SYS modeµÈ¼Ûusr mode */
+ STM r0!, {r13, r14} /* ½«{r13,r14}ÈëÕ» */
+ MRS r2, SPSR
+ STR r2, [r0], #4 /* ½«SPSRÈëÕ» */
+ MSR CPSR_c, #0xd3 /* svc mode */
+ STM r0!, {r13, r14} /* ½«{r13,r14} */
+ MRS r2, SPSR
+ STR r2, [r0], #4 /* ½«SPSRÈëÕ» */
+ MSR CPSR_c, #0xd7 /* ABT mode */
+ MRS r2, SPSR
+ STM r0!, {r13, r14}
+ STR r2, [r0], #4
+ MSR CPSR_c, #0xdb /* UND mode */
+ MRS r2, SPSR
+ STM r0!, {r13, r14}
+ STR r2, [r0], #4
+ MSR CPSR_c, #0xd2 /* IRQ mode */
+ MRS r2, SPSR
+ STM r0!, {r13, r14}
+ STR r2, [r0], #4
+ MSR CPSR_c, #0xd1 /* FIQ mode */
+ MRS r2, SPSR
+ STM r0!, {r8-r14}
+ STR r2, [r0], #4
+ MSR CPSR_c, r1 /* »¹ÔCPRS */
+ LDR r14, =Osa_CoreRegisters /* »¹Ô¼Ä´æÆ÷ */
+ LDM r14!, {r0-r12} /* »¹Ôr0-r12£¬r13µÄֵ֮ǰÒÑ»¹Ô */
+ LDMDB r13, {R14} /* »¹Ôr14 */
+ BX r14 /* ·µ»Ø */
+
+/**************************************************************************
+ º¯ÊýÃû³Æ£ºzOss_Cp15ReadControlRegister
+ ¹¦ÄÜÃèÊö£º
+ ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ (OUT):ÎÞ
+ ·µ »Ø Öµ£º ÎÞ
+ ÆäËü˵Ã÷£º
+ **************************************************************************/
+.type zOss_Cp15ReadControlRegister, %function
+zOss_Cp15ReadControlRegister:
+ MRC p15, 0, r0, c1, c0, 0
+ BX LR
+
+/**************************************************************************
+ º¯ÊýÃû³Æ£ºzOss_ReadCpsr
+ ¹¦ÄÜÃèÊö£º
+ ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ (OUT):ÎÞ
+ ·µ »Ø Öµ£º ÎÞ
+ ÆäËü˵Ã÷£º
+ **************************************************************************/
+.type zOss_ReadCpsr, %function
+zOss_ReadCpsr:
+ MRS r0, CPSR
+ BX LR
+
+/**************************************************************************
+ º¯ÊýÃû³Æ£ºcleanCache
+ ¹¦ÄÜÃèÊö£º
+ ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ (OUT):ÎÞ
+ ·µ »Ø Öµ£º ÎÞ
+ ÆäËü˵Ã÷£º
+ **************************************************************************/
+.type zOss_CleanCache, %function
+zOss_CleanCache:
+ mov r0, #0;
+ mcr p15, 0, r0, c7, c14, 0
+ mcr p15, 0, r0, c7, c5, 0
+ mcr p15, 0, r0, c7, c15, 0
+ mcr p15, 0, r0, c7, c10, 4
+ BX LR
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_except_arm_asm_rvct.S b/cp/ps/plat/src/oss/sup/src/sup_except_arm_asm_rvct.S
new file mode 100644
index 0000000..3cd70f0
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_except_arm_asm_rvct.S
@@ -0,0 +1,126 @@
+/**************************************************************************
+*
+* Copyright (c) 2013 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : tos_except_arm_asm_rvct.S
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : arm´¦ÀíÆ÷
+* ×÷ Õß : µËÄþˆÒ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2013/10/12
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+
+
+/**************************************************************************
+* È«¾Öº¯ÊýÉùÃ÷
+**************************************************************************/
+ EXPORT zOss_RamdumpSaveRegisters
+ EXPORT cp15_readControlRegister
+ EXPORT cp15_readDomainRegister
+ EXPORT cp15_readTTB
+
+/**************************************************************************
+* Íⲿ±äÁ¿ÉùÃ÷
+**************************************************************************/
+ IMPORT Osa_CoreRegisters
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+ º¯ÊýÃû³Æ£ºzOss_SaveRegisters
+ ¹¦ÄÜÃèÊö£º ±£´æÒì³£·¢ÉúʱËùÓеļĴæÖµÖÁ½á¹¹Ìå±äÁ¿(Osa_CoreRegisters),
+ ÔÚµ÷Óú¯Êý֮ǰÐè½ûÖ¹ËùÓÐÖжÏ
+ ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ (OUT):ÎÞ
+ ·µ »Ø Öµ£º ÎÞ
+ ÆäËü˵Ã÷£º
+ **************************************************************************/
+ AREA ||.text||, CODE, ALIGN = 2
+zOss_RamdumpSaveRegisters
+ PUSH {r14}
+ LDR r14,=Osa_CoreRegisters
+ STM r14!,{r0-r12} /* ±£´ær0-r12 */
+ MOV r0,r14 /* ±£´ær14ÖÁr0£¬ºóÐøÒÔr0Ϊ»ùµØַѹջ */
+ LDR r14,[r13],#4 /* »¹Ôr13,r14 */
+ MRS r1,CPSR /* ±£´æcpsrÖÁr1 */
+ MSR CPSR_c,#0xdf /*SYS modeµÈ¼Ûusr mode */
+ STM r0!,{r13,r14} /* ½«{r13,r14}ÈëÕ» */
+ MRS r2,SPSR
+ STR r2,[r0],#4 /* ½«SPSRÈëÕ» */
+ MSR CPSR_c,#0xd3 /*svc mode */
+ STM r0!,{r13,r14} /* ½«{r13,r14} */
+ MRS r2,SPSR
+ STR r2,[r0],#4 /* ½«SPSRÈëÕ» */
+ MSR CPSR_c,#0xd7 /* ABT mode */
+ MRS r2,SPSR
+ STM r0!,{r13,r14}
+ STR r2,[r0],#4
+ MSR CPSR_c,#0xdb /* UND mode */
+ MRS r2,SPSR
+ STM r0!,{r13,r14}
+ STR r2,[r0],#4
+ MSR CPSR_c,#0xd2 /* IRQ mode */
+ MRS r2,SPSR
+ STM r0!,{r13,r14}
+ STR r2,[r0],#4
+ MSR CPSR_c,#0xd1 /* FIQ mode */
+ MRS r2,SPSR
+ STM r0!,{r8-r14}
+ STR r2,[r0],#4
+ MSR CPSR_c,r1 /* »¹ÔCPRS */
+ LDR r14,=Osa_CoreRegisters /* »¹Ô¼Ä´æÆ÷ */
+ LDM r14!,{r0-r12} /* »¹Ôr0-r12£¬r13µÄֵ֮ǰÒÑ»¹Ô */
+ LDMDB r13,{R14} /* »¹Ôr14 */
+ BX r14 /* ·µ»Ø */
+
+/**************************************************************************
+ º¯ÊýÃû³Æ£ºcp15_readControlRegister
+ ¹¦ÄÜÃèÊö£º
+ ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ (OUT):ÎÞ
+ ·µ »Ø Öµ£º ÎÞ
+ ÆäËü˵Ã÷£º
+ **************************************************************************/
+cp15_readControlRegister
+ MRC p15, 0, r0, c1, c0, 0
+ BX LR
+
+/**************************************************************************
+ º¯ÊýÃû³Æ£ºcp15_readDomainRegister
+ ¹¦ÄÜÃèÊö£º
+ ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ (OUT):ÎÞ
+ ·µ »Ø Öµ£º ÎÞ
+ ÆäËü˵Ã÷£º
+ **************************************************************************/
+cp15_readDomainRegister
+ MRC p15, 0, r0, c3, c0, 0
+ BX LR
+
+/**************************************************************************
+ º¯ÊýÃû³Æ£ºcp15_readTTB
+ ¹¦ÄÜÃèÊö£º
+ ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ (OUT):ÎÞ
+ ·µ »Ø Öµ£º ÎÞ
+ ÆäËü˵Ã÷£º
+ **************************************************************************/
+cp15_readTTB
+ MRC p15, 0, r0, c2, c0, 0
+ BX LR
+
+ END
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_except_cortexm_asm.S b/cp/ps/plat/src/oss/sup/src/sup_except_cortexm_asm.S
new file mode 100644
index 0000000..d216c15
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_except_cortexm_asm.S
@@ -0,0 +1,112 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_except_cortex_asm.s
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : cortex´¦ÀíÆ÷
+* ×÷ Õß : ÁõÑÇÄÏ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2011/12/16
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+.syntax unified
+.thumb
+.text
+
+/**************************************************************************
+* È«¾Öº¯ÊýÉùÃ÷
+**************************************************************************/
+/**************************************************************************
+* Íⲿ±äÁ¿ÉùÃ÷
+**************************************************************************/
+.extern g_zRamdumpRegisters
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+ º¯ÊýÃû³Æ£ºzOss_SaveRegisters
+ ¹¦ÄÜÃèÊö£º ±£´æÒì³£·¢ÉúʱËùÓеļĴæÖµÖÁ½á¹¹Ìå±äÁ¿(Osa_CoreRegisters),
+ ÔÚµ÷Óú¯Êý֮ǰÐè½ûÖ¹ËùÓÐÖжÏ
+ ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ (OUT):ÎÞ
+ ·µ »Ø Öµ£º ÎÞ
+ ÆäËü˵Ã÷£º
+ **************************************************************************/
+.align 2
+.global zOss_RamdumpSaveRegisters
+.thumb
+.thumb_func
+.type zOss_RamdumpSaveRegisters, %function
+zOss_RamdumpSaveRegisters:
+ push {r1}
+ ldr r1, =g_zRamdumpRegisters
+ stm r1!, {r0}
+ mov r0, r1
+ ldr r1, [r13]
+ stm r0!, {r1-r6}
+ mov r1, r7
+ mov r2, r8
+ mov r3, r9
+ mov r4, r10
+ mov r5, r11
+ mov r6, r12
+ stm r0!,{r1-r6} /*r0 - r12*/
+
+ mov r1, r13
+ adds r1, r1, #0x4
+ mov r2, r14
+ mrs r3, psr
+ mrs r4, primask
+ mrs r5, control
+ stm r0!, {r1-r5} /* r13,r14,xPSR,primask,control */
+
+ ldr r0, =g_zRamdumpRegisters
+ adds r0, r0, #0x20
+ ldm r0!, {r1-r5}
+ mov r8, r1
+ mov r9, r2
+ mov r10, r3
+ mov r11, r4
+ mov r12, r5 /*r8 - r12*/
+
+ ldm r0!, {r1-r5}
+ mov r13, r1
+ mov r14, r2 /* r13,r14 */
+ msr apsr_nzcvq, r3
+ msr primask, r4
+ msr control, r5
+
+ ldr r0, =g_zRamdumpRegisters
+ adds r0, r0, #0x4
+ ldm r0!, {r1-r7} /* r1 - r7 */
+ ldr r0, =g_zRamdumpRegisters /* r0 */
+ ldr r0, [r0]
+ bx r14
+
+/**************************************************************************
+ º¯ÊýÃû³Æ£ºzOss_CleanCache
+ ¹¦ÄÜÃèÊö£ºÇåcacheÊý¾Ý
+ ²ÎÊý˵Ã÷£º(IN): ÎÞ
+ (OUT): ÎÞ
+ ·µ »Ø Öµ£ºÎÞ
+ ÆäËü˵Ã÷£º
+ **************************************************************************/
+.align 2
+.global zOss_CleanCache
+.thumb
+.thumb_func
+.type zOss_CleanCache, %function
+zOss_CleanCache:
+ bx r14
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_except_csky_asm.S b/cp/ps/plat/src/oss/sup/src/sup_except_csky_asm.S
new file mode 100644
index 0000000..fc24642
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_except_csky_asm.S
@@ -0,0 +1,211 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : tos_except_csky_asm.s
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ :
+* ×÷ Õß :
+* °æ ±¾ :
+* Íê³ÉÈÕÆÚ :
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include <pkgconf/hal.h>
+#include <pkgconf/system.h>
+#include <cyg/hal/board.h>
+#ifdef CYGPKG_KERNEL
+#include <pkgconf/kernel.h>
+#endif
+#include <pkgconf/hal_cskycpu.h>
+#include <cyg/hal/arch.inc>
+#include <pkgconf/kernel.h>
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Ö±äÁ¿ÉùÃ÷
+**************************************************************************/
+.globl zOss_RamdumpSaveRegisters
+//.globl zOss_LoadRegisters
+
+/**************************************************************************
+* Íⲿ±äÁ¿ÉùÃ÷
+**************************************************************************/
+.extern gRamdumpAdrress
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+ * ±£´æ¼Ä´æÆ÷ÐÅÏ¢
+ * º¯ÊýÔÐÍ VOID zOss_RamdumpSaveRegisters(VOID)
+ **************************************************************************/
+.text
+.balign 4
+zOss_RamdumpSaveRegisters:
+ subi r0, 4
+ stw r10, (r0, 0) //°Ñr15ѹջ£¬ÒÔ±ãºóÐøʹÓ㻽èÓÃr10£»
+ lrw r10, gRamdumpAdrress
+/* ±£´ær0-r15 */
+ stw r1, (r10, 4)
+ stw r2, (r10, 8)
+ stw r3, (r10, 12)
+ stw r4, (r10, 16)
+ stw r5, (r10, 20)
+ stw r6, (r10, 24)
+ stw r7, (r10, 28)
+ stw r8, (r10, 32)
+ stw r9, (r10, 36)
+ ldw r1, (r0, 0)
+ stw r1, (r10, 40)
+ addi r0, 4
+ stw r0, (r10, 0)
+ stw r11, (r10, 44)
+ stw r12, (r10, 48)
+ stw r13, (r10, 52)
+ stw r14, (r10, 56)
+ stw r15, (r10, 60)
+/* ±£´æ¿ØÖƼĴæÆ÷ */
+ addi r10, 32
+ addi r10, 32
+ mfcr r1, psr
+ stw r1, (r10, 0)
+ mfcr r1, VBR
+ stw r1, (r10, 4)
+ mfcr r1, epsr
+ stw r1, (r10, 8)
+ mfcr r1, fpsr
+ stw r1, (r10, 12)
+ mfcr r1, epc
+ stw r1, (r10, 16)
+ mfcr r1, fpc
+ stw r1, (r10, 20)
+ mfcr r1, ss0
+ stw r1, (r10, 24)
+ mfcr r1, ss1
+ stw r1, (r10, 28)
+ mfcr r1, ss2
+ stw r1, (r10, 32)
+ mfcr r1, ss3
+ stw r1, (r10, 36)
+ mfcr r1, ss4
+ stw r1, (r10, 40)
+ mfcr r1, gcr
+ stw r1, (r10, 44)
+ mfcr r1, gsr
+ stw r1, (r10, 48)
+ mfcr r1, cr13 //²úÆ·ÐòºÅ¼Ä´æÆ÷cr13
+ stw r1, (r10, 52)
+ mfcr r1, cr14 //dsp¿ØÖÆ״̬¼Ä´æÆ÷£»
+ stw r1, (r10, 56)
+ mfcr r1, cr15 //½ö´æÔÚÓÚ´øд¦ÀíÆ÷½Ó¿ÚµÄck_core´¦ÀíÆ÷ÖÐ(Èçck610M¡¢ck610sµÈ)
+ stw r1, (r10, 60)
+ addi r10, 32
+ addi r10, 32
+ mfcr r1, cr17 //¸ßËÙ»º´æ¼Ä´æÆ÷£»
+ stw r1, (r10, 0)
+ mfcr r1, cr18 //¸ßËÙ»º´æÅäÖüĴæÆ÷£»
+ stw r1, (r10, 4)
+ mfcr r1, cr19 //¿É¸ßËٺͷÃÎÊȨÏÞÅäÖüĴæÆ÷£»
+ stw r1, (r10, 8)
+ mfcr r1, cr20 //±£»¤Çø¿ØÖƼĴæÆ÷£»
+ stw r1, (r10, 12)
+ mfcr r1, cr21 //±£»¤Çø Ñ¡Ôñ¼Ä´æÆ÷£»
+ stw r1, (r10, 16)
+ jmp r15
+
+#if 0
+/**************************************************************************
+ * ±£´æ¼Ä´æÆ÷ÐÅÏ¢
+ * º¯ÊýÔÐÍ VOID zOss_LoadRegisters(VOID)
+ *¸Ãº¯ÊýµÄʹÓÃÐèҪעÒâzOss_SaveRegistersº¯Êý
+ **************************************************************************/
+.text
+.balign 4
+zOss_LoadRegisters:
+ lrw r10, gRamdumpAdrress
+ addi r10, 32
+ addi r10, 32
+//¼ÓÔØ¿ØÖƼĴæÆ÷
+ ldw r1, (r10, 0)
+ mtcr r1, psr
+ ldw r1, (r10, 4)
+ mtcr r1, VBR
+ ldw r1, (r10, 8)
+ mtcr r1, epsr
+ ldw r1, (r10, 12)
+ mtcr r1, fpsr
+ ldw r1, (r10, 16)
+ mtcr r1, epc
+ ldw r1, (r10, 20)
+ mtcr r1, fpc
+ ldw r1, (r10, 24)
+ mtcr r1, ss0
+ ldw r1, (r10, 28)
+ mtcr r1, ss1
+ ldw r1, (r10, 32)
+ mtcr r1, ss2
+ ldw r1, (r10, 36)
+ mtcr r1, ss3
+ ldw r1, (r10, 40)
+ mtcr r1, ss4
+ ldw r1, (r10, 44)
+ mtcr r1, gcr
+ ldw r1, (r10, 48)
+ mtcr r1, gsr
+ ldw r1, (r10, 52)
+ mtcr r1, cr13
+ ldw r1, (r10, 56)
+ mtcr r1, cr14
+ ldw r1, (r10, 60)
+ mtcr r1, cr15
+ addi r10, 32
+ addi r10, 32
+ ldw r1, (r10, 0)
+ mtcr r1, cr17
+ ldw r1, (r10, 4)
+ mtcr r1, cr18
+ ldw r1, (r10, 8)
+ mtcr r1, cr19
+ ldw r1, (r10, 12)
+ mtcr r1, cr20
+ ldw r1, (r10, 16)
+ mtcr r1, cr21
+
+ subi r10, 32
+ subi r10, 32
+ subi r10, 32
+ subi r10, 32
+//¼ÓÔØr0-r15
+ ldw r0, (r10, 0)
+ ldw r1, (r10, 4)
+ ldw r2, (r10, 8)
+ ldw r3, (r10, 12)
+ ldw r4, (r10, 16)
+ ldw r5, (r10, 20)
+ ldw r6, (r10, 24)
+ ldw r7, (r10, 28)
+ ldw r8, (r10, 32)
+ ldw r9, (r10, 36)
+ ldw r11, (r10, 44)
+ ldw r12, (r10, 48)
+ ldw r13, (r10, 52)
+ ldw r14, (r10, 56)
+ ldw r15, (r10, 60)
+ ldw r10, (r10, 40)
+ jmp r15
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_monitor.c b/cp/ps/plat/src/oss/sup/src/sup_monitor.c
new file mode 100644
index 0000000..c828c8c
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_monitor.c
@@ -0,0 +1,636 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : Ö§³Å²ã¼à¿ØÄ£¿é
+* ÎÄ ¼þ Ãû : oss_monitor.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : Ö§³Å²ãÊý¾ÝµÄÊÕ¼¯£¬Óë¸ú×Ù¹¤¾ß´úÀíÈÎÎñ½øÐн»»¥
+* ×÷ Õß : ÎâÕý¾ü
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2012/12/12
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ :
+* ÐÞ ¸Ä ÈË :
+* ÐÞ¸ÄÈÕÆÚ :
+* ÐÞ¸ÄÄÚÈÝ :
+**************************************************************************/
+
+#ifdef _USE_MONITOR
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+#include "osa.h"
+#include "sup_except.h"
+#include "oss_irq.h"
+#include "oss_trace.h"
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#if (defined _USE_ZX297550_HARDWARE)
+# define OSS_MON_VERSION_TYPE "7550"
+#elif (defined _USE_ZX297520_HARDWARE)
+# define OSS_MON_VERSION_TYPE "7520"
+#elif (defined _USE_ZX297510_HARDWARE)
+# define OSS_MON_VERSION_TYPE "7510"
+#elif (defined _USE_ZX297502_HARDWARE)
+# define OSS_MON_VERSION_TYPE "7502"
+#else
+# define OSS_MON_VERSION_TYPE "unkown"
+#endif
+
+#define OSS_MON_AGT_NAME "OsAgt"
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+typedef struct
+{
+ UINT32 msgId;
+ UINT32 (*func)(UINT8 *ptr);
+} oss_mon_func_t;
+
+typedef struct
+{
+ T_ZOss_Mon_Version monVersionInfo;
+ T_ZOss_Mon_Cpu_Frequency monCpuFrequency;
+ T_ZOss_Mon_Cpu_Load monCpuLoad;
+ T_ZOss_Mon_Pool monPoolInfo;
+ T_ZOss_Mon_Pool_Alloc monPoolAlloc;
+ T_ZOss_Mon_Pool_Leak monPoolLeak;
+ T_ZOss_Mon_Heap monHeapInfo;
+ T_ZOss_Mon_Thread monThreadInfo;
+ T_ZOss_Mon_Task monTaskInfo;
+ T_ZOss_Mon_Event monEventInfo;
+ T_ZOss_Mon_Msg monMsgInfo;
+ T_ZOss_Mon_Ramlog monRamlogInfo;
+ T_ZOss_Mon_Get_Var_Ack monGetVarInfo;
+ T_ZOss_Mon_Timer monTimerInfo;
+ T_ZOss_Mon_Mmu monMmuInfo;
+} oss_mon_ele_ptr_t;
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+static UINT32 monitor_MessageDisposeHandler(UINT32 msg_id, UINT8 *buf);
+static UINT32 monitor_VersionInfo(UINT8 *buf);
+static UINT32 monitor_CpuFrequencyInfo(UINT8 *buf);
+static UINT32 monitor_CpuLoadInfo(UINT8 *buf);
+static UINT32 monitor_PoolInfo(UINT8 *buf);
+static UINT32 monitor_PoolAllocInfo(UINT8 *buf);
+static UINT32 monitor_PoolLeakInfo(UINT8 *buf);
+static UINT32 monitor_HeapInfo(UINT8 *buf);
+static UINT32 monitor_ThreadInfo(UINT8 *buf);
+static UINT32 monitor_TaskInfo(UINT8 *buf);
+static UINT32 monitor_EventInfo(UINT8 *buf);
+static UINT32 monitor_MsgInfo(UINT8 *buf);
+static UINT32 monitor_RamlogInfo(UINT8 *buf);
+static UINT32 monitor_TimerInfo(UINT8 *buf);
+static UINT32 monitor_MmuInfo(UINT8 *buf);
+static UINT32 monitor_GetVarInfo(UINT8 *buf);
+static UINT32 monitor_SetVarInfo(UINT8 *buf);
+static UINT32 monitor_SetMonFlag(UINT8 *buf);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+UINT32 gOsa_MonitorFlag = FALSE;
+static ZOSS_TASK_ID gMon_OsAgtID = NULL;
+static oss_mon_ele_ptr_t oss_mon_ele_ptr = {0};
+static oss_mon_func_t oss_mon_id_to_func[] =
+{
+ {OSS_MON_VERSION, monitor_VersionInfo },
+ {OSS_MON_CPU_FREQUENCY, monitor_CpuFrequencyInfo},
+ {OSS_MON_CPU_LOAD, monitor_CpuLoadInfo },
+ {OSS_MON_POOL, monitor_PoolInfo },
+ {OSS_MON_POOL_ALLOC, monitor_PoolAllocInfo },
+ {OSS_MON_POOL_LEAK, monitor_PoolLeakInfo },
+ {OSS_MON_HEAP, monitor_HeapInfo },
+ {OSS_MON_THREAD, monitor_ThreadInfo },
+ {OSS_MON_TASK, monitor_TaskInfo },
+ {OSS_MON_EVENT, monitor_EventInfo },
+ {OSS_MON_MSG, monitor_MsgInfo },
+ {OSS_MON_RAMLOG, monitor_RamlogInfo },
+ {OSS_MON_GET_VAR_REQ, monitor_GetVarInfo },
+ {OSS_MON_SET_VAR, monitor_SetVarInfo },
+ {OSS_MON_TIMER, monitor_TimerInfo },
+ {OSS_MON_MMU, monitor_MmuInfo },
+};
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºMonitor_TaskEntry
+* ¹¦ÄÜÃèÊö£º³õʼ»¯¼à¿Ø¹ÜÀíÄ£¿éÈë¿Úº¯Êý
+* ²ÎÊý˵Ã÷£º(IN)
+* state: ÈÎÎñ״̬
+* msg_id: ÏûÏ¢ID
+* buf: ÏûÏ¢buf
+* msg_len: ÏûÏ¢³¤¶È
+* private: ˽ÓÐÊý¾Ý
+* (OUT)
+* ·µ »Ø Öµ£º
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID Monitor_TaskEntry(UINT8 state, UINT32 msg_id, UINT8 *buf, UINT16 msg_len, UINT8 *private_data)
+{
+ UINT32 status = ZOSS_ERROR;
+
+ switch(state)
+ {
+ case ZOSS_STATUS_INIT:
+ {
+ switch(msg_id)
+ {
+ case EV_INIT:
+ {
+ break;
+ }
+
+ case EV_POWERON:
+ {
+ gMon_OsAgtID = zOss_GetTaskID(OSS_MON_AGT_NAME);
+ #ifdef CYGOPT_HAL_ARM_MMU
+ zTos_GetMmuConfigTable(&oss_mon_ele_ptr.monMmuInfo);
+ #endif
+ status = zOss_SetState(ZOSS_STATUS_WORK);
+ if (status != ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_SHELL, PRINT_LEVEL_ABNORMAL, "OSS_MONITOR_POWERON:Fail to set state!");
+ }
+ break;
+ }
+
+ default:
+ {
+ zOss_Printf(SUBMDL_SHELL, PRINT_LEVEL_ABNORMAL, "OSS_MONITOR:Receive a invalid message!");
+ break;
+ }
+ }
+ break;
+ }
+
+ case ZOSS_STATUS_WORK:
+ {
+ switch(msg_id)
+ {
+ case OSS_MON_SET_FLAG:
+ {
+ status = monitor_SetMonFlag(buf);
+ if (status != ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_SHELL, PRINT_LEVEL_ABNORMAL, "OSS_MONITOR:Fail to set Monitor flag!");
+ }
+ break;
+ }
+
+ default:
+ {
+ status = monitor_MessageDisposeHandler(msg_id, buf);
+ if (status != ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_SHELL, PRINT_LEVEL_ABNORMAL, "OSS_MONITOR:Fail to dispose message!");
+ }
+ break;
+ }
+ }
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+}
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_MessageDisposeHandler
+* ¹¦ÄÜÃèÊö£º¼à¿Ø¹ÜÀíÄ£ÏûÏ¢´¦Àíº¯Êý
+* ²ÎÊý˵Ã÷£º(IN)
+* msg_id: ÏûÏ¢ID
+* buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_MessageDisposeHandler(UINT32 msg_id, UINT8 *buf)
+{
+ UINT32 cnt = 0;
+
+ if (!gOsa_MonitorFlag)
+ {
+ zOss_Printf(SUBMDL_SHELL, PRINT_LEVEL_ABNORMAL, "OSS_MONITOR: Monitor flag is off!");
+ return ZOSS_ERROR;
+ }
+
+ for (cnt = 0; cnt < ARRAY_SIZE(oss_mon_id_to_func); cnt++)
+ {
+ if (msg_id == oss_mon_id_to_func[cnt].msgId)
+ {
+ return (oss_mon_id_to_func[cnt].func(buf));
+ }
+ }
+
+ return ZOSS_ERROR;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_VersionInfo
+* ¹¦ÄÜÃèÊö£ºÌṩÏà¹ØµÄ°æ±¾ÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_VersionInfo(UINT8 *buf)
+{
+ oss_mon_ele_ptr.monVersionInfo.version = (char *)OSS_MON_VERSION_TYPE;
+
+ return zOss_TaskSendData(OSS_MON_VERSION,
+ &oss_mon_ele_ptr.monVersionInfo,
+ sizeof(T_ZOss_Mon_Version),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_CpuFrequencyInfo
+* ¹¦ÄÜÃèÊö£ºÌṩCPUÖ÷ƵÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_CpuFrequencyInfo(UINT8 *buf)
+{
+ oss_mon_ele_ptr.monCpuFrequency.frequency = 128;//zDrvSysClk_GetArmCoreFreq();
+
+ return zOss_TaskSendData(OSS_MON_CPU_FREQUENCY,
+ &oss_mon_ele_ptr.monCpuFrequency,
+ sizeof(T_ZOss_Mon_Cpu_Frequency),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_CpuLoadInfo
+* ¹¦ÄÜÃèÊö£ºÌṩCPU¸ºÔØÂÊ
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_CpuLoadInfo(UINT8 *buf)
+{
+ oss_mon_ele_ptr.monCpuLoad.load =
+ (unsigned short)( (OSS_MON_PERCENT_RADIO - Osa_GetProcessCPU(zOss_GetThreadIDByName(EXCEP_IDLETHREADNAME)))
+ * OSS_MON_PERCENT_RADIO);
+
+ return zOss_TaskSendData(OSS_MON_CPU_LOAD,
+ &oss_mon_ele_ptr.monCpuLoad,
+ sizeof(T_ZOss_Mon_Cpu_Load),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_PoolInfo
+* ¹¦ÄÜÃèÊö£ºÌṩÄÚ´æ³ØµÄʹÓÃÇé¿ö
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£ºÄÚ´æ³Øµ±Ç°µÄͳ¼ÆÐÅϢΪ¸÷sizeµÄʹÓøöÊý
+**************************************************************************/
+static UINT32 monitor_PoolInfo(UINT8 *buf)
+{
+ pool_used_info(&oss_mon_ele_ptr.monPoolInfo);
+
+#ifdef POOL_DEBUG
+ return zOss_TaskSendData(OSS_MON_POOL,
+ &oss_mon_ele_ptr.monPoolInfo,
+ sizeof(T_ZOss_Mon_Pool),
+ gMon_OsAgtID);
+#else
+ return ZOSS_SUCCESS;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_PoolAllocInfo
+* ¹¦ÄÜÃèÊö£ºÌṩÄÚ´æ³ØµÄÉêÇëʹÓÃÇé¿ö
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£ºÉêÇëµÄÄÚ´æÐèÒª¸ú×Ù¹¤¾ß´úÀíÈÎÎñ(ÏûÏ¢½ÓÊÕ·½)ÊÍ·Å
+**************************************************************************/
+static UINT32 monitor_PoolAllocInfo(UINT8 *buf)
+{
+ pool_alloc_info(&oss_mon_ele_ptr.monPoolAlloc);
+
+#ifdef POOL_DEBUG
+ return zOss_TaskSendData(OSS_MON_POOL_ALLOC,
+ &oss_mon_ele_ptr.monPoolAlloc,
+ sizeof(T_ZOss_Mon_Pool_Alloc),
+ gMon_OsAgtID);
+#else
+ return ZOSS_SUCCESS;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_PoolLeakInfo
+* ¹¦ÄÜÃèÊö£ºÌṩÄÚ´æ³ØµÄÉêÇëʹÓÃй¶Çé¿ö
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£ºÉêÇëµÄÄÚ´æÐèÒª¸ú×Ù¹¤¾ß´úÀíÈÎÎñ(ÏûÏ¢½ÓÊÕ·½)ÊÍ·Å
+**************************************************************************/
+static UINT32 monitor_PoolLeakInfo(UINT8 *buf)
+{
+ pool_leak_info(&oss_mon_ele_ptr.monPoolLeak);
+
+#ifdef POOL_DEBUG
+ return zOss_TaskSendData(OSS_MON_POOL_LEAK,
+ &oss_mon_ele_ptr.monPoolLeak,
+ sizeof(T_ZOss_Mon_Pool_Leak),
+ gMon_OsAgtID);
+#else
+ return ZOSS_SUCCESS;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_HeapInfo
+* ¹¦ÄÜÃèÊö£ºÌṩ¶ÑÄÚ´æµÄʹÓÃÇé¿ö
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_HeapInfo(UINT8 *buf)
+{
+ z0ss_GetHeapInfo(&oss_mon_ele_ptr.monHeapInfo);
+
+ return zOss_TaskSendData(OSS_MON_HEAP,
+ &oss_mon_ele_ptr.monHeapInfo,
+ sizeof(T_ZOss_Mon_Heap),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_ThreadInfo
+* ¹¦ÄÜÃèÊö£ºÌṩÏ̵߳ÄÏà¹Ø״̬ÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£ºÉêÇëµÄÄÚ´æÐèÒª¸ú×Ù¹¤¾ß´úÀíÈÎÎñ(ÏûÏ¢½ÓÊÕ·½)ÊÍ·Å
+**************************************************************************/
+static UINT32 monitor_ThreadInfo(UINT8 *buf)
+{
+ z0ss_GetAllThreadInfo(&oss_mon_ele_ptr.monThreadInfo);
+
+ return zOss_TaskSendData(OSS_MON_THREAD,
+ &oss_mon_ele_ptr.monThreadInfo,
+ sizeof(T_ZOss_Mon_Thread),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_TaskInfo
+* ¹¦ÄÜÃèÊö£ºÌṩÈÎÎñµÄÏà¹Ø״̬ÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£ºÉêÇëµÄÄÚ´æÐèÒª¸ú×Ù¹¤¾ß´úÀíÈÎÎñ(ÏûÏ¢½ÓÊÕ·½)ÊÍ·Å
+**************************************************************************/
+static UINT32 monitor_TaskInfo(UINT8 *buf)
+{
+ zOss_GetAllTaskInfo(&oss_mon_ele_ptr.monTaskInfo);
+
+ return zOss_TaskSendData(OSS_MON_TASK,
+ &oss_mon_ele_ptr.monTaskInfo,
+ sizeof(T_ZOss_Mon_Task),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_EventInfo
+* ¹¦ÄÜÃèÊö£ºÌṩϵͳµ÷¶ÈʼþÏà¹ØÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_EventInfo(UINT8 *buf)
+{
+ z0ss_GetEventInfo(&oss_mon_ele_ptr.monEventInfo);
+
+ return zOss_TaskSendData(OSS_MON_EVENT,
+ &oss_mon_ele_ptr.monEventInfo,
+ sizeof(T_ZOss_Mon_Event),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_MsgInfo
+* ¹¦ÄÜÃèÊö£ºÌṩÏûÏ¢µÄÊÕ·¢ÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_MsgInfo(UINT8 *buf)
+{
+ z0ss_GetMsgInfo(&oss_mon_ele_ptr.monMsgInfo);
+
+ return zOss_TaskSendData(OSS_MON_MSG,
+ &oss_mon_ele_ptr.monMsgInfo,
+ sizeof(T_ZOss_Mon_Msg),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_RamlogInfo
+* ¹¦ÄÜÃèÊö£ºÌṩRamlogÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_RamlogInfo(UINT8 *buf)
+{
+ z0ss_GetRamlogInfo(&oss_mon_ele_ptr.monRamlogInfo);
+
+ return zOss_TaskSendData(OSS_MON_RAMLOG,
+ &oss_mon_ele_ptr.monRamlogInfo,
+ sizeof(T_ZOss_Mon_Ramlog),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_PrivodeVarInfo
+* ¹¦ÄÜÃèÊö£ºÌṩָ¶¨±äÁ¿µÄÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£ºÉêÇëµÄÄÚ´æÐèÒª¸ú×Ù¹¤¾ß´úÀíÈÎÎñ(ÏûÏ¢½ÓÊÕ·½)ÊÍ·Å
+**************************************************************************/
+static UINT32 monitor_GetVarInfo(UINT8 *buf)
+{
+ T_ZOss_Mon_Get_Var_Req *varInfo = NULL;
+
+ if (buf == NULL)
+ {
+ return ZOSS_ERROR;
+ }
+
+ varInfo = (T_ZOss_Mon_Get_Var_Req *)buf;
+ if (varInfo->base == 0 || varInfo->size == 0)
+ {
+ return ZOSS_ERROR;
+ }
+
+ oss_mon_ele_ptr.monGetVarInfo.size = varInfo->size;
+ oss_mon_ele_ptr.monGetVarInfo.value = (unsigned char *)zOss_GetUB(oss_mon_ele_ptr.monGetVarInfo.size);
+ zOss_AssertEx(oss_mon_ele_ptr.monGetVarInfo.value != NULL, ZOSS_ERROR);
+
+ zOss_Memcpy((VOID *)oss_mon_ele_ptr.monGetVarInfo.value, (const VOID *)varInfo->base, varInfo->size);
+ zOss_RetUB((VOID *)varInfo);
+ varInfo = NULL;
+ return zOss_TaskSendData(OSS_MON_GET_VAR_ACK,
+ &oss_mon_ele_ptr.monGetVarInfo,
+ sizeof(T_ZOss_Mon_Get_Var_Ack),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_SetVarInfo
+* ¹¦ÄÜÃèÊö£ºÐÞ¸ÄÖ¸¶¨ÄÚ´æ¶ÎµÄÖµ
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_SetVarInfo(UINT8 *buf)
+{
+ T_ZOss_Mon_Set_Var *varInfo = NULL;
+ ZOSS_INTR old_intr = 0;
+
+ if (buf == NULL)
+ {
+ return ZOSS_ERROR;
+ }
+ varInfo = (T_ZOss_Mon_Set_Var *)buf;
+ if (varInfo->base == 0 || varInfo->size == 0)
+ {
+ return ZOSS_ERROR;
+ }
+
+ ZOSS_SAVE_IRQ(old_intr);
+ zOss_Memcpy((VOID *)varInfo->base, (const VOID *)varInfo->value, varInfo->size);
+ ZOSS_RESTORE_IRQ(old_intr);
+
+ zOss_RetUB((VOID *)varInfo->value);
+ zOss_RetUB((VOID *)varInfo);
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_TimerInfo
+* ¹¦ÄÜÃèÊö£ºÌṩTimerµÄʹÓÃÇé¿ö
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£ºÉêÇëµÄÄÚ´æÐèÒª¸ú×Ù¹¤¾ß´úÀíÈÎÎñ(ÏûÏ¢½ÓÊÕ·½)ÊÍ·Å
+**************************************************************************/
+static UINT32 monitor_TimerInfo(UINT8 *buf)
+{
+ zOss_GetTimerInfo(&oss_mon_ele_ptr.monTimerInfo);
+
+ return zOss_TaskSendData(OSS_MON_TIMER,
+ &oss_mon_ele_ptr.monTimerInfo,
+ sizeof(T_ZOss_Mon_Timer),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_MmuInfo
+* ¹¦ÄÜÃèÊö£ºÌṩMMUÄÚ´æÅäÖÃÓ³Éä±íÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_MmuInfo(UINT8 *buf)
+{
+ return zOss_TaskSendData(OSS_MON_MMU,
+ &oss_mon_ele_ptr.monMmuInfo,
+ sizeof(T_ZOss_Mon_Mmu),
+ gMon_OsAgtID);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºmonitor_MonFlagInfo
+* ¹¦ÄÜÃèÊö£ºÐ޸ļà¿ØÄ£¿é±ê־λ
+* ²ÎÊý˵Ã÷£º(IN) buf: ÏûÏ¢buf
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS£»Ê§°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 monitor_SetMonFlag(UINT8 *buf)
+{
+ T_ZOss_Mon_Set_Flag *flagInfo = NULL;
+
+ if (buf)
+ {
+ flagInfo = (T_ZOss_Mon_Set_Flag *)buf;
+ if (flagInfo->flag)
+ {
+#ifdef OSS_TRACE_THREAD
+ oss_trace_thread_open();
+#endif
+
+#ifdef TOS_STATISTIC_IRQ
+ tos_statistic_irq_open();
+#endif
+
+#ifdef TOS_TRACE_IRQ
+ tos_trace_irq_open();
+#endif
+ }
+ else
+ {
+#ifdef TOS_TRACE_IRQ
+ tos_trace_irq_close();
+#endif
+
+#ifdef TOS_STATISTIC_IRQ
+ tos_statistic_irq_close();
+#endif
+
+#ifdef OSS_TRACE_THREAD
+ oss_trace_thread_close();
+#endif
+ }
+ gOsa_MonitorFlag = flagInfo->flag;
+ zOss_RetUB((VOID *)flagInfo);
+ return ZOSS_SUCCESS;
+ }
+ return ZOSS_ERROR;
+}
+
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_nvm.c b/cp/ps/plat/src/oss/sup/src/sup_nvm.c
new file mode 100755
index 0000000..d5f927d
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_nvm.c
@@ -0,0 +1,1041 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98_NVM
+* ÎÄ ¼þ Ãû : nvm.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : nvÊý¾Ý¹ÜÀí½Ó¿Ú
+* ×÷ Õß : ¬л¼ª
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2009-08-06
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : wuzhengjun
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001781798
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0002
+* ÐÞ ¸Ä ÈË : wuzhengjun
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-27
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é EC:617001781846
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0003
+* ÐÞ ¸Ä ÈË : wangqing
+* ÐÞ¸ÄÈÕÆÚ : 2018-08-27
+* ÐÞ¸ÄÄÚÈÝ : ¸ÄΪÎļþϵͳʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_nvm.h"
+#include "drv_api.h"
+#include "oss_cfg.h"
+#include "RWNvConfig.h"
+#ifdef _OS_LINUX
+#include <linux/unistd.h>
+#include <linux/ctype.h>
+#include <linux/syscalls.h>
+#include <linux/statfs.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef USE_CPPS_KO
+#define CPPS_KO_FUNC(func) kernel_##func
+#else
+#define CPPS_KO_FUNC(func) func
+#endif
+
+/**************************************************************************
+* Íⲿº¯ÊýºÍ±äÁ¿ÉùÃ÷Çø
+**************************************************************************/
+extern void msleep(unsigned int msecs);
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#define NV_SYMBOL_DOWN 0xA2 /* unused */
+#define NV_SYMBOL_NORMAL 0xB3 /* Õý³£Çé¿öϱê־λµÄÖµ */
+#define NV_SYMBOL_WRITE 0xC4 /* дNVÇé¿öϱê־λµÄÖµ */
+#define NV_SYMBOL_FACTORY 0xD5 /* ³ö³§»Ö¸´±ê־λµÄÖµ */
+
+#define NV_WORK_AREA 0x01 /* ¹¤×÷Çø±êʶ */
+#define NV_BACKUP_AREA 0x02 /* ±¸·ÝÇø±êʶ */
+
+#define NVM_FS_RO_FAC_PATH "/mnt/nvrofs/nvroall.bin"
+#define NVM_FS_ROW_FAC_PATH "/mnt/nvrofs/nvrowall.bin"
+#define NVM_FS_ROW_C0_FAC_PATH "/mnt/nvrofs/nvroc0wall.bin"
+#define NVM_FS_RWO_FAC_PATH "/mnt/imagefs/nvrwoall.bin"
+#define NVM_FS_RW_FAC_PATH "/mnt/imagefs/nvrwall.bin"
+#define NVM_FS_RW_HASH_FAC_PATH "/mnt/imagefs/nvrwall.hash"
+
+#define NVM_FS_RW_DIR "/etc_rw/psnv"
+#define NVM_FS_RW_MAIN_PATH "/etc_rw/psnv/rw_work"
+#define NVM_FS_RW_BACKUP_PATH "/etc_rw/psnv/rw_backup"
+
+#define NVM_FS_FAC_SYMBOL_PATH "/etc_rw/psnv/fac_flag"
+#define NVM_FS_RW_MAIN_SYMBOL_PATH "/etc_rw/psnv/work_flag"
+#define NVM_FS_RW_BACKUP_SYMBOL_PATH "/etc_rw/psnv/backup_flag"
+#define NVM_FS_RW_HASH_WORK_PATH "/etc_rw/psnv/nvrwall.hash"
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+static BOOL Nvram_Check_Data(VOID);
+static UINT32 Nvram_WriteWithFlag(UINT32 NvItemID, UINT8 *NvItemData, UINT32 NvItemLen, UINT8 iNvm);
+static UINT32 Nvram_WriteRO(const CHAR *part_name, UINT32 NvItemID, UINT8 *NvItemData, UINT32 NvItemLen);
+static UINT32 Nvram_FsRead(const CHAR *part_name, UINT32 dwStart, UINT32 dwLen, UINT8 *to);
+static UINT32 Nvram_FsWrite(const CHAR *part_name, UINT32 dwStart, UINT32 dwLen, UINT8 *from);
+static UINT32 Nvram_Remount(CHAR *DevName, CHAR *DirName, CHAR *Type, UINT32 Flag);
+static UINT32 Nvram_CopyFile(const CHAR *pDstFile, const CHAR *pSrcFile);
+static UINT32 Nvram_CmpFile(const CHAR *pDstFile, const CHAR *pSrcFile);
+static UINT32 Nvram_DirInit(VOID);
+static UINT32 Nvram_RoInit(VOID);
+static UINT32 Nvram_RwInit(VOID);
+static SINT32 Nvram_WriteFile(const CHAR *pFile, UINT8 *pBuf, UINT32 len);
+static UINT8 *Nvram_ReadFile(const CHAR *pFile, UINT32 *len);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+static ZOSS_MUTEX_ID gNV_Mutex = NULL; /* Flash²Ù×÷»¥³âÌå */
+static BOOL gNV_Inited = FALSE; /* NV¶ÁдʹÄÜ */
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* º¯ÊýÃû³Æ£º NV_Init
+* ¹¦ÄÜÃèÊö£º NV³õʼ»¯
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 NV_Init(VOID)
+{
+ T_OSS_PARAM *pOssParam = NULL;
+
+ if (gNV_Inited)
+ return ZOSS_SUCCESS;
+
+ /* ´´½¨NV»¥³âÁ¿ */
+ gNV_Mutex = zOss_CreateMutex("NV_Mutex", ZOSS_INHERIT);
+ if (gNV_Mutex == NULL)
+ return ZOSS_ERROR;
+
+ /* ²é¿´¹¤×÷ÇøºÍ±¸·ÝÇøÊý¾ÝÊÇ·ñÓÐЧ£¬ÈçÎÞЧÔò»Ö¸´ */
+ Nvram_Check_Data();
+
+ gNV_Inited = TRUE;
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_NvItemRead
+* ¹¦ÄÜÃèÊö£º ¶ÁÒ»ÏîNVÊý¾Ý
+* ²ÎÊý˵Ã÷£º (IN)
+* NvItemID: ¸ÃNVÏîµÄÆ«ÒƵØÖ·(Ïà¶ÔÓÚNVÆðʼµØÖ·µÄÆ«ÒÆ)
+* NvItemData: ¶Á³öµÄÊý¾Ý
+* NvItemLen: Êý¾Ý³¤¶È
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_NvItemRead(UINT32 NvItemID, UINT8 *NvItemData, UINT32 NvItemLen)
+{
+ SINT32 status = -1;
+ SINT8 *pNvFile = NULL;
+
+ if (gNV_Inited == FALSE || NvItemLen == 0 || NvItemData == NULL)
+ return ZOSS_ERROR;
+
+ if(NvItemID >= OS_FLASH_RO_OFFSET_FROM_NV && (NvItemID + NvItemLen) <= (OS_FLASH_RO_OFFSET_FROM_NV + OS_FLASH_RO_NVRAM_SIZE))
+ {
+ pNvFile = NVM_FS_RO_FAC_PATH;
+ NvItemID -= OS_FLASH_RO_OFFSET_FROM_NV;
+ }
+ else if(NvItemID >= OS_FLASH_LOCKNET_ROW_OFFSET_FROM_NV && (NvItemID + NvItemLen) <= (OS_FLASH_LOCKNET_ROW_OFFSET_FROM_NV + OS_FLASH_LOCKNET_ROW_SIZE))
+ {
+ pNvFile = NVM_FS_ROW_FAC_PATH;
+ NvItemID -= OS_FLASH_LOCKNET_ROW_OFFSET_FROM_NV;
+ }
+ else if(NvItemID >= OS_FLASH_C0CALIINFO_ROW_OFFSET_FROM_NV && (NvItemID + NvItemLen) <= (OS_FLASH_C0CALIINFO_ROW_OFFSET_FROM_NV + OS_FLASH_C0CALIINFO_ROW_SIZE))
+ {
+ pNvFile = NVM_FS_ROW_C0_FAC_PATH;
+ NvItemID -= OS_FLASH_C0CALIINFO_ROW_OFFSET_FROM_NV;
+ }
+ else if(NvItemID >= OS_FLASH_RWO_OFFSET_FROM_NV && (NvItemID + NvItemLen) <= (OS_FLASH_RWO_OFFSET_FROM_NV + OS_FLASH_RWO_NVRAM_SIZE))
+ {
+ pNvFile = NVM_FS_RWO_FAC_PATH;
+ NvItemID -= OS_FLASH_RWO_OFFSET_FROM_NV;
+ }
+ else if(NvItemID >= OS_FLASH_RW_OFFSET_FROM_NV && (NvItemID + NvItemLen) <= (OS_FLASH_RW_OFFSET_FROM_NV + OS_FLASH_RW_NVRAM_SIZE))
+ {
+ pNvFile = NVM_FS_RW_MAIN_PATH;
+ NvItemID -= OS_FLASH_RW_OFFSET_FROM_NV;
+ }
+ else
+ return ZOSS_ERROR;
+
+ /* »ñÈ¡NV²Ù×÷»¥³âÁ¿ */
+ zOss_GetMutex(gNV_Mutex, ZOSS_WAIT_FOREVER);
+ status = Nvram_FsRead(pNvFile, NvItemID, NvItemLen, NvItemData);
+ zOss_PutMutex(gNV_Mutex);
+
+ return status;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_NvItemWrite
+* ¹¦ÄÜÃèÊö£º дһÏîNVÊý¾Ý
+* ²ÎÊý˵Ã÷£º (IN)
+* NvItemID: ¸ÃNVÏîµÄÆ«ÒƵØÖ·(Ïà¶ÔÓÚNVÆðʼµØÖ·µÄÆ«ÒÆ)
+* NvItemData: дÈëµÄÊý¾Ý
+* NvItemLen: Êý¾Ý³¤¶È
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_NvItemWrite(UINT32 NvItemID, UINT8 *NvItemData, UINT32 NvItemLen)
+{
+ UINT32 status = ZOSS_ERROR;
+
+ if (gNV_Inited == FALSE || NvItemLen == 0 || NvItemData == NULL)
+ return ZOSS_ERROR;
+
+ zOss_GetMutex(gNV_Mutex, ZOSS_WAIT_FOREVER);
+
+ if(NvItemID >= OS_FLASH_RW_OFFSET_FROM_NV && (NvItemID + NvItemLen) <= (OS_FLASH_RW_OFFSET_FROM_NV + OS_FLASH_RW_NVRAM_SIZE))
+ {//rw
+ NvItemID -= OS_FLASH_RW_OFFSET_FROM_NV;
+ status = Nvram_WriteWithFlag(NvItemID, NvItemData, NvItemLen, NV_WORK_AREA);/* ½«Êý¾ÝдÈ빤×÷Çø */
+ if (status == ZOSS_SUCCESS)
+ status = Nvram_WriteWithFlag(NvItemID, NvItemData, NvItemLen, NV_BACKUP_AREA);/* ½«Êý¾ÝдÈ뱸·ÝÇø */
+ }
+ else if(NvItemID >= OS_FLASH_RO_OFFSET_FROM_NV && (NvItemID + NvItemLen) <= (OS_FLASH_RO_OFFSET_FROM_NV + OS_FLASH_RO_NVRAM_SIZE))
+ {// ro
+ NvItemID -= OS_FLASH_RO_OFFSET_FROM_NV;
+ status = Nvram_FsWrite(NVM_FS_RO_FAC_PATH, NvItemID, NvItemLen, NvItemData);
+ }
+ else if(NvItemID >= OS_FLASH_LOCKNET_ROW_OFFSET_FROM_NV && (NvItemID + NvItemLen) <= (OS_FLASH_LOCKNET_ROW_OFFSET_FROM_NV + OS_FLASH_LOCKNET_ROW_SIZE))
+ {// row_locknet
+ NvItemID -= OS_FLASH_LOCKNET_ROW_OFFSET_FROM_NV;
+ status = Nvram_FsWrite(NVM_FS_ROW_FAC_PATH, NvItemID, NvItemLen, NvItemData);
+ }
+ else if(NvItemID >= OS_FLASH_C0CALIINFO_ROW_OFFSET_FROM_NV && (NvItemID + NvItemLen) <= (OS_FLASH_C0CALIINFO_ROW_OFFSET_FROM_NV + OS_FLASH_C0CALIINFO_ROW_SIZE))
+ {// ro_c0cail
+ NvItemID -= OS_FLASH_C0CALIINFO_ROW_OFFSET_FROM_NV;
+ status = Nvram_FsWrite(NVM_FS_ROW_C0_FAC_PATH, NvItemID, NvItemLen, NvItemData);
+ }
+
+ zOss_PutMutex(gNV_Mutex);
+
+ return status;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_ResetNVFactory
+* ¹¦ÄÜÃèÊö£º »Ö¸´³ö³§ÉèÖÃ(ÖØÆôºóÉúЧ)
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_ResetNVFactory(VOID)
+{
+ UINT8 Symbol = NV_SYMBOL_FACTORY;
+ UINT32 status = ZOSS_ERROR;
+
+ status = Nvram_FsWrite(NVM_FS_FAC_SYMBOL_PATH, 0, 1, &Symbol);
+
+ return (status == 0) ? ZOSS_SUCCESS : ZOSS_ERROR;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_NvInResume
+* ¹¦ÄÜÃèÊö£º ÊÇ·ñ´¦ÓÚNV»Ö¸´Á÷³ÌÖÐ
+* ²ÎÊý˵Ã÷£º ÎÞ
+* ·µ »Ø Öµ£º TRUE:´¦ÓÚ»Ö¸´Á÷³Ì£»FLASE:²»´¦ÓÚ»Ö¸´Á÷³Ì
+* ÆäËü˵Ã÷£º Çý¶¯Ê¹ÓÃ
+**************************************************************************/
+BOOL zOss_NvInResume(VOID)
+{
+ return 0;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_NvramFlush
+* ¹¦ÄÜÃèÊö£º ½«»º´æÊý¾Ýдµ½NVÖÐ
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_NvramFlush(VOID)
+{
+ return Nvram_Flush();
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_NvCheck
+* ¹¦ÄÜÃèÊö£º ¼ì²âNV±êÖ¾£¬²¢½øÐлָ´
+* ²ÎÊý˵Ã÷£º ÎÞ
+* ·µ »Ø Öµ£º ÎÞ
+* ÆäËü˵Ã÷£º Çý¶¯Ê¹ÓÃ
+**************************************************************************/
+VOID zOss_NvCheck(VOID)
+{
+ return;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_NvItemWriteFactory
+* ¹¦ÄÜÃèÊö£º дһÏîNV ³ö³¡ÇøÊý¾Ý
+* ²ÎÊý˵Ã÷£º (IN)
+* NvItemID: ¸ÃNVÏîµÄÆ«ÒƵØÖ·(Ïà¶ÔÓÚNVÆðʼµØÖ·µÄÆ«ÒÆ)
+* NvItemData: дÈëµÄÊý¾Ý
+* NvItemLen: Êý¾Ý³¤¶È
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º ×èÈûº¯Êý£¬²»ÔÊÐíÖжϼäÖ´ÐÐ
+**************************************************************************/
+UINT32 zOss_NvItemWriteFactory(UINT32 NvItemID, UINT8 *NvItemData, UINT32 NvItemLen)
+{
+ UINT32 status = ZOSS_ERROR;
+ mm_segment_t old_fs = get_fs();
+
+ if (gNV_Inited == FALSE || NvItemLen == 0 || NvItemData == NULL)
+ return ZOSS_ERROR;
+
+ if(NvItemID >= OS_FLASH_RW_OFFSET_FROM_NV && (NvItemID + NvItemLen) <= (OS_FLASH_RW_OFFSET_FROM_NV + OS_FLASH_RW_NVRAM_SIZE))
+ NvItemID -= OS_FLASH_RW_OFFSET_FROM_NV;
+ else
+ return ZOSS_ERROR;
+
+ zOss_GetMutex(gNV_Mutex, ZOSS_WAIT_FOREVER);
+
+ //status = Nvram_Remount("mtd:imagefs", "/mnt/imagefs", "jffs2", MS_REMOUNT |MS_VERBOSE);
+ //if(ZOSS_SUCCESS != status)
+ //{
+ // zOss_PutMutex(gNV_Mutex);
+ // return ZOSS_ERROR;
+ //}
+
+ status = Nvram_FsWrite(NVM_FS_RW_FAC_PATH, NvItemID, NvItemLen, NvItemData);
+ //status |= Nvram_Remount("mtd:imagefs", "/mnt/imagefs", "jffs2", MS_REMOUNT |MS_VERBOSE | MS_RDONLY);
+
+ zOss_PutMutex(gNV_Mutex);
+ return status;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_NvGetEccLogInfo
+* ¹¦ÄÜÃèÊö£º »ñÈ¡ECC LogÐÅÏ¢
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_NvGetEccLogInfo(T_ZOss_NvEccLog *logInfo)
+{
+ return ZOSS_ERROR;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_ChangeNvroAttr
+* ¹¦ÄÜÃèÊö£º ¸Ä±äNVRO·ÖÇøµÄÊôÐÔ
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_ChangeNvroAttr(int writable)
+{
+ if (cpnv_ChangeNvroAttr(writable) < 0)
+ return ZOSS_ERROR;
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_Finish
+* ¹¦ÄÜÃèÊö£º ½áÊøNV²Ù×÷£¬½«Êý¾Ýдµ½NVÖÐ
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 Nvram_Finish(VOID)
+{
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_Flush
+* ¹¦ÄÜÃèÊö£º ½«»º´æÊý¾Ýдµ½NVÖÐ
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 Nvram_Flush(VOID)
+{
+ return ZOSS_SUCCESS;
+}
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_DirInit
+* ¹¦ÄÜÃèÊö£º ³õʼ»¯nvmĿ¼
+* ²ÎÊý˵Ã÷£º (IN)
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 Nvram_DirInit(VOID)
+{
+ if(CPPS_KO_FUNC(sys_access)(NVM_FS_RW_DIR, 0) != 0)
+ {
+ if(CPPS_KO_FUNC(sys_mkdir)(NVM_FS_RW_DIR, 0755) != 0)
+ {
+ printk("cpnv mkdir %s fali\n", NVM_FS_RW_DIR);
+ return ZOSS_ERROR;
+ }
+ }
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_RoInit
+* ¹¦ÄÜÃèÊö£º ³õʼ»¯Ro nv
+* ²ÎÊý˵Ã÷£º (IN)
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 Nvram_RoInit(VOID)
+{
+ UINT8 *pNvdata;
+ UINT32 status = ZOSS_ERROR;
+
+ if(CPPS_KO_FUNC(sys_open)(NVM_FS_RO_FAC_PATH, O_RDONLY, 0) == -ENOENT)
+ {
+ pNvdata = zOss_GetUB(OS_FLASH_RO_NVRAM_SIZE);
+ if (pNvdata == NULL)
+ {
+ printk("cpnv malloc rodata fail\n");
+ return ZOSS_ERROR;
+ }
+
+ memset(pNvdata, 0xff, OS_FLASH_RO_NVRAM_SIZE);
+
+ status = Nvram_WriteRO(NVM_FS_RO_FAC_PATH, 0, pNvdata, OS_FLASH_RO_NVRAM_SIZE);
+ zOss_RetUB(pNvdata);
+ if(status != ZOSS_SUCCESS)
+ return ZOSS_ERROR;
+ else
+ printk("cpnv clean ro fs success!\n");
+ }
+
+ if(CPPS_KO_FUNC(sys_open)(NVM_FS_ROW_FAC_PATH, O_RDONLY, 0) == -ENOENT)
+ {
+ pNvdata = zOss_Malloc(OS_FLASH_LOCKNET_ROW_SIZE);
+ if (pNvdata == NULL)
+ {
+ printk("cpnv malloc rowdata fail\n");
+ return ZOSS_ERROR;
+ }
+
+ memset(pNvdata, 0xff, OS_FLASH_LOCKNET_ROW_SIZE);
+ status = Nvram_WriteRO(NVM_FS_ROW_FAC_PATH, 0, pNvdata, OS_FLASH_LOCKNET_ROW_SIZE);
+ zOss_Free(pNvdata);
+ if(status != ZOSS_SUCCESS)
+ return ZOSS_ERROR;
+ else
+ printk("cpnv clean row_locknet fs success!\n");
+ }
+
+ if(CPPS_KO_FUNC(sys_open)(NVM_FS_ROW_C0_FAC_PATH, O_RDONLY, 0) == -ENOENT)
+ {
+ pNvdata = zOss_Malloc(OS_FLASH_C0CALIINFO_ROW_SIZE);
+ if (pNvdata == NULL)
+ {
+ printk("cpnv malloc rowdata fail\n");
+ return ZOSS_ERROR;
+ }
+
+ memset(pNvdata, 0xff, OS_FLASH_C0CALIINFO_ROW_SIZE);
+ status = Nvram_WriteRO(NVM_FS_ROW_C0_FAC_PATH, 0, pNvdata, OS_FLASH_C0CALIINFO_ROW_SIZE);
+ zOss_Free(pNvdata);
+ if(status != ZOSS_SUCCESS)
+ return ZOSS_ERROR;
+ else
+ printk("cpnv clean row_cocail fs success!\n");
+ }
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_RwInit
+* ¹¦ÄÜÃèÊö£º ³õʼ»¯Ro nv
+* ²ÎÊý˵Ã÷£º (IN)
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 Nvram_RwInit(VOID)
+{
+ UINT8 WorkArea_Symbol = 0;
+ UINT8 BackUp_Symbol = 0;
+ UINT8 Factory_Symbol = 0;
+ SINT32 WorkArea_Status = -1;
+ SINT32 BackUp_Status = -1;
+ UINT32 status = ZOSS_ERROR;
+
+factory_check:
+
+ /* °æ±¾ÏÂÔØ */ /* »Ö¸´³ö³§ */ /* FotaÉý¼¶ */
+ status = Nvram_FsRead(NVM_FS_FAC_SYMBOL_PATH, 0, 1, &Factory_Symbol);
+ if(status || Factory_Symbol == NV_SYMBOL_FACTORY || Nvram_CmpFile(NVM_FS_RW_HASH_FAC_PATH, NVM_FS_RW_HASH_WORK_PATH))
+ {
+ status = Nvram_CopyFile(NVM_FS_RW_MAIN_PATH, NVM_FS_RW_FAC_PATH);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+ status = Nvram_CopyFile(NVM_FS_RW_BACKUP_PATH, NVM_FS_RW_FAC_PATH);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+ status = Nvram_CopyFile(NVM_FS_RW_HASH_WORK_PATH, NVM_FS_RW_HASH_FAC_PATH);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ WorkArea_Symbol = NV_SYMBOL_NORMAL;
+ status = Nvram_FsWrite(NVM_FS_RW_MAIN_SYMBOL_PATH, 0, 1, &WorkArea_Symbol);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+ BackUp_Symbol = NV_SYMBOL_NORMAL;
+ status = Nvram_FsWrite(NVM_FS_RW_BACKUP_SYMBOL_PATH, 0, 1, &BackUp_Symbol);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ Factory_Symbol = NV_SYMBOL_NORMAL;
+ status = Nvram_FsWrite(NVM_FS_FAC_SYMBOL_PATH, 0, 1, &Factory_Symbol);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ printk("cpnv version download or restore fac or fota update!\n");
+ return ZOSS_SUCCESS;
+ }
+
+ /* ¶ÁÈ¡¹¤×÷ÇøºÍ±¸·ÝÇøÖеıê־λ */
+ WorkArea_Status = Nvram_FsRead(NVM_FS_RW_MAIN_SYMBOL_PATH, 0, 1, &WorkArea_Symbol);
+ BackUp_Status = Nvram_FsRead(NVM_FS_RW_BACKUP_SYMBOL_PATH, 0, 1, &BackUp_Symbol);
+ if(WorkArea_Status != 0 || WorkArea_Symbol != NV_SYMBOL_NORMAL)
+ {
+ /* work area check fail */
+ if(BackUp_Status == 0 && BackUp_Symbol == NV_SYMBOL_NORMAL)
+ {
+ /* backup area check ok */
+ WorkArea_Symbol = NV_SYMBOL_WRITE;
+ status = Nvram_FsWrite(NVM_FS_RW_MAIN_SYMBOL_PATH, 0, 1, &WorkArea_Symbol);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ status = Nvram_CopyFile(NVM_FS_RW_MAIN_PATH, NVM_FS_RW_BACKUP_PATH);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ WorkArea_Symbol = NV_SYMBOL_NORMAL;
+ status = Nvram_FsWrite(NVM_FS_RW_MAIN_SYMBOL_PATH, 0, 1, &WorkArea_Symbol);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ printk("cpnv restore backup to main!\n");
+ }
+ else
+ {
+ /* backup and work area check both fail */
+ Factory_Symbol = NV_SYMBOL_FACTORY;
+ status = Nvram_FsWrite(NVM_FS_FAC_SYMBOL_PATH, 0, 1, &Factory_Symbol);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ printk("cpnv work and backup both fail restore fac!\n");
+ goto factory_check;
+ }
+ }
+ else
+ {
+ /* WorkArea ok*/
+ if(BackUp_Status != 0 || BackUp_Symbol != NV_SYMBOL_NORMAL)
+ {
+ /* backup area check fail */
+ BackUp_Symbol = NV_SYMBOL_WRITE;
+ status = Nvram_FsWrite(NVM_FS_RW_BACKUP_SYMBOL_PATH, 0, 1, &BackUp_Symbol);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ status = Nvram_CopyFile(NVM_FS_RW_BACKUP_PATH, NVM_FS_RW_MAIN_PATH);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ BackUp_Symbol = NV_SYMBOL_NORMAL;
+ status = Nvram_FsWrite(NVM_FS_RW_BACKUP_SYMBOL_PATH, 0, 1, &BackUp_Symbol);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ printk("cpnv restore main to backup!\n");
+ }
+ else
+ {
+ /* WorkArea and Backup Area both ok */
+ if(ZOSS_ERROR == Nvram_CmpFile(NVM_FS_RW_BACKUP_PATH, NVM_FS_RW_MAIN_PATH))
+ {
+ Factory_Symbol = NV_SYMBOL_FACTORY;
+ status = Nvram_FsWrite(NVM_FS_FAC_SYMBOL_PATH, 0, 1, &Factory_Symbol);
+ zOss_ASSERT(status == ZOSS_SUCCESS);
+
+ printk("cpnv cmp wrong!, restore fac!\n");
+
+ goto factory_check;
+ }
+ }
+ }
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_WriteRO
+* ¹¦ÄÜÃèÊö£º дһÏîNV ROÊý¾Ý
+* ²ÎÊý˵Ã÷£º (IN)
+* part_name: ÎļþÃû³Æ
+* NvItemID: ¸ÃNVÏîµÄÆ«ÒƵØÖ·(Ïà¶ÔÓÚNVÆðʼµØÖ·µÄÆ«ÒÆ)
+* NvItemData: дÈëµÄÊý¾Ý
+* NvItemLen: Êý¾Ý³¤¶È
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º ÁÙʱ·½°¸ÊÊÓ㬺óÐøɾ³ý
+**************************************************************************/
+static UINT32 Nvram_WriteRO(const CHAR *part_name, UINT32 NvItemID, UINT8 *NvItemData, UINT32 NvItemLen)
+{
+ UINT32 status = ZOSS_ERROR;
+
+ status = Nvram_Remount("mtd:nvrofs", "/mnt/nvrofs", "jffs2", MS_REMOUNT |MS_VERBOSE);
+ if(ZOSS_SUCCESS != status)
+ return ZOSS_ERROR;
+
+ status = Nvram_FsWrite(part_name, NvItemID, NvItemLen, NvItemData);
+ status |= Nvram_Remount("mtd:nvrofs", "/mnt/nvrofs", "jffs2", MS_REMOUNT |MS_VERBOSE|MS_RDONLY);
+
+ return status;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_Check_Data
+* ¹¦ÄÜÃèÊö£º ²é¿´¹¤×÷ÇøºÍ±¸·ÝÇøÊý¾ÝÊÇ·ñÓÐЧ£¬ÈçÎÞЧÔò»Ö¸´
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØTRUE, ·ñÔò·µ»ØFALSE
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static BOOL Nvram_Check_Data(VOID)
+{
+ if(Nvram_DirInit() != ZOSS_SUCCESS)
+ {
+ printk("cpnv Nvram_DirInit fail!\n");
+ zOss_ASSERT(0);
+ }
+
+ if(Nvram_RoInit() != ZOSS_SUCCESS)
+ {
+ printk("cpnv Nvram_RoInit fail!\n");
+ zOss_ASSERT(0);
+ }
+
+ if(Nvram_RwInit() != ZOSS_SUCCESS)
+ {
+ printk("cpnv Nvram_RwInit fail!\n");
+ zOss_ASSERT(0);
+ }
+
+ return TRUE;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_WriteWithFlag
+* ¹¦ÄÜÃèÊö£º дһÏîNV RW´ø±êÖ¾
+* ²ÎÊý˵Ã÷£º (IN)
+* NvItemID: ¸ÃNVÏîµÄÆ«ÒƵØÖ·(Ïà¶ÔÓÚNVÆðʼµØÖ·µÄÆ«ÒÆ)
+* NvItemData: дÈëµÄÊý¾Ý
+* NvItemLen: Êý¾Ý³¤¶È
+* iNvm: Ö÷»¹ÊDZ¸·Ý
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 Nvram_WriteWithFlag(UINT32 NvItemID, UINT8 *NvItemData, UINT32 NvItemLen, UINT8 iNvm)
+{
+ CHAR *pSymbol_File = NULL;
+ CHAR *pWrite_File = NULL;
+ UINT32 Start_Addr = 0;
+ UINT8 NV_Symbol = 0;
+ UINT32 status = ZOSS_ERROR;
+
+ if (iNvm == NV_WORK_AREA)
+ {
+ pSymbol_File = NVM_FS_RW_MAIN_SYMBOL_PATH;
+ pWrite_File = NVM_FS_RW_MAIN_PATH;
+ }
+ else if (iNvm == NV_BACKUP_AREA)
+ {
+ pSymbol_File = NVM_FS_RW_BACKUP_SYMBOL_PATH;
+ pWrite_File = NVM_FS_RW_BACKUP_PATH;
+ }
+ else
+ return ZOSS_ERROR;
+
+ NV_Symbol = NV_SYMBOL_WRITE;
+ status = Nvram_FsWrite(pSymbol_File, 0, 1, &NV_Symbol);
+ if (status != ZOSS_SUCCESS)
+ return ZOSS_ERROR;
+
+ status = Nvram_FsWrite(pWrite_File, NvItemID, NvItemLen, NvItemData);
+ if (status != ZOSS_SUCCESS)
+ return ZOSS_ERROR;
+
+ NV_Symbol = NV_SYMBOL_NORMAL;
+
+ return Nvram_FsWrite(pSymbol_File, 0, 1, &NV_Symbol);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_FsRead
+* ¹¦ÄÜÃèÊö£º ´ÓÎļþ
+* ²ÎÊý˵Ã÷£º (IN)¶ÁÈ¡nv
+* part_name: ÎļþÃû
+* dwStart: ¸ÃNVÏîµÄÆ«ÒƵØÖ·(Ïà¶ÔÓÚNVÆðʼµØÖ·µÄÆ«ÒÆ)
+* from: дÈëµÄÊý¾Ý
+* dwLen: Êý¾Ý³¤¶È
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º ÁÙʱ·½°¸ÊÊÓ㬺óÐøɾ³ý
+**************************************************************************/
+static UINT32 Nvram_FsRead(const CHAR *part_name, UINT32 dwStart, UINT32 dwLen, UINT8 *to)
+{
+ SINT32 ret = 0;
+ SINT32 fd = 0;
+ mm_segment_t old_fs = get_fs();
+
+ if((part_name == NULL) || (to == NULL))
+ return ZOSS_ERROR;
+
+ set_fs(KERNEL_DS);
+ fd = CPPS_KO_FUNC(sys_open)(part_name, O_RDONLY, 0);
+ if(fd < 0)
+ {
+ printk("cpnv open %s fail,errno = %d\n", part_name, fd);
+ set_fs(old_fs);
+ return ZOSS_ERROR;
+ }
+
+ ret = CPPS_KO_FUNC(sys_lseek)(fd, dwStart, 0);
+ if(ret < 0)
+ {
+ printk("cpnv lseek %s fail,errno = %d\n", part_name, ret);
+ CPPS_KO_FUNC(sys_close)(fd);
+ set_fs(old_fs);
+ return ZOSS_ERROR;
+ }
+
+ ret = CPPS_KO_FUNC(sys_read)(fd, to, dwLen);
+ if(ret != dwLen)
+ {
+ printk("cpnv read %s fail, len = %d, errno = %d\n", part_name, dwLen, ret);
+ CPPS_KO_FUNC(sys_close)(fd);
+ set_fs(old_fs);
+ return ZOSS_ERROR;
+ }
+
+ CPPS_KO_FUNC(sys_close)(fd);
+ set_fs(old_fs);
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_FsWrite
+* ¹¦ÄÜÃèÊö£º дNVÊý¾Ýµ½Îļþ
+* ²ÎÊý˵Ã÷£º (IN)
+* part_name: ÎļþÃû
+* dwStart: ¸ÃNVÏîµÄÆ«ÒƵØÖ·(Ïà¶ÔÓÚNVÆðʼµØÖ·µÄÆ«ÒÆ)
+* from: дÈëµÄÊý¾Ý
+* dwLen: Êý¾Ý³¤¶È
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º ÁÙʱ·½°¸ÊÊÓ㬺óÐøɾ³ý
+**************************************************************************/
+static UINT32 Nvram_FsWrite(const CHAR *part_name, UINT32 dwStart, UINT32 dwLen, UINT8 *from)
+{
+ SINT32 ret = 0;
+ SINT32 fd = 0;
+ mm_segment_t old_fs = get_fs();;
+
+ if(part_name == NULL || from == NULL)
+ return ZOSS_ERROR;
+
+ set_fs(KERNEL_DS);
+ fd = CPPS_KO_FUNC(sys_open)(part_name, O_SYNC | O_RDWR | O_CREAT , 0);
+ if(fd < 0)
+ {
+ printk("cpnv open %s fail,errno = %d\n", part_name, fd);
+ set_fs(old_fs);
+ return ZOSS_ERROR;
+ }
+
+ ret = CPPS_KO_FUNC(sys_lseek)(fd, dwStart, 0);
+ if(ret < 0)
+ {
+ printk("cpnv lseek %s fail,errno = %d\n", part_name, ret);
+ CPPS_KO_FUNC(sys_close)(fd);
+ set_fs(old_fs);
+ return ZOSS_ERROR;
+ }
+
+ ret = CPPS_KO_FUNC(sys_write)(fd, from, dwLen);
+ if(ret != dwLen)
+ {
+ printk("cpnv write %s fail,errno = %d\n", part_name, ret);
+ CPPS_KO_FUNC(sys_close)(fd);
+ set_fs(old_fs);
+ return ZOSS_ERROR;
+ }
+
+ CPPS_KO_FUNC(sys_fsync)(fd);
+ CPPS_KO_FUNC(sys_close)(fd);
+ set_fs(old_fs);
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_Remount
+* ¹¦ÄÜÃèÊö£º ÖØйÒÔØ·ÖÇø
+* ²ÎÊý˵Ã÷£º (IN)
+* DevName: É豸Ãû³Æ
+* DirName: ¹ÒÔØ·¾¶
+* Type: ÎļþÀàÐÍ
+* Flag: ±êÖ¾
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º ×èÈûº¯Êý£¬²»ÔÊÐíÖжϼäÖ´ÐÐ
+**************************************************************************/
+UINT32 Nvram_Remount(CHAR *DevName, CHAR *DirName, CHAR *Type, UINT32 Flag)
+{
+ int ret = 0;
+ mm_segment_t old_fs = get_fs();
+
+ set_fs(KERNEL_DS);
+retry1:
+ ret = CPPS_KO_FUNC(sys_mount)(DevName, DirName, Type, Flag , 0);
+ if(ret == EBUSY)
+ {
+ msleep(10);
+ goto retry1;
+ }
+ set_fs(old_fs);
+
+ if(ret < 0)
+ {
+ printk("cpnv sys_mount fail,errno = %d\n", ret);
+ return ZOSS_ERROR;
+ }
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_CopyFile
+* ¹¦ÄÜÃèÊö£º ±È½Ï¹¤×÷ÇøºÍ±¸·ÝÇø
+* ²ÎÊý˵Ã÷£º (IN)
+* pDstFile: Ä¿±êÎļþ
+* pSrcFile: Ô´Îļþ
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 Nvram_CopyFile(const CHAR *pDstFile, const CHAR *pSrcFile)
+{
+ UINT8 *pBuf;
+ UINT32 len;
+ UINT32 ret;
+
+ if(pDstFile == NULL || pSrcFile == NULL)
+ return ZOSS_ERROR;
+
+ pBuf = Nvram_ReadFile(pSrcFile, &len);
+ if(!pBuf)
+ return ZOSS_ERROR;
+
+ ret = Nvram_FsWrite(pDstFile, 0, len, pBuf);
+
+ zOss_Free(pBuf);
+
+ return ret;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_CmpFile
+* ¹¦ÄÜÃèÊö£º ±È½Ï¹¤×÷ÇøºÍ±¸·ÝÇø
+* ²ÎÊý˵Ã÷£º (IN)
+* pDstFile: Ä¿±êÎļþ
+* pSrcFile: Ô´Îļþ
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 Nvram_CmpFile(const CHAR *pDstFile, const CHAR *pSrcFile)
+{
+ UINT8 *pDst;
+ UINT8 *pSrc;
+ UINT32 DstLen;
+ UINT32 SrcLen;
+
+ if(pDstFile == NULL || pSrcFile == NULL)
+ return ZOSS_ERROR;
+
+ pDst = Nvram_ReadFile(pDstFile, &DstLen);
+ if(!pDst)
+ return ZOSS_ERROR;
+
+ pSrc = Nvram_ReadFile(pSrcFile, &SrcLen);
+ if(!pSrc)
+ {
+ zOss_Free(pDst);
+ return ZOSS_ERROR;
+ }
+
+ if(DstLen != SrcLen)
+ {
+ zOss_Free(pSrc);
+ zOss_Free(pDst);
+
+ printk("Nvram_CmpFile Dstbuf = %d, Srcbuf = %d\n", DstLen, SrcLen);
+ return ZOSS_ERROR;
+ }
+
+ if(memcmp(pSrc, pDst, SrcLen) != 0)
+ {
+ zOss_Free(pSrc);
+ zOss_Free(pDst);
+ return ZOSS_ERROR;
+ }
+
+ zOss_Free(pSrc);
+ zOss_Free(pDst);
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_ReadFile
+* ¹¦ÄÜÃèÊö£º ¶ÁÈ¡Õû¸önvÎļþ
+* ²ÎÊý˵Ã÷£º (IN)
+* pFile: Îļþ
+* len: ³¤¶È
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º·µ»ØÖµµ÷ÓÃÕßÊÍ·Å
+**************************************************************************/
+static UINT8 *Nvram_ReadFile(const CHAR *pFile, UINT32 *len)
+{
+ SINT32 fd = 0;
+ SINT32 ret = 0;
+ struct stat buf = {0};
+ UINT8 *pBuf = {0};
+
+ if(pFile == NULL)
+ return NULL;
+
+ fd = CPPS_KO_FUNC(sys_open)(pFile, O_RDONLY, 0);
+ if(fd < 0)
+ {
+ printk("cpnv open %s fail,errno = %d\n", pFile, fd);
+ return NULL;
+ }
+
+ ret = CPPS_KO_FUNC(sys_newfstat)(fd, &buf);
+ if(0 != ret)
+ {
+ printk("cpnv stat %s fail,errno = %d\n", pFile, ret);
+ CPPS_KO_FUNC(sys_close)(fd);
+ return NULL;
+ }
+
+ pBuf = zOss_Malloc(buf.st_size);
+ if (pBuf == NULL)
+ {
+ printk("cpnv malloc fail\n");
+ CPPS_KO_FUNC(sys_close)(fd);
+ return NULL;
+ }
+
+ ret = CPPS_KO_FUNC(sys_read)(fd, pBuf, buf.st_size);
+ if(ret != buf.st_size)
+ {
+ printk("cpnv read %s fail,errno = %d\n", pFile, ret);
+ CPPS_KO_FUNC(sys_close)(fd);
+ zOss_Free(pBuf);
+ return NULL;
+ }
+ CPPS_KO_FUNC(sys_close)(fd);
+ *len = buf.st_size;
+
+ return pBuf;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Nvram_WriteFile
+* ¹¦ÄÜÃèÊö£º дÕû¸önvÎļþ
+* ²ÎÊý˵Ã÷£º (IN)
+* pFile: Îļþ
+* len: ³¤¶È
+* (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º·µ»ØÖµµ÷ÓÃÕßÊÍ·Å
+**************************************************************************/
+/*
+static SINT32 Nvram_WriteFile(const CHAR *pFile, UINT8 *pBuf, UINT32 len)
+{
+ SINT32 fd = 0;
+ SINT32 ret = 0;
+
+ fd = CPPS_KO_FUNC(sys_open)(pFile, O_SYNC | O_RDWR | O_CREAT | O_TRUNC, 0);
+ if(fd < 0)
+ {
+ printk("cpnv11 open %s fail,errno = %d\n", pFile, fd);
+ return 0;
+ }
+
+ ret = CPPS_KO_FUNC(sys_write)(fd, pBuf, len);
+ if(ret != len)
+ {
+ printk("cpnv write %s fail,errno = %d\n", pFile, ret);
+ CPPS_KO_FUNC(sys_close)(fd);
+ return ret;
+ }
+
+ CPPS_KO_FUNC(sys_fsync)(fd);
+ CPPS_KO_FUNC(sys_close)(fd);
+
+ return ret;
+}
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_printf.c b/cp/ps/plat/src/oss/sup/src/sup_printf.c
new file mode 100644
index 0000000..bf78ce8
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_printf.c
@@ -0,0 +1,114 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : printagt.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : ´òÓ¡´úÀíÔ´Îļþ
+* ×÷ Õß : ÀîÑô
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2007-06-09
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : ÐíÐË¿ü
+* ÐÞ¸ÄÈÕÆÚ : 2007-09-12
+* ÐÞ¸ÄÄÚÈÝ : ÐÞ¸ÄÁËOSS_Printfʹ֮¿ÉÒÔÔÚOSE¶Ë´òÓ¡
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0002
+* ÐÞ ¸Ä ÈË : ÐíÐË¿ü
+* ÐÞ¸ÄÈÕÆÚ : 2008-04-29
+* ÐÞ¸ÄÄÚÈÝ : ¶Ô´òÓ¡µÄЧÂʽøÐÐÁËÓÅ»¯
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0003
+* ÐÞ ¸Ä ÈË : Ï°Ö¾Ùæ
+* ÐÞ¸ÄÈÕÆÚ : 2009-03-20
+* ÐÞ¸ÄÄÚÈÝ : ÓÅ»¯´òӡЧÂÊ¡¢Ö§³Ö´òÓ¡µ½Îļþ¡¢¼Ç¼×îºó´òÓ¡¹¦ÄܺʹòÓ¡»º³å¸ßЧ»¯
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0004
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001782014
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0005
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-27
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é EC:617001782003
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+
+/**************************************************************************
+* Íⲿº¯ÊýÉùÃ÷
+**************************************************************************/
+#ifdef _OS_WIN
+#define vsnprintf _vsnprintf
+#endif
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+/**********************************************************************
+* º¯ÊýÃû³Æ£ºvsnformat
+* ¹¦ÄÜÃèÊö£º¸ñʽ»¯×Ö·û´®²¢Êä³öÖÁ»º³åÇø
+* ²ÎÊý˵Ã÷: (IN)
+ dwMaxCount£º»º³åÇø´óС£¨°üÀ¨NULL½áÊø·û£©
+ format £ºÒªÊ¹Óõĸñʽ´®
+ vaList £º¿É±ä²ÎÊýÁбí
+ (OUT)
+ pcBuffer £ºÊä³ö»º³åÇø
+* ·µ »Ø Öµ£º-1 £ºÊµ¼ÊÒªÊä³öµÄ×Ö½ÚÊý³¬³ö»º³åÇø´óС
+ ÆäËü£ºÊµ¼ÊÊä³öµÄ×Ö½ÚÊý¡£
+* ÆäËü˵Ã÷£º²»Ö§³Ö¸¡µãÊä³ö
+***********************************************************************/
+SINT32 vsnformat(CHAR *pcBuffer, UINT32 dwMaxCount, const CHAR *pcParamFormat, va_list vaList)
+{
+ return vsnprintf(( char *)pcBuffer, dwMaxCount, (char *)pcParamFormat, vaList);
+}
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_ramdump_arm.c b/cp/ps/plat/src/oss/sup/src/sup_ramdump_arm.c
new file mode 100644
index 0000000..5e62528
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_ramdump_arm.c
@@ -0,0 +1,267 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_ramdump_arm.c
+* Ïà¹ØÎļþ : Éú³ÉramdumpµÄarmv6¡¢armv5Ìåϵ½á¹¹µÄcmm½Å±¾Îļþ£»
+* ʵÏÖ¹¦ÄÜ :
+* ×÷ Õß : ÎâÕý¾ü
+* °æ ±¾ : 1.0
+* Íê³ÉÈÕÆÚ : 2013/10/19
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : ¸ß»ª·å
+* ÐÞ¸ÄÈÕÆÚ : 2012/10/10
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_ramdump.h"
+#ifdef _OS_TOS
+#include "tos_except_arm.h"
+#elif defined (_OS_LINUX)
+#include "linux_except_arm.h"
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#define ZOSS_ARM_MODE_NUM 6
+#define ZOSS_BANK_REG_NUM 3
+#define ZOSS_NORMAL_REG_NUM 15
+
+#define ZOSS_EXCEPT_UNDEF_INSTRUTION 0x04
+#define ZOSS_EXCEPT_PREFETCH_ABORT 0x0C
+#define ZOSS_EXCEPT_DATA_ABORT 0x10
+#define ZOSS_EXCEPT_IRQ 0x18
+#define ZOSS_EXCEPT_FIQ 0x1C
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+/**************************************************************************
+*Íⲿº¯ÊýÉùÃ÷Çø
+**************************************************************************/
+#ifdef _OS_TOS
+extern char *zTos_MpuDisplayCp15(char *addr);
+extern char *zTos_MmuDisplayCp15(char *addr);
+#elif defined (_OS_LINUX)
+extern char *ramdump_mpu_cp15(char *addr);
+extern char *ramdump_mmu_cp15(char *addr);
+#endif
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+static CHAR *ramdump_CreateCpsrCmmFile(CHAR *address);
+static CHAR *ramdump_CreateRegsitersCmmFile(CHAR *address);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+struct cpu_core Osa_CoreRegisters = {0};
+static struct cpu_regdump *g_zRadmumpRegInfo = NULL;
+static UINT8 g_zRamdump_ArmMode[ZOSS_ARM_MODE_NUM] = /* Êý×é˳ÐòÓëstruc coreÖеÄ˳ÐòÒ»Ö£¬²»Äܸü¸Ä */
+{
+ 0xdf, /* SYS */
+ 0xd3, /* SVC */
+ 0xd7, /* ABT */
+ 0xdb, /* UND */
+ 0xd2, /* IRQ */
+ 0xd1, /* FIQ */
+};
+static CHAR *g_zRamdumpBankReg[ZOSS_BANK_REG_NUM] = {(CHAR *)"r13", (CHAR *)"r14", (CHAR *)"spsr"};
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_CreateCpsrCmmFile
+ * ¹¦ÄÜÃèÊö£º´´½¨cpsr½Å±¾£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * cmmAddress : ½Å±¾µÄµØÖ·Ö¸Õ룻
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º ·µ»Ø½Å±¾µØÖ·£»
+**************************************************************************/
+static CHAR *ramdump_CreateCpsrCmmFile(CHAR *cmmAddress)
+{
+ UINT32 value = 0;
+
+ /* Êä³öcpsr */
+ if(g_zRadmumpRegInfo != NULL)
+ {
+ switch(g_zRadmumpRegInfo->vector)
+ {
+ case ZOSS_EXCEPT_UNDEF_INSTRUTION: /* undefined instruction */
+ {
+ value = Osa_CoreRegisters.undefined.psr;
+ break;
+ }
+ case ZOSS_EXCEPT_PREFETCH_ABORT: /* prefetch abort */
+ {
+ value = Osa_CoreRegisters.abort.psr;
+ break;
+ }
+ case ZOSS_EXCEPT_DATA_ABORT: /* data abort */
+ {
+ value = Osa_CoreRegisters.abort.psr;
+ break;
+ }
+ case ZOSS_EXCEPT_IRQ: /* IRQ */
+ {
+ value = Osa_CoreRegisters.irq.psr;
+ break;
+ }
+ case ZOSS_EXCEPT_FIQ: /* FIQ */
+ {
+ value = Osa_CoreRegisters.fiq.psr;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+ else
+ {
+ value =zOss_ReadCpsr();
+ }
+
+ return cmmAddress += (UINT32)sprintf(cmmAddress, "r.s cpsr %#lx\r\n", value);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_CreateRegsitersCmmFile
+ * ¹¦ÄÜÃèÊö£º´´½¨cpsr½Å±¾£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * cmmAddress: ½Å±¾µÄµØÖ·Ö¸Õ룻
+ * (OUT):
+ * ·µ »Ø Öµ£º·µ»Ø½Å±¾µØÖ·£»
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static CHAR *ramdump_CreateRegsitersCmmFile(CHAR *cmmAddress)
+{
+ UINT32 value = 0;
+ UINT32 *paddress = NULL;
+ UINT32 i = 0;
+ UINT32 j = 0;
+
+ zOss_ASSERT(cmmAddress != NULL);
+ if(g_zRadmumpRegInfo != NULL)
+ {
+ value = g_zRadmumpRegInfo->pc;
+ }
+ else
+ {
+ value = Osa_CoreRegisters.supervisor.lr;
+ }
+ cmmAddress += sprintf(cmmAddress, "r.s pc %#lx\r\n", value);
+
+ /* Çл»µ½svcģʽ£¬»¹Ôr0-r12 */
+ cmmAddress += sprintf(cmmAddress, "r.s cpsr %#lx\r\n", (UINT32)g_zRamdump_ArmMode[0]);
+
+ for(i = 0; i < ZOSS_NORMAL_REG_NUM-2; i++)
+ {
+ cmmAddress += sprintf(cmmAddress, "r.s r%d %#lx\r\n",(int)i, Osa_CoreRegisters.r[i]);
+ }
+ paddress = (UINT32 *)(&Osa_CoreRegisters.user.sp);
+ /* Êä³ö³ýfiqÖ®ÍâµÄÆäËûģʽ±¸·Ý¼Ä´æÆ÷ */
+ for(i = 0; i < ZOSS_ARM_MODE_NUM-1; i++)
+ {
+ cmmAddress += sprintf(cmmAddress, "r.s cpsr %#lx\r\n", (UINT32)g_zRamdump_ArmMode[i]);
+ for(j = 0; j < ZOSS_BANK_REG_NUM; j++)
+ {
+ cmmAddress += sprintf(cmmAddress, "r.s %s %#lx\r\n", g_zRamdumpBankReg[j], *paddress);
+ paddress++;
+ }
+ }
+ /* Êä³öFIQ r8-r14 */
+ cmmAddress += sprintf(cmmAddress, "r.s cpsr %#lx\r\n", (UINT32)g_zRamdump_ArmMode[5]);
+ for(i = 8; i < ZOSS_NORMAL_REG_NUM; i++)
+ {
+ cmmAddress += sprintf(cmmAddress, "r.s r%d %#lx\r\n", (int)i, *paddress);
+ paddress++;
+ }
+ /* Êä³öFIQ spsr */
+ cmmAddress += sprintf(cmmAddress, "r.s spsr %#lx\r\n", *paddress);
+ /* ´´½¨cpsr½Å±¾ */
+ return ramdump_CreateCpsrCmmFile(cmmAddress);
+}
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º zOss_RamdumpCreateCmmFile
+ * ¹¦ÄÜÃèÊö£º Éú³É»Ö¸´¶ÑÕ»µÄT32½Å±¾
+ * ²ÎÊý˵Ã÷£º (IN):
+ * pCmmFileInfo: ½Å±¾ÎļþÐÅÏ¢Ö¸Õ룻
+ * (OUT):ÎÞ
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ******************************************************************************/
+VOID zOss_RamdumpCreateCmmFile(T_zOss_RamdumpCmmFileInfo *pCmmFileInfo)
+{
+ CHAR *cmmAddress = NULL;
+
+ cmmAddress = pCmmFileInfo->cmmFileBuffer;
+ cmmAddress += sprintf(cmmAddress, "ENTRY &%s\r\n", ZOSS_RAMDUMP_DIR_NAME);
+ /*´´½¨¼Ä´æÆ÷½Å±¾ */
+ cmmAddress = ramdump_CreateRegsitersCmmFile(cmmAddress);
+ /* ½ûÖ¹MMU»òMPU */
+ cmmAddress += sprintf(cmmAddress, "per.s c15:0x1 %%long %#lx\r\n", (zOss_Cp15ReadControlRegister() & 0xfffffffe));
+ /* ´´½¨region ½Å±¾ */
+ cmmAddress = zOss_RamdumpCreateRegionsCmmFile(cmmAddress);
+ /* Êä³öcp15 c1 ¿ØÖƼĴæÆ÷ */
+ cmmAddress += sprintf(cmmAddress, "per.s c15:0x1 %%long %#lx\r\n", zOss_Cp15ReadControlRegister());
+
+#ifdef _OS_TOS
+# ifdef CYGOPT_HAL_ARM_MMU
+ /* Êä³ömmuÏà¹ØµÄ¼Ä´æÆ÷ */
+ cmmAddress = zTos_MmuDisplayCp15(cmmAddress);
+# endif
+
+# ifdef CYGOPT_HAL_ARM_MPU
+ /* Êä³ömpuÏà¹ØµÄ¼Ä´æÆ÷ */
+ cmmAddress = zTos_MpuDisplayCp15(cmmAddress);
+# endif
+#elif defined (_OS_LINUX)
+# ifdef CONFIG_MMU
+ /* Êä³ömmuÏà¹ØµÄ¼Ä´æÆ÷ */
+ cmmAddress = ramdump_mmu_cp15(cmmAddress);
+# else
+ /* Êä³ömpuÏà¹ØµÄ¼Ä´æÆ÷ */
+ cmmAddress = ramdump_mpu_cp15(cmmAddress);
+# endif
+#endif
+
+ /* Êä³ö½áÊø·û */
+ cmmAddress += sprintf(cmmAddress, "ENDDO\r\n");
+
+ pCmmFileInfo->cmmFileSize = (UINT32)(cmmAddress - pCmmFileInfo->cmmFileBuffer);
+ zOss_AssertExN(pCmmFileInfo->cmmFileSize <= pCmmFileInfo->cmmFileMaxSize);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_ramdump_client.c b/cp/ps/plat/src/oss/sup/src/sup_ramdump_client.c
new file mode 100644
index 0000000..c8cd6ea
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_ramdump_client.c
@@ -0,0 +1,443 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : tos_ramdump_arm_client.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ :
+* ×÷ Õß : ÎâÕý¾ü
+* °æ ±¾ : 1.0
+* Íê³ÉÈÕÆÚ : 2013/07/18
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_ramdump.h"
+#include "drvs_icp.h"
+#include "ram_config.h"
+
+#ifdef _OS_TOS
+#include <cyg/hal/tos_arm_mmu.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*************************************************************************
+* Íⲿº¯ÊýÉùÃ÷Çø
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+T_zOss_RamdumpOpt g_zRamdump_Optfunc = {NULL,NULL};
+T_zOss_RamdumpClientInfo *g_zRamdump_ClientInfo = NULL;
+T_zOss_RamdumpClientMsgInfo g_zRamdump_IcpMsgInfo = {0};
+
+#define ZRAMDUMP_CLIENT_FILE "sup_ramdump_client.con"
+#define ZRAMDUMP_CLIENT_ICP_TABLE(srcModId,desModId,chID)
+#define ZRAMDUMP_CLIENT_MEM_TABLE(identifier,pRamdumpStartAddr,ramdumpSize)
+#define ZRAMDUMP_SERVER_MEM_TABLE(identifier,pRamdumpStartAddr,ramdumpSize,serverFlagBase)
+#undef ZRAMDUMP_CLIENT_ICP_TABLE
+#define ZRAMDUMP_CLIENT_ICP_TABLE(identifier,actorID,chID) \
+ (UINT32)(identifier),(T_HalIcp_MsgActor)(actorID), \
+ (T_ZDrvRpMsg_ChID)(chID)
+static T_zOss_RamdumpIcpInfo s_zRamdump_IcpClientInfo =
+{
+ #include ZRAMDUMP_CLIENT_FILE
+};
+
+#undef ZRAMDUMP_CLIENT_ICP_TABLE
+#define ZRAMDUMP_CLIENT_ICP_TABLE(identifier,actorID,chID)
+#undef ZRAMDUMP_CLIENT_MEM_TABLE
+#define ZRAMDUMP_CLIENT_MEM_TABLE(identifier,pRamdumpStartAddr,ramdumpSize) \
+ (UINT32)(identifier),(CHAR *)(pRamdumpStartAddr), \
+ (UINT32)(ramdumpSize)
+static T_zOss_RamdumpClientConInfo s_zRamdump_ClientCfgInfo =
+{
+ #include ZRAMDUMP_CLIENT_FILE
+};
+#undef ZRAMDUMP_CLIENT_MEM_TABLE
+#define ZRAMDUMP_CLIENT_MEM_TABLE(identifier,pRamdumpStartAddr,ramdumpSize)
+static BOOL s_zRamdump_InitFlag = FALSE;
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#define ZOSS_RAMDUMP_CLIENT_ICP_SIZE 0x40
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+static VOID ramdump_ClientSendMsg(T_zOss_RamdumpIcpInfo *IcpInfo, T_zOss_RamdumpClientMsgInfo *pMsgInfo);
+static VOID ramdump_ClientProcessMsg(VOID *pMsg, UINT32 len);
+static VOID ramdump_Main(VOID);
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ClientSendMsg
+ * ¹¦ÄÜÃèÊö£ººË¼äͨѶÏûÏ¢·¢ËͽӿÚ
+ * ²ÎÊý˵Ã÷£º(IN):
+ * pIcpInfo: ramdump ICPÐÅÏ¢
+ * pMsgInfo: ICPÏûÏ¢
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ClientSendMsg(T_zOss_RamdumpIcpInfo *pIcpInfo, T_zOss_RamdumpClientMsgInfo *pMsgInfo)
+{
+ T_ZDrvRpMsg_Msg icpMsg = { 0 };
+
+ icpMsg.actorID = pIcpInfo->actorID;
+ icpMsg.chID = pIcpInfo->chID;
+ icpMsg.flag = 1;
+ icpMsg.buf = pMsgInfo;
+ icpMsg.len = sizeof(T_zOss_RamdumpClientMsgInfo);
+ zDrvRpMsg_WriteLockIrq(&icpMsg);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_GetConfigRegion
+ * ¹¦ÄÜÃèÊö£º»ñÈ¡ramdÒªµ¼³öµÄÇøÓò£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+#ifdef CYGOPT_HAL_ARM_MMU
+static VOID ramdump_GetConfigRegion(VOID)
+{
+ T_zOss_RamdumpRegion regionInfo = {0};
+ UINT32 cnt = 0;
+ T_zTos_MmuConfigItem *pItem = NULL;
+
+ for (cnt = 0; cnt < g_zTos_MmuConfigTable.count; cnt++)
+ {
+ pItem = &g_zTos_MmuConfigTable.item[cnt];
+ if (pItem->attr & ZTOS_MMU_REGION_DUMP)
+ {
+ regionInfo.baseForServer = pItem->server_base;
+ regionInfo.baseForSelf = pItem->physical_base;
+ regionInfo.size = pItem->size;
+ regionInfo.baseForCopy = (pItem->attr & ZTOS_MMU_REGION_COPY) ? pItem->server_base : 0;
+ zOss_RamdumpConfigureMem(®ionInfo);
+ }
+ }
+}
+#endif
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SetPartition
+ * ¹¦ÄÜÃèÊö£ºramdump¿Õ¼ä»®·Ö£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SetPartition(VOID)
+{
+ UINT32 size;
+ UINT32 sizeUnit = s_zRamdump_ClientCfgInfo.ramdumpSize/ZOSS_RAMDUMP_CLIENT_TOTAL_RATE;;
+
+ /* ramdumpµØÖ·»®·Ö */
+ memset(s_zRamdump_ClientCfgInfo.pRamdumpStartAddr, 0, s_zRamdump_ClientCfgInfo.ramdumpSize);
+ g_zRamdump_ClientInfo = (T_zOss_RamdumpClientInfo *)(((UINT32)s_zRamdump_ClientCfgInfo.pRamdumpStartAddr + sizeof(UINT32) - 1) & ~(sizeof(UINT32) - 1));
+ g_zRamdump_ClientInfo->clientFlagBase = (UINT32)g_zRamdump_ClientInfo+((sizeof(T_zOss_RamdumpClientInfo) + sizeof(UINT32) - 1)& ~(sizeof(UINT32) - 1));
+ g_zRamdump_ClientInfo->pCmmInfo = (T_zOss_RamdumpCmmFileInfo *)((char *)g_zRamdump_ClientInfo->clientFlagBase+4);
+ g_zRamdump_ClientInfo->pCmmInfo->cmmFileSize = 0;
+ size = (sizeUnit * ZOSS_RAMDUMP_CMM_INFO_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ClientInfo->pCmmInfo->cmmFileMaxSize = (size - sizeof(T_zOss_RamdumpCmmFileInfo));
+
+ g_zRamdump_ClientInfo->pConfigureInfo= (T_zOss_RamdumpRegionInfo *)((CHAR*)g_zRamdump_ClientInfo->pCmmInfo + size);
+ g_zRamdump_ClientInfo->pConfigureInfo->regionNum = 0;
+ size = (sizeUnit * ZOSS_RAMDUMP_CONFIGURED_REGION_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ClientInfo->pConfigureInfo->regionMaxNum = (size - sizeof(T_zOss_RamdumpRegionInfo)) / sizeof(T_zOss_RamdumpRegion);
+
+ g_zRamdump_ClientInfo->pParsedInfo = (T_zOss_RamdumpRegionInfo *)((CHAR*)g_zRamdump_ClientInfo->pConfigureInfo + size);
+ g_zRamdump_ClientInfo->pParsedInfo->regionNum = 0;
+ size = (sizeUnit * ZOSS_RAMDUMP_PARSED_REGION_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ClientInfo->pParsedInfo->regionMaxNum = (size - sizeof(T_zOss_RamdumpRegionInfo)) / sizeof(T_zOss_RamdumpRegion);
+
+ g_zRamdump_ClientInfo->pErrInfo = (T_zOss_RamdumpBuffInfo *)((CHAR *)g_zRamdump_ClientInfo->pParsedInfo + size);
+ size = (sizeUnit * ZOSS_RAMDUMP_ERR_INFO_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ClientInfo->pErrInfo->pBuff = (CHAR *)g_zRamdump_ClientInfo->pErrInfo + sizeof(T_zOss_RamdumpBuffInfo);
+ g_zRamdump_ClientInfo->pErrInfo->buffLen = size - sizeof(T_zOss_RamdumpBuffInfo);
+ g_zRamdump_ClientInfo->clientId = s_zRamdump_ClientCfgInfo.clientId;
+ sprintf((char *)g_zRamdump_ClientInfo->pErrInfo->pBuff, "%d_c_core: exact error!\n",(int)s_zRamdump_ClientCfgInfo.clientId);
+
+ zOss_AssertExN(((CHAR *)g_zRamdump_ClientInfo->pErrInfo->pBuff+ size) <=
+ (s_zRamdump_ClientCfgInfo.pRamdumpStartAddr + s_zRamdump_ClientCfgInfo.ramdumpSize));
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ClientProcessMsg
+ * ¹¦ÄÜÃèÊö£ººË¼äͨѶserverÏûÏ¢´¦Àí½Ó¿Ú
+ * ²ÎÊý˵Ã÷£º(IN):
+ * pBuff:ÏûÏ¢µÄbuff
+ * len :ÏûÏ¢µÄ³¤¶È
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ClientProcessMsg(VOID *pBuff, UINT32 len)
+{
+ T_zOss_RamdumpServerMsgInfo *ramdumpMsg = (T_zOss_RamdumpServerMsgInfo *)pBuff;
+
+ switch(ramdumpMsg->msgType)
+ {
+ case ZOSS_RAMDUMP_EXCPT_TYPE:
+ {
+ sprintf((char *)g_zRamdump_ClientInfo->pErrInfo->pBuff, "%d_c_core: force error!\n",(int)g_zRamdump_ClientInfo->clientId);
+ zOss_RamdumpHandle(1, 1, 1);
+ break;
+ }
+ case ZOSS_RAMDUMP_TEST_EXCPT_TYPE:
+ {
+ sprintf((char *)g_zRamdump_ClientInfo->pErrInfo->pBuff, "%d_c_core: exact error!\n",(int)g_zRamdump_ClientInfo->clientId);
+ zOss_RamdumpHandle(1, 1, 1);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ClientIcpInit
+ * ¹¦ÄÜÃèÊö£ºclient ICP ³õʼ»¯£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ClientIcpInit(VOID)
+{
+ zDrvRpMsg_CreateChannel(s_zRamdump_IcpClientInfo.actorID, s_zRamdump_IcpClientInfo.chID, ZOSS_RAMDUMP_CLIENT_ICP_SIZE);
+ zDrvRpMsg_RegCallBack(s_zRamdump_IcpClientInfo.actorID, s_zRamdump_IcpClientInfo.chID, ramdump_ClientProcessMsg);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_NotifyServerExceptionOccur
+ * ¹¦ÄÜÃèÊö£ºÍ¨Öªserver·¢ÉúÁËÒì³££»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_NotifyServerExceptionOccur(VOID)
+{
+ T_zOss_RamdumpClientMsgInfo msgInfo = {0};
+
+ msgInfo.Identifier = s_zRamdump_ClientCfgInfo.clientId;
+ msgInfo.msgType = ZOSS_RAMDUMP_EXCPT_TYPE;
+ msgInfo.pRamdumpStartAddr = s_zRamdump_ClientCfgInfo.pRamdumpStartAddr;
+ msgInfo.radmumpSize = s_zRamdump_ClientCfgInfo.ramdumpSize;
+ ramdump_ClientSendMsg(&s_zRamdump_IcpClientInfo, &msgInfo);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ProcessException
+ * ¹¦ÄÜÃèÊö£º´¦ÀíÒì³£ÐÅÏ¢£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ProcessException(VOID)
+{
+ *(UINT32 *)g_zRamdump_ClientInfo->clientFlagBase = ZOSS_RAMDUMP_FLAG_SECOND_VALUE;
+ zOss_CleanCache();
+ while (*(UINT32 *)g_zRamdump_ClientInfo->clientFlagBase != ZOSS_RAMDUMP_FLAG_THIRD_VALUE);
+ zOss_RamdumpCreateCmmFile(g_zRamdump_ClientInfo->pCmmInfo);
+ *(UINT32 *)g_zRamdump_ClientInfo->clientFlagBase = ZOSS_RAMDUMP_FLAG_FOUR_VALUE;
+ zOss_CleanCache();
+}
+
+/*****************************************************************************
+ * º¯ÊýÃû³Æ£º ramdump_Main
+ * ¹¦ÄÜÃèÊö£º Ö´ÐÐramdump
+ * ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ * (OUT):ÎÞ
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ****************************************************************************/
+static VOID ramdump_Main(VOID)
+{
+ ramdump_NotifyServerExceptionOccur();
+ ramdump_ProcessException();
+}
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£º zOss_RamdumpHandle
+ * ¹¦ÄÜÃèÊö£º Ramdump´¦Àíº¯Êý
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º ²ÎÊýÔÚTOS²Ù×÷ϵͳÉÏûÓÐʵ¼ÊÒâÒ壻
+ **************************************************************************/
+VOID zOss_RamdumpHandle(UINT16 user_called, UINT16 ecode, UINT16 extra)
+{
+ static UINT32 excepNum = 0;
+ ZOSS_INTR old_intr;
+
+ ZOSS_SAVE_IRQ(old_intr);
+ if (++excepNum > 1 || !s_zRamdump_InitFlag) /* Ö»±£´æµÚÒ»´Î³ö´íÏÖ³¡ */
+ {
+ for( ; ; ) ;
+ }
+ zOss_RamdumpEncodeError(g_zRamdump_ClientInfo->pErrInfo->pBuff, user_called, ecode, extra);
+ ramdump_Main();
+ for( ; ; ) ;
+ ZOSS_RESTORE_IRQ(old_intr);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_RegionsCmmFile
+ * ¹¦ÄÜÃèÊö£ºT32cmm½Å±¾ÄÚ´æ¶ÎдÈë
+ * ²ÎÊý˵Ã÷£º(IN):
+ * address: cmm½Å±¾µÄµØÖ·£»
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+CHAR *zOss_RamdumpCreateRegionsCmmFile(CHAR *address)
+{
+ CHAR fileName[ZOSS_RAMDUMP_FILENAME_LEN] = {0};
+ UINT32 i = 0;
+
+ sprintf(fileName, "%d_c_mem.bin", (int)g_zRamdump_ClientInfo->clientId);
+ for (i = 0; i < g_zRamdump_ClientInfo->pParsedInfo->regionNum; i++)
+ {
+ T_zOss_RamdumpRegion *pRegion = &(g_zRamdump_ClientInfo->pParsedInfo->regions[i]);
+ if (pRegion->baseForSelf != pRegion->baseForServer)
+ {
+ UINT32 parsedEnd = pRegion->baseForSelf + pRegion->size - 1;
+ address += sprintf(address, "data.load.binary &%s\\%d_%s %#lx--%#lx /noclear\r\n", ZOSS_RAMDUMP_DIR_NAME,
+ (int)i, fileName, pRegion->baseForSelf, parsedEnd);
+ if (pRegion->baseForCopy != 0)
+ {
+ memcpy((void*)pRegion->baseForCopy, (void*)pRegion->baseForSelf,(parsedEnd - pRegion->baseForSelf + 1));
+ }
+ }
+ else
+ {
+ address += (UINT32)sprintf(address, "data.load.binary &%s\\%d_%s %#lx--%#lx /noclear\r\n", ZOSS_RAMDUMP_DIR_NAME,
+ (int)i, fileName, pRegion->baseForSelf, pRegion->baseForSelf + pRegion->size - 1);
+ }
+ }
+
+ return address;
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£º zOss_RamdumpConfigureMem
+ * ¹¦ÄÜÃèÊö£º ±£´æÄÚ´æ¶ÎÊý¾ÝÅäÖÃÐÅÏ¢
+ * ²ÎÊý˵Ã÷£º (IN):
+ * regionInfo: ÅäÖÃÇøÓòÖ¸Õ룻
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID zOss_RamdumpConfigureMem(T_zOss_RamdumpRegion *regionInfo)
+{
+ T_zOss_RamdumpRegionInfo *pCfgInfo = g_zRamdump_ClientInfo->pConfigureInfo;
+
+ if (regionInfo->size == 0)
+ return;
+ zOss_AssertExN(pCfgInfo->regionNum < pCfgInfo->regionMaxNum);
+ zOss_AssertExN((regionInfo->size - 1) <= (0xFFFFFFFF - regionInfo->baseForServer));
+ pCfgInfo->regions[pCfgInfo->regionNum].baseForServer = regionInfo->baseForServer;
+ pCfgInfo->regions[pCfgInfo->regionNum].baseForSelf = regionInfo->baseForSelf;
+ pCfgInfo->regions[pCfgInfo->regionNum].baseForCopy = regionInfo->baseForCopy;
+ pCfgInfo->regions[pCfgInfo->regionNum].size = regionInfo->size;
+ (pCfgInfo->regionNum)++;
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£º zOss_RamdumpSetOperation
+ * ¹¦ÄÜÃèÊö£º ramdumpÓû§×¢²á½Ó¿Ú£»
+ * ²ÎÊý˵Ã÷£º (IN):
+ * funcObjPtr: »Øµ÷º¯Êý£»
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID zOss_RamdumpSetOperation(T_zOss_RamdumpOpt *funcObjPtr)
+{
+ zOss_AssertExN(funcObjPtr != NULL);
+
+ if (funcObjPtr->ramdump_Process_PreHook != NULL)
+ {
+ g_zRamdump_Optfunc.ramdump_Process_PreHook = funcObjPtr->ramdump_Process_PreHook;
+ }
+
+ if (funcObjPtr->ramdump_Process_AftHook != NULL)
+ {
+ g_zRamdump_Optfunc.ramdump_Process_AftHook = funcObjPtr->ramdump_Process_AftHook;
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ: zOss_RamdumpInit
+ * ¹¦ÄÜÃèÊö£ºRamdump³õʼ»¯£»
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ***************************************************************************/
+VOID zOss_RamdumpInit(VOID)
+{
+ ramdump_SetPartition();
+#ifdef CYGOPT_HAL_ARM_MMU
+ ramdump_GetConfigRegion();
+#endif
+ ramdump_ClientIcpInit();
+ *(UINT32 *)g_zRamdump_ClientInfo->clientFlagBase = ZOSS_RAMDUMP_FLAG_FIRST_VALUE;
+ g_zRamdump_IcpMsgInfo.Identifier = s_zRamdump_ClientCfgInfo.clientId;
+ g_zRamdump_IcpMsgInfo.msgType = ZOSS_RAMDUMP_INIT_TYPE;
+ g_zRamdump_IcpMsgInfo.pRamdumpStartAddr = s_zRamdump_ClientCfgInfo.pRamdumpStartAddr;
+ g_zRamdump_IcpMsgInfo.radmumpSize = s_zRamdump_ClientCfgInfo.ramdumpSize;
+
+ ramdump_ClientSendMsg(&s_zRamdump_IcpClientInfo, &g_zRamdump_IcpMsgInfo);
+ zOss_CleanCache();
+ s_zRamdump_InitFlag = TRUE;
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºOsa_SysErrHndInit
+ * ¹¦ÄÜÃèÊö£ºµØÖ·È«¾Ö±äÁ¿³õʼ»¯,»ñÈ¡ramdumpÄÚ´æ¿éĬÈÏÅäÖÃ
+ arm0ºÍarm1ͬ²½»úÖÆ
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º´ò×®£¬ÎªÁ˼æÈÝose¡¢cskyµÈramdump¹¦ÄÜ£»
+ ***************************************************************************/
+VOID Osa_SysErrHndInit(VOID)
+{
+
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_ramdump_client_lib.c b/cp/ps/plat/src/oss/sup/src/sup_ramdump_client_lib.c
new file mode 100644
index 0000000..f50dd73
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_ramdump_client_lib.c
@@ -0,0 +1,412 @@
+/*******************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+********************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_ramdump_m0_adapt.c
+* Ïà¹ØÎļþ : sup_ramdump_m0_adapt.c
+* ʵÏÖ¹¦ÄÜ : ʵÏÖm0°æ±¾È±ÉÙµÄc¿âº¯Êý£»
+* ×÷ Õß : ¸ß»ª·å
+* °æ ±¾ : 1.0
+* Íê³ÉÈÕÆÚ : 2013/10/17
+* ÆäËü˵Ã÷ :
+*******************************************************************************/
+
+/*******************************************************************************
+* Ð޸ļǼ
+*******************************************************************************/
+
+/*******************************************************************************
+* #includeÇø
+*******************************************************************************/
+#include <stdarg.h>
+#include "oss_api.h"
+#include "sup_ramdump.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*******************************************************************************
+* ºê¶¨ÒåÇø
+*******************************************************************************/
+#define ZOSS_VSNFORMAT_BUFF_SIZE 100
+#define ZOSS_VSNFORMAT_TOCHAR(n) ((n) + '0')
+#define ZOSS_VSNFORMAT__DECIMAL 10
+#define ZOSS_VSNFORMAT_HEX 16
+#define ZOSS_VSNFORMAT_HEXPREFIX_LEN 2
+#define ZOSS_VSNFORMAT_LONG 0X0
+#define ZOSS_VSNFORMAT_PREFIX 0X1
+#define ZOSS_VSNFORMAT_HEXPREFIX 0X4
+#define ZOSS_INT_MAX 0xFF
+
+/*******************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+*******************************************************************************/
+/* ¸ñʽ»¯·µ»ØÖµÀàÐÍ */
+typedef enum
+{
+ FORMAT_TYPE_CONTINUE,
+ FORMAT_TYPE_PUTFMTSTR,
+ FORMAT_TYPE_INTVALUE,
+ FORMAT_TYPE_ERROR,
+ FORMAT_TYPE_MAX
+}T_zOss_FormatTypeRet;
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+*******************************************************************************/
+static SINT32 vsnformat(CHAR *pcBuffer, UINT32 dwMaxCount, const CHAR *pcParamFormat, va_list vaList);
+static SINT32 getVareIntValue(UINT32 *pFormatType, SINT32 swBase, va_list *vaList);
+static CHAR *translateNumberToStr(CHAR *pAcBuf, SINT32 dwVal, SINT32 swBase, SINT32 *sdwSize);
+static CHAR *getStrLen(va_list *vaList, SINT32 *pSdwSize);
+static T_zOss_FormatTypeRet getFormatType(SINT32 swCh, UINT32 *pFormatType, SINT32 *pSwBase);
+
+/*******************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+*******************************************************************************/
+static CHAR BIG_HEX_DIGIT[] = "0123456789ABCDEF";
+static CHAR NULLSTRING[] = "(null)";
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+*******************************************************************************/
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º getVareIntValue
+ * ¹¦ÄÜÃèÊö£º »ñÈ¡±ä²ÎÖÐÕûÐεÄÊýÖµ£»
+ * ²ÎÊý˵Ã÷£º (IN):
+ * pFormatType: ¸ñʽ»¯ÀàÐÍ£»
+ * (OUT):
+ * swBase: ÖÆʽ£»
+ * vaList: ¿É±ä²ÎÊý£»
+ * ·µ »Ø Öµ£º ·µ»Ø±ä²ÎÖеÄÕûÐÎÊýÖµ£»
+ * ÆäËü˵Ã÷£º
+ ******************************************************************************/
+static SINT32 getVareIntValue(UINT32 *pFormatType, SINT32 swBase, va_list *vaList)
+{
+ SINT32 dwVal = 0;
+
+ if (*pFormatType & (1 << ZOSS_VSNFORMAT_LONG))
+ {
+ dwVal = va_arg(*vaList, unsigned long);
+ }
+ else
+ {
+ dwVal = va_arg(*vaList, unsigned int);
+ }
+
+ if ((*pFormatType & (1 << ZOSS_VSNFORMAT_PREFIX)) && (ZOSS_VSNFORMAT_HEX == swBase) && (0 != dwVal))
+ {
+ *pFormatType = *pFormatType | (1<< ZOSS_VSNFORMAT_HEXPREFIX);
+ }
+
+ return dwVal;
+}
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º translateNumberToStr
+ * ¹¦ÄÜÃèÊö£º ½«Êý×Öת»¯ÎªÊý×Ö×Ö·û´®£»
+ * ²ÎÊý˵Ã÷£º (IN):
+ * pAcBuf: »º´æµÄÖ¸Õ룻
+ * dwVal: ÕûÐÎÊýÖµ£»
+ * swBase: ÖÆʽ£»
+ * (OUT):
+ * sdwSize: ת»¯ºóÊýÖµµÄ´óС£»
+ * ·µ »Ø Öµ£º ·µ»ØÊýÖµ´æ·ÅµÄµØÖ·£»
+ * ÆäËü˵Ã÷£º
+ ******************************************************************************/
+static CHAR *translateNumberToStr(CHAR *pAcBuf, SINT32 dwVal, SINT32 swBase, SINT32 *sdwSize)
+{
+ CHAR *pch = pAcBuf + ZOSS_VSNFORMAT_BUFF_SIZE;
+
+ switch (swBase)
+ {
+ case ZOSS_VSNFORMAT__DECIMAL: /* 10½øÖÆÊä³ö */
+ {
+ while (dwVal >= ZOSS_VSNFORMAT__DECIMAL)
+ {
+ *--pch = (CHAR)ZOSS_VSNFORMAT_TOCHAR(dwVal % ZOSS_VSNFORMAT__DECIMAL);
+ dwVal /= ZOSS_VSNFORMAT__DECIMAL;
+ }
+ *--pch = (CHAR)ZOSS_VSNFORMAT_TOCHAR(dwVal);
+ break;
+ }
+ case ZOSS_VSNFORMAT_HEX: /* 16½øÖÆÊä³ö */
+ {
+ do
+ {
+ *--pch = BIG_HEX_DIGIT[dwVal & 15];
+ dwVal >>= 4;
+ }
+ while (dwVal);
+ break;
+ }
+ default:
+ break;
+ }
+ *sdwSize = pAcBuf + ZOSS_VSNFORMAT_BUFF_SIZE - pch;
+ return pch;
+}
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º getStrLen
+ * ¹¦ÄÜÃèÊö£º »ñÈ¡¿É±ä×Ö·û´®µÄ³¤¶È£»
+ * ²ÎÊý˵Ã÷£º (IN):
+ * vaList: ¿É±ä²ÎÊý
+ * pSdwSize: ¿É±ä²ÎÊýµÄ³¤¶È£»
+ * (OUT):
+ * ·µ »Ø Öµ£º ·µ»Ø%ÔÚ×Ö·û´®µÄλÖã»
+ * ÆäËü˵Ã÷£º
+ ******************************************************************************/
+CHAR *getStrLen(va_list *vaList, SINT32 *pSdwSize)
+{
+ CHAR *pch = (CHAR *)va_arg(*vaList, CHAR *);
+
+ if (pch == NULL)
+ {
+ pch = NULLSTRING;
+ }
+ *pSdwSize = (SINT32)strlen((char *)pch);
+ return pch;
+}
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º getFormatType
+ * ¹¦ÄÜÃèÊö£º ½«Êý×Öת»¯ÎªÊý×Ö×Ö·û´®£»
+ * ²ÎÊý˵Ã÷£º (IN):
+ * swCh: ¸ñʽ»¯×Ö·û£»
+ * (OUT):
+ * pFormatType: ¸ñʽ»¯ÀàÐÍ£»
+ * pSwBase: Êý¾ÝµÄÖÆʽ
+ * ·µ »Ø Öµ£º ¸ñʽ»¯µÄ·µ»ØÖµÀàÐÍ£»
+ * ÆäËü˵Ã÷£º
+ ******************************************************************************/
+static T_zOss_FormatTypeRet getFormatType(SINT32 swCh, UINT32 *pFormatType, SINT32 *pSwBase)
+{
+ T_zOss_FormatTypeRet retType = FORMAT_TYPE_MAX;
+
+ switch (swCh)
+ {
+ case '#':
+ {
+ *pFormatType = *pFormatType | (1 << ZOSS_VSNFORMAT_PREFIX);
+ retType = FORMAT_TYPE_CONTINUE;
+ break;
+ }
+ case 'l':
+ {
+ *pFormatType = *pFormatType | (1 << ZOSS_VSNFORMAT_LONG);
+ retType = FORMAT_TYPE_CONTINUE;
+ break;
+ }
+ case 's':
+ {
+ retType = FORMAT_TYPE_PUTFMTSTR;
+ break;
+ }
+ case 'X':
+ case 'x':
+ {
+ *pSwBase = ZOSS_VSNFORMAT_HEX;
+ retType = FORMAT_TYPE_INTVALUE;
+ }
+ break;
+ case 'd':
+ case 'i':
+ {
+ *pSwBase = ZOSS_VSNFORMAT__DECIMAL;
+ retType = FORMAT_TYPE_INTVALUE;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ return retType;
+}
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º vsnformat
+ * ¹¦ÄÜÃèÊö£º ¸ñʽ»¯×Ö·û´®²¢Êä³öÖÁ»º³åÇø
+ * ²ÎÊý˵Ã÷£º (IN):
+ * dwMaxCount£º»º³åÇø´óС£¨°üÀ¨NULL½áÊø·û£©
+ * format £ºÒªÊ¹Óõĸñʽ´®
+ * vaList £º¿É±ä²ÎÊýÁбí
+ * (OUT):
+ * pcBuffer £ºÊä³ö»º³åÇø
+ * ·µ »Ø Öµ£º -1 £ºÊµ¼ÊÒªÊä³öµÄ×Ö½ÚÊý³¬³ö»º³åÇø´óС,ÆäËü£ºÊµ¼ÊÊä³öµÄ×Ö½ÚÊý¡£
+ * ÆäËü˵Ã÷£º ΪÁËM0°æ±¾Öƶ¨µÄ¹¦ÄÜ£¬²»Ö§³ÖºÜ¶àvsnformat¹¦ÄÜ£»
+ ******************************************************************************/
+static SINT32 vsnformat(CHAR *pcBuffer, UINT32 dwMaxCount, const CHAR *pcParamFormat, va_list vaList)
+{
+ SINT16 swCh; /* È¡×ÔpcParamFormatµÄ×Ö·û */
+ CHAR *pch; /* ´¦Àí×Ö·ûµÄÖ¸Õë */
+ SINT32 dwVal; /* ÕûÊý²ÎÊý %[diouxX] */
+ SINT32 sdwSize; /* ÒªÊä³ö²ÎÊýµÄ³¤¶È */
+ SINT32 sdwRealSize; /* ²ÎÊýµÄʵ¼ÊÊä³ö³¤¶È */
+ CHAR acBuf[ZOSS_VSNFORMAT_BUFF_SIZE]; /* ´æ·ÅÕûÊý²ÎÊýµÄ»º´æ */
+ SINT32 sdwRet = 0; /* Êä³ö¼ÆÊý */
+ SINT32 swBase = ZOSS_VSNFORMAT__DECIMAL; /* ÕûÐβÎÊýµÄÊä³öµÄ½øÖÆ */
+ SINT32 dwCount = 0; /* ͳ¼ÆÊä³ö»º³åÇøµ±Ç°µÄ×Ö½ÚÊý */
+ CHAR *pcOut = pcBuffer; /* Êä³ö»º³åÇøÖ¸Õë */
+ UINT32 formatType = 0;
+ T_zOss_FormatTypeRet retFmtType = FORMAT_TYPE_MAX;
+
+ zOss_ASSERT((NULL != pcBuffer) || (NULL != pcParamFormat));
+ for (;;) /* ɨÃè¸ñʽ´®ÖеÄ%×Ö·û */
+ {
+ for (pch = (CHAR *)pcParamFormat; ((swCh = *pcParamFormat) != '\0') && (swCh != '%');
+ pcParamFormat++) ; /* ËÑË÷%×Ö·û */
+
+ /* Êä³ö%Ç°µÄÆäËü×Ö·û */
+ dwCount += pcParamFormat - pch;
+ memcpy(pcOut, pch, (UINT32)(pcParamFormat - pch));
+ pcOut += pcParamFormat - pch;
+ sdwRet += pcParamFormat - pch;
+ if ('\0' == swCh)
+ {
+ *pcOut = '\0'; /* ²¹ÉÏNULL½áÊø·û */
+ return sdwRet;
+ }
+ pcParamFormat++; /* Ìø¹ý '%' */
+ /* Ñ»·´¦Àíµ±Ç°%µÄÊä³ö¸ñʽ */
+ for (;;)
+ {
+ swCh = *pcParamFormat++;
+ retFmtType = getFormatType(swCh,&formatType,&swBase);
+ if ((retFmtType == FORMAT_TYPE_INTVALUE) || (retFmtType == FORMAT_TYPE_PUTFMTSTR))
+ {
+ break;
+ }
+ }
+ if ((retFmtType == FORMAT_TYPE_INTVALUE)) /* »ñÈ¡±ä²ÎÖеÄÕûÐͲÎÊý */
+ {
+ dwVal = getVareIntValue(&formatType, swBase, &vaList);
+ pch = translateNumberToStr(acBuf, dwVal, swBase, &sdwSize);
+ }
+ if (retFmtType == FORMAT_TYPE_PUTFMTSTR)
+ pch = getStrLen(&vaList, &sdwSize);
+ sdwRealSize = sdwSize;
+ if ( formatType & (1 << ZOSS_VSNFORMAT_HEXPREFIX))
+ {
+ sdwRealSize += ZOSS_VSNFORMAT_HEXPREFIX_LEN;
+ dwCount += ZOSS_VSNFORMAT_HEXPREFIX_LEN;
+ *pcOut++ = '0';
+ *pcOut++ = (CHAR)swCh;
+ }
+ /* Êä³öʵ¼ÊµÄ¸ñʽ´®¾»ºÉ */
+ dwCount += (UINT32)sdwSize;
+ zOss_ASSERT(dwCount < dwMaxCount);
+ memcpy(pcOut, pch, (UINT32)sdwSize);
+ pcOut += sdwSize;
+ sdwRet += sdwRealSize;
+ }
+}
+
+/*******************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+*******************************************************************************/
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º sprintf
+ * ¹¦ÄÜÃèÊö£º ʵÏÖc¿âsprintf¹¦ÄÜ£»
+ * ²ÎÊý˵Ã÷£º (IN):
+ * s: »º´æÖ¸Õ룻
+ * format: ¸ñʽ»¯×Ö·û´®£»
+ * ... : ´ý¸ñʽ»¯Êý¾Ý£»
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º Ϊm0°æ±¾¶¨ÖÆ£»
+ ******************************************************************************/
+int sprintf(char *s, const char *format, ...)
+{
+ int rc;
+ va_list ap;
+
+ va_start(ap, format);
+ rc = vsnformat(s, ZOSS_INT_MAX, format, ap);
+ va_end(ap);
+
+ return rc;
+}
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º memcpy
+ * ¹¦ÄÜÃèÊö£º ʵÏÖc¿âmemcpy¹¦ÄÜ£»
+ * ²ÎÊý˵Ã÷£º (IN):
+ * pDst: Ä¿±êµØÖ·£»
+ * pSrc: Ô´µØÖ·£»
+ * n : ³¤¶È£»
+ * (OUT):
+ * ·µ »Ø Öµ£º ·µ»ØÄ¿±êµØÖ·pDst£»
+ * ÆäËü˵Ã÷£º
+ ******************************************************************************/
+void *memcpy(void *pDst, const void *pSrc, size_t n)
+{
+ char *pTmpDst = (char *)pDst;
+ const char *pTmpSrc = (const char *)pSrc;
+
+ while (n--)
+ {
+ *pTmpDst++ = *pTmpSrc++;
+ }
+ return pDst;
+}
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º memchr
+ * ¹¦ÄÜÃèÊö£º ʵÏÖc¿âmemcpy¹¦ÄÜ£»
+ * ²ÎÊý˵Ã÷£º (IN):
+ * pStr: Ä¿±ê×Ö·û´®Ö¸Õ룻
+ * c : ×Ö·û£»
+ * n : ³¤¶È£»
+ * (OUT):
+ * ·µ »Ø Öµ£º ²éÕÒµÄ×Ö·ûµÄµØÖ·£»
+ * ÆäËü˵Ã÷£º
+ ******************************************************************************/
+void *memchr(const void *pStr, int c, size_t n)
+{
+ const unsigned char *pTmpStr = (const unsigned char *)pStr;
+
+ c &= 0xff;
+ while (n--)
+ {
+ if (*pTmpStr == c)
+ {
+ return (void *)pTmpStr;
+ }
+ pTmpStr++;
+ }
+ return NULL;
+}
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º memset
+ * ¹¦ÄÜÃèÊö£º ʵÏÖc¿âmemset¹¦ÄÜ£»
+ * ²ÎÊý˵Ã÷£º (IN):
+ * pStr: bufferµÄÖ¸Õ룻
+ * c : ·ûºÅ£»
+ * n : ×Ö·û´®µÄ³¤¶È£»
+ * (OUT):
+ * ·µ »Ø Öµ£º ·µ»ØpStrÖ¸Õ룻
+ * ÆäËü˵Ã÷£º
+ ******************************************************************************/
+void *memset(void *pStr, int c, size_t n)
+{
+ char *pTmpStr = (char *)pStr;
+
+ while (n-- != 0)
+ {
+ *pTmpStr++ = (char)c;
+ }
+ return pStr;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_ramdump_comm.c b/cp/ps/plat/src/oss/sup/src/sup_ramdump_comm.c
new file mode 100644
index 0000000..9550f46
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_ramdump_comm.c
@@ -0,0 +1,313 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_ramdump_comm.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : ramdumpµÄIO½Ó¿ÚʵÏÖ·â×°£»
+* ×÷ Õß :
+* °æ ±¾ : 1.0
+* Íê³ÉÈÕÆÚ : 2014/03/25
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#ifdef _USE_CP_USB
+#include "oss_api.h"
+#include "drvs_usbPoll.h"
+#else
+#include "oss_api.h"
+#include "drvs_icp.h"
+#include "drv_api.h"
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* Íⲿº¯ÊýºÍ±äÁ¿ÉùÃ÷Çø
+**************************************************************************/
+#ifndef _USE_CP_USB
+extern SINT32 zDrvRpMsg_CreateLockSaveChannel (T_ZDrvRpMsg_MsgActor actorID, T_ZDrvRpMsg_ChID chID, UINT32 size);
+extern SINT32 zDrvRpMsg_ReadLockIrq(const T_ZDrvRpMsg_Msg *pMsg);
+#endif
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#define ZOSS_RAMDUMP_USB_POLL_CNT 100
+#define ZOSS_RAMDUMP_ICP_CHANNEL_SIZE 0x2800
+#define ZOSS_RAMDUMP_ICP_DATA_SIZE(len) (min((len),(ZOSS_RAMDUMP_ICP_CHANNEL_SIZE/2)))
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+#ifdef _USE_CP_USB
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpUsbInit
+ * ¹¦ÄÜÃèÊö£ºramdump USB ³õʼ»¯.
+ * ²ÎÊý˵Ã÷£º
+ * (IN)
+ * ÎÞ
+ * (OUT)
+ * ÎÞ
+ *·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ **************************************************************************/
+VOID zOss_RamdumpUsbInit(VOID)
+{
+ zDrvUsbPoll_Init(); /* ³õʼ»¯USB */
+ while (!zDrvUsbPoll_isConnect()) ; /* ²éѯUSBÊÇ·ñÁ¬½Ó */
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpUsbReadData
+ * ¹¦ÄÜÃèÊö£º¶ÁÖ¸¶¨Í¨µÀµÄÊý¾Ý.
+ * ²ÎÊý˵Ã÷£º
+ * (IN)
+ * buffer: ¶ÁÊý¾ÝµÄbufferÖ¸Õ룻
+ * size : ¶ÁÊý¾ÝµÄ´óС£»
+ * (OUT)
+ * ÎÞ
+ *·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ **************************************************************************/
+VOID zOss_RamdumpUsbReadData(UINT8 *buffer, UINT32 size)
+{
+ UINT32 count = 0;
+
+ do
+ {
+ zDrvUsbPoll_Isr();
+ count = (UINT32)zDrvUsbPoll_Read(buffer, size);
+ if( size <= count)
+ {
+ break;
+ }
+ buffer += count;
+ size -=count;
+ }
+ while (size > 0);
+}
+
+/***************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpIoWriteData
+ * ¹¦ÄÜÃèÊö£ºÐ´Êý¾Ýµ½Ö¸¶¨Í¨µÀ.
+ * ²ÎÊý˵Ã÷£º(IN):
+ * buffer: ¶ÁÊý¾ÝµÄbufferÖ¸Õ룻
+ * size : ¶ÁÊý¾ÝµÄ´óС£»
+ * (OUT):
+ * ÎÞ£»
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ****************************************************************************/
+VOID zOss_RamdumpUsbWriteData(UINT8 *buffer, UINT32 size)
+{
+ UINT32 count = 0;
+
+ while (size > 0)
+ {
+ zDrvUsbPoll_Isr();
+ count = (UINT32)zDrvUsbPoll_Write(buffer, size);
+ if( size <= count)
+ {
+ break;
+ }
+
+ buffer += count;
+ size -=count;
+ }
+}
+
+/***************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpIoFinish
+ * ¹¦ÄÜÃèÊö£ºRamdumpÎļþ´«Êä½áÊø£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ****************************************************************************/
+VOID zOss_RamdumpUsbFinish(VOID)
+{
+ UINT32 i;
+
+ for (i = 0; i < ZOSS_RAMDUMP_USB_POLL_CNT; i++) /* µÈ´ýÊý¾Ý·¢ËÍÍêºó£¬ÔÙÖØÆô */
+ {
+ zDrvUsbPoll_Isr();
+ }
+}
+
+/***************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpSetUsbOpt
+ * ¹¦ÄÜÃèÊö£ºÉèÖÃUsbͨµÀ;
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ****************************************************************************/
+VOID zOss_RamdumpSetUsbOpt(VOID)
+{
+ T_zOss_RamdumpIoOpt hook = {zOss_RamdumpUsbInit, zOss_RamdumpUsbReadData, zOss_RamdumpUsbWriteData, zOss_RamdumpUsbFinish};
+
+ zOss_RamdumpSetIoOpt(hook);
+ return;
+}
+#else
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpIcpReadData
+ * ¹¦ÄÜÃèÊö£º¶ÁÖ¸¶¨Í¨µÀµÄÊý¾Ý.
+ * ²ÎÊý˵Ã÷£º
+ * (IN)
+ * buffer: ¶ÁÊý¾ÝµÄbufferÖ¸Õ룻
+ * size : ¶ÁÊý¾ÝµÄ´óС£»
+ * (OUT)
+ * ÎÞ
+ *·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ **************************************************************************/
+static VOID zOss_RamdumpIcpReadData(UINT8 *buffer, UINT32 size)
+{
+ T_ZDrvRpMsg_Msg icpMsg = {0};
+ UINT8 *pBuf = buffer;
+ SINT32 retCode = RPMSG_CHANNEL_NOMSG;
+
+ icpMsg.actorID = ICP_MSG_ACTOR_A9;
+ icpMsg.chID = RAMDUMP;
+ icpMsg.buf = buffer;
+ icpMsg.len = size;
+ icpMsg.flag |= RPMSG_READ_POLL;
+
+ do
+ {
+ retCode = zDrvRpMsg_ReadLockIrq(&icpMsg);
+ if(retCode != RPMSG_CHANNEL_NOMSG)
+ {
+ if( size <= icpMsg.len)
+ {
+ break;
+ }
+ pBuf = icpMsg.buf;
+ pBuf += icpMsg.len;
+ icpMsg.buf = pBuf;
+ size -= icpMsg.len;
+ icpMsg.len = size;
+ }
+ }while (size > 0);
+}
+
+/***************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpIcpWriteData
+ * ¹¦ÄÜÃèÊö£ºÐ´Êý¾Ýµ½Ö¸¶¨Í¨µÀ.
+ * ²ÎÊý˵Ã÷£º(IN):
+ * buffer: ¶ÁÊý¾ÝµÄbufferÖ¸Õ룻
+ * size : ¶ÁÊý¾ÝµÄ´óС£»
+ * (OUT):
+ * ÎÞ£»
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ****************************************************************************/
+static VOID zOss_RamdumpIcpWriteData(UINT8 *buffer, UINT32 size)
+{
+ T_ZDrvRpMsg_Msg icpMsg = {0};
+ SINT32 retCode = RPMSG_SPACE_NOT_ENOUGH;
+
+ icpMsg.actorID = ICP_MSG_ACTOR_A9;
+ icpMsg.chID = RAMDUMP;
+ icpMsg.buf = buffer;
+ icpMsg.len = ZOSS_RAMDUMP_ICP_DATA_SIZE(size);
+ icpMsg.flag |= RPMSG_WRITE_INT;
+
+ do
+ {
+ retCode = zDrvRpMsg_WriteLockIrq(&icpMsg);
+ if(retCode>0)
+ {
+ buffer += retCode;
+ size -= retCode;
+ icpMsg.buf = buffer;
+ icpMsg.len = ZOSS_RAMDUMP_ICP_DATA_SIZE(size);
+ }
+ }while ((retCode == RPMSG_SPACE_NOT_ENOUGH)||(size > 0));
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpIcpInit
+ * ¹¦ÄÜÃèÊö£ºramdump Icp ³õʼ»¯.
+ * ²ÎÊý˵Ã÷£º
+ * (IN)
+ * ÎÞ
+ * (OUT)
+ * ÎÞ
+ *·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ **************************************************************************/
+static VOID zOss_RamdumpIcpInit(VOID)
+{
+ SINT32 retCode = DRV_SUCCESS;
+ UINT8 pBuff[] = "ramdump";
+
+ retCode = zDrvRpMsg_CreateLockSaveChannel(ICP_MSG_ACTOR_A9, RAMDUMP, ZOSS_RAMDUMP_ICP_CHANNEL_SIZE);
+ zOss_ASSERT(retCode == DRV_SUCCESS);
+
+ /*ÏòͨµÀÖÐдÈëµÚÒ»°üÊý¾Ý±íʾÇëÇó½¨Á¢Í¨ÐÅ*/
+ zOss_RamdumpIcpWriteData(pBuff, strlen((const char *)pBuff));
+}
+
+/***************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpIcpFinish
+ * ¹¦ÄÜÃèÊö£ºRamdumpÎļþ´«Êä½áÊø£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ****************************************************************************/
+static VOID zOss_RamdumpIcpFinish(VOID)
+{
+
+}
+
+/***************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpSetIcpOpt
+ * ¹¦ÄÜÃèÊö£ºÉèÖÃICPͨµÀ;
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ****************************************************************************/
+VOID zOss_RamdumpSetIcpOpt(VOID)
+{
+ T_zOss_RamdumpIoOpt hook = {zOss_RamdumpIcpInit, zOss_RamdumpIcpReadData, zOss_RamdumpIcpWriteData, zOss_RamdumpIcpFinish};
+
+ zOss_RamdumpSetIoOpt(hook);
+ return;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_ramdump_cortexm.c b/cp/ps/plat/src/oss/sup/src/sup_ramdump_cortexm.c
new file mode 100644
index 0000000..690bab7
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_ramdump_cortexm.c
@@ -0,0 +1,100 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_ramdump_cortextm.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : Éú³ÉramdumpµÄarmv6-mÌåϵ½á¹¹µÄcmm½Å±¾Îļþ£»
+* ʵÏÖ¹¦ÄÜ :
+* ×÷ Õß : ÎâÕý¾ü
+* °æ ±¾ : 1.0
+* Íê³ÉÈÕÆÚ : 2013/07/19
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : ¸ß»ª·å
+* ÐÞ¸ÄÈÕÆÚ : 2012/10/10
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_ramdump.h"
+#include "tos_except_cortexm.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#define ZOSS_NORMAL_REG_NUM 13
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+struct cpu_core g_zRamdumpRegisters = {0};
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/*******************************************************************************
+ * º¯ÊýÃû³Æ£º zOss_RamdumpCreateCmmFile
+ * ¹¦ÄÜÃèÊö£º Éú³É»Ö¸´¶ÑÕ»µÄT32½Å±¾
+ * ²ÎÊý˵Ã÷£º (IN):
+ * pCmmFileInfo: cmm½Å±¾ÎļþÐÅÏ¢Ö¸Õ룻
+ * (OUT):ÎÞ
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ******************************************************************************/
+VOID zOss_RamdumpCreateCmmFile(T_zOss_RamdumpCmmFileInfo *pCmmFileInfo)
+{
+ CHAR *cmmAddress = NULL;
+ UINT32 i = 0;
+
+ cmmAddress = pCmmFileInfo->cmmFileBuffer;
+ cmmAddress += sprintf(cmmAddress, "ENTRY &%s\r\n", ZOSS_RAMDUMP_DIR_NAME);
+ cmmAddress += sprintf(cmmAddress, "r.s control %#lx\r\n", g_zRamdumpRegisters.control);
+ cmmAddress += sprintf(cmmAddress, "r.s pc %#lx\r\n", g_zRamdumpRegisters.lr);
+ cmmAddress += sprintf(cmmAddress, "r.s xpsr %#lx\r\n", g_zRamdumpRegisters.psr);
+ cmmAddress += sprintf(cmmAddress, "r.s primask %#lx\r\n", g_zRamdumpRegisters.primask);
+ cmmAddress += sprintf(cmmAddress, "r.s r13 %#lx\r\n", g_zRamdumpRegisters.sp);
+
+ for(i = 0; i < ZOSS_NORMAL_REG_NUM; i++)
+ {
+ cmmAddress += sprintf(cmmAddress, "r.s r%d %#lx\r\n", (int)i, g_zRamdumpRegisters.r[i]);
+ }
+
+ cmmAddress = zOss_RamdumpCreateRegionsCmmFile(cmmAddress);
+ cmmAddress += sprintf(cmmAddress, "ENDDO\r\n"); /*Êä³ö½áÊø·û*/
+ pCmmFileInfo->cmmFileSize = (UINT32)(cmmAddress - pCmmFileInfo->cmmFileBuffer);
+ zOss_AssertExN(pCmmFileInfo->cmmFileSize <= pCmmFileInfo->cmmFileMaxSize);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_ramdump_csky.c b/cp/ps/plat/src/oss/sup/src/sup_ramdump_csky.c
new file mode 100644
index 0000000..5a64081
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_ramdump_csky.c
@@ -0,0 +1,129 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_ramdump_csky.c
+* Ïà¹ØÎļþ : Éú³Éck610Ìåϵ½á¹¹µÄcmm½Å±¾Îļþ
+* ʵÏÖ¹¦ÄÜ :
+* ×÷ Õß : ÎâÕý¾ü
+* °æ ±¾ : 1.0
+* Íê³ÉÈÕÆÚ : 2013/07/19
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : ¸ß»ª·å
+* ÐÞ¸ÄÈÕÆÚ : 2012/10/10
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+#include "sup_ramdump.h"
+#ifdef _OS_TOS
+#include "tos_except_arm.h"
+#elif defined (_OS_LINUX)
+#include "linux_except_arm.h"
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#define ZRAMDUMP_REGS_TOTAL_CNT 80
+#define ZRAMDUMP_NORMAL_REGS_CNT 16
+#define ZRADMUMP_CTRL_REGS_CNT 22
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+tos_except_register_t *g_zEceptRegister = NULL;
+volatile UINT32 g_zRamdumpAdrress[ZRAMDUMP_REGS_TOTAL_CNT] = {0}; /* ±£´æ¼Ä´æÆ÷ÐÅÏ¢ */
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+ * º¯ÊýÃû³Æ£º zOss_RamdumpCreateCmmFile
+ * ¹¦ÄÜÃèÊö£º Éú³É»Ö¸´¶ÑÕ»µÄcds½Å±¾
+ * ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ * (OUT):ÎÞ
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ **************************************************************************/
+VOID zOss_RamdumpCreateCmmFile(T_zOss_RamdumpCmmFileInfo *pCmmFileInfo)
+{
+ UINT32 regIndex = 0;
+ CHAR *cmmAddress = pCmmFileInfo->cmmFileBuffer;
+ UINT32 i = 0;
+
+ g_zEceptRegister = tos_dump_except_register();
+ if (g_zEceptRegister != NULL)
+ {
+ zOss_Memcpy((VOID *)g_zRamdumpAdrress,g_zEceptRegister,sizeof(tos_except_register_t));
+ }
+
+ cmmAddress += sprintf(cmmAddress, "ENTRY &%s\r\n", ZOSS_RAMDUMP_DIR_NAME);
+ cmmAddress += sprintf(cmmAddress, "restore %s binary %#lx\r\n",RAM_NAME, (UINT32)_ram_start);
+
+ /* Êä³ö¿ØÖƼĴæÆ÷, g_zRamdumpAdrress µØÖ·Ç°Ãæ±£´æµÄÊÇr0-r15,ËùÒÔregIndexÊÇ´Ó16¿ªÊ¼µÄ */
+ regIndex = ZRAMDUMP_NORMAL_REGS_CNT;
+ if (g_zEceptRegister != NULL)
+ {
+ cmmAddress += sprintf(cmmAddress,"set $cr0 = %#lx\r\n", (int)g_zEceptRegister->epsr);
+ regIndex++;
+ }
+ else
+ {
+ cmmAddress += sprintf(cmmAddress, "set $cr0 = %#lx\r\n", g_zRamdumpAdrress[regIndex++]);
+ }
+
+ for (i = 1; i < ZRADMUMP_CTRL_REGS_CNT; i++)
+ {
+ if (i == ZRAMDUMP_NORMAL_REGS_CNT)
+ {
+ continue;
+ }
+ cmmAddress += sprintf(cmmAddress,"set $cr%d = %#lx\r\n", (int)i, g_zRamdumpAdrress[regIndex++]);
+ }
+ /* Êä³ör0-r15 */
+ regIndex = 0;
+ for (i = 0; i < ZRAMDUMP_NORMAL_REGS_CNT; i++)
+ {
+ cmmAddress += sprintf(cmmAddress, "set $r%d = %#lx\r\n", (int)i, g_zRamdumpAdrress[regIndex++]);
+ }
+ if (g_zEceptRegister != NULL)
+ {
+ cmmAddress += sprintf(cmmAddress, "set $pc = %#lx\r\n",(unsigned int)g_zEceptRegister->epc );
+ }
+ else
+ {
+ cmmAddress += sprintf(cmmAddress, "set $pc = %#lx\r\n", g_zRamdumpAdrress[--regIndex]);
+ }
+ pCmmFileInfo->cmmFileSize = (UINT32)(cmmAddress - pCmmFileInfo->cmmFileBuffer);
+ zOss_AssertExN(pCmmFileInfo->cmmFileSize <= pCmmFileInfo->cmmFileMaxSize);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/cp/ps/plat/src/oss/sup/src/sup_ramdump_server.c b/cp/ps/plat/src/oss/sup/src/sup_ramdump_server.c
new file mode 100644
index 0000000..6e5ac02
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_ramdump_server.c
@@ -0,0 +1,1408 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû :
+* ÎÄ ¼þ Ãû : sup_ramdump_server.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ :
+* ×÷ Õß : ÎâÕý¾ü
+* °æ ±¾ : 1.0
+* Íê³ÉÈÕÆÚ : 2013/07/19
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_ramdump.h"
+#include "sys_func_atcfg.h"
+#include "sys_com.h"
+#include "drvs_usbPoll.h"
+#include "ram_config.h"
+#include "drvs_icp.h"
+
+#if defined (_USE_ARM1_RAMDUMP) || defined (_USE_ZSP_RAMDUMP)
+#include "ps_ephy_interface.h"
+#include "drv_api.h"
+#endif
+
+#ifdef _OS_TOS
+#include <cyg/hal/tos_cache.h>
+#include <cyg/hal/tos_arm_mmu.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* Íⲿº¯ÊýºÍ±äÁ¿ÉùÃ÷Çø
+**************************************************************************/
+#ifdef __GNUC__
+# ifdef _OS_LINUX
+#define _ramdump_size 0x6000
+char _ramdump_array[_ramdump_size];
+#define _ramdump_start (_ramdump_array)
+# else
+extern char _ramdump_start[];
+extern char _ramdump_size[];
+# endif
+#elif defined (__ARMCC_VERSION)
+extern char Image$$RAMDUMP$$ZI$$Base[];
+extern char Image$$RAMDUMP$$ZI$$Limit[];
+
+#define _ramdump_start Image$$RAMDUMP$$ZI$$Base
+#define _ramdump_size (Image$$RAMDUMP$$ZI$$Limit - Image$$RAMDUMP$$ZI$$Base)
+#endif
+
+extern SINT32 zDrvIcp_ClearState(T_HalIcp_MsgActor actor, T_HalIcp_Dword bit_map);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+T_zOss_RamdumpOpt g_zRamdump_Optfunc = {NULL,NULL};
+T_zOss_RamdumpServerInfo g_zRamdump_ServerInfo = {0};
+
+#define ZRAMDUMP_SERVER_FILE "sup_ramdump_server.con"
+#define ZRAMDUMP_CLIENT_ICP_TABLE(srcModId,desModId,low_word,high_word)
+#define ZRAMDUMP_AGENT_ICP_TABLE(srcModId,desModId,low_word,high_word)
+#define ZRAMDUMP_SERVER_MEM_TABLE(identifier,pRamdumpStartAddr,ramdumpSize)
+#undef ZRAMDUMP_CLIENT_ICP_TABLE
+#define ZRAMDUMP_CLIENT_ICP_TABLE(srcModId,desModId,low_word,high_word) \
+ {(srcModId),(desModId),{low_word,high_word}},
+T_zOss_RamdumpIcpInfo g_zRamdump_ClientIcpInfo[] =
+{
+ #include ZRAMDUMP_SERVER_FILE
+};
+
+#undef ZRAMDUMP_CLIENT_ICP_TABLE
+#define ZRAMDUMP_CLIENT_ICP_TABLE(srcModId,desModId,low_word,high_word)
+#undef ZRAMDUMP_AGENT_ICP_TABLE
+#define ZRAMDUMP_AGENT_ICP_TABLE(srcModId,desModId,low_word,high_word) \
+ {(srcModId),(desModId),{low_word,high_word}},
+static T_zOss_RamdumpIcpInfo s_zRamdump_AgentIcpInfo[] =
+{
+ #include ZRAMDUMP_SERVER_FILE
+};
+
+#undef ZRAMDUMP_AGENT_ICP_TABLE
+#define ZRAMDUMP_AGENT_ICP_TABLE(srcModId,desModId,low_word,high_word)
+#undef ZRAMDUMP_SERVER_MEM_TABLE
+#define ZRAMDUMP_SERVER_MEM_TABLE(identifier,pRamdumpStartAddr,ramdumpSize) \
+ (UINT32)(identifier), (CHAR*)(pRamdumpStartAddr), \
+ (UINT32)(ramdumpSize)
+static T_zOss_RamdumpServerConInfo s_zRamdump_ServerCfgInfo =
+{
+ #include ZRAMDUMP_SERVER_FILE
+};
+#undef ZRAMDUMP_SERVER_MEM_TABLE
+#define ZRAMDUMP_SERVER_MEM_TABLE(identifier,pRamdumpStartAddr,ramdumpSize)
+static T_zOss_RamdumpClientInfo **s_zRamdump_ClientInfo = NULL;
+static T_zOss_RamdumpExceptInfo s_zRamdump_ExceptCore = {FALSE, 0};
+static BOOL s_zRamdump_InitFlag = FALSE;
+#ifdef _USE_ARM1_RAMDUMP
+static BOOL s_zRamdump_Arm1WaitFlag = FALSE;
+#endif
+
+static T_zOss_RamdumpIoOpt g_zRamdumpIoOpt;
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+/* io read/write buffer: [msg][data] */
+#define ZOSS_RAMDUMP_IO_DATA_BASE(addr) ((UINT32)addr + 4)
+#define ZOSS_RAMDUMP_ICP_CLIENT_SIZE 0X24
+#define ZOSS_RAMDUMP_ICP_AGENT_SIZE 0X24
+#define ZOSS_RAMDUMP_DELAYTIME_CNT 2500
+
+#ifdef _USE_ARM1_RAMDUMP
+#define ZOSS_RAMDUNP_PHY_INFO_BASE 0x24A60000
+#define ZOSS_RAMDUMP_PHY_COREDID 0XFF
+#define ZOSS_RAMDUMP_FLAG_ARM02ARM1_SIZE 4
+#define ZOSS_RAMDUMP_FLAG_ARM12ARM0_SIZE 4
+#define ZOSS_RAMDUMP_CMM_BUFFER_SIZE 4096
+#define ZOSS_RAMDUMP_CFG_REGIONS_SIZE 4096
+#define ZOSS_RAMDUMP_PARSED_REGIONS_SIZE 4096
+#define ZOSS_RAMDUMP_FILE_SIZE 2048
+#define ZOSS_RAMDUMP_ERROR_FILE_SIZE 1024
+#define ZOSS_RAMDUMP_ARM1_NAME "arm1_memory.bin"
+#define ZOSS_RAMDUMP_ARM1_CMM_INFO_BASE 0x24A60000
+#define ZOSS_RAMDUMP_CFG_REGION_BASE (ZOSS_RAMDUMP_ARM1_CMM_INFO_BASE + ZOSS_RAMDUMP_CMM_BUFFER_SIZE)
+#define ZOSS_RAMDUMP_ARM1_PARSED_REGION_BASE (ZOSS_RAMDUMP_CFG_REGION_BASE + ZOSS_RAMDUMP_CFG_REGIONS_SIZE)
+#define ZOSS_RADMUMP_ARM1_ERROR_FILE_BASE (ZOSS_RAMDUMP_ARM1_PARSED_REGION_BASE + ZOSS_RAMDUMP_PARSED_REGIONS_SIZE)
+#define ZOSS_RAMDUMP_ARM1_FLAG_ARM02ARM1_BASE (ZOSS_RADMUMP_ARM1_ERROR_FILE_BASE + ZOSS_RAMDUMP_ERROR_FILE_SIZE)
+#define ZOSS_RAMDUMP_ARM1_FLAG_ARM12ARM0_BASE (ZOSS_RAMDUMP_ARM1_FLAG_ARM02ARM1_BASE + ZOSS_RAMDUMP_FLAG_ARM02ARM1_SIZE)
+#define ZOSS_RAMDUMP_CMM_FILE_BUF_SIZE(addr) (*(UINT32 *)addr)
+#define ZOSS_RAMDUMP_CMM_FILE_BUF_BASE(addr) ((UINT32)addr + 4)
+#endif
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+static VOID ramdump_TransferData(VOID);
+static VOID ramdump_GetAvailableRegion(T_zOss_RamdumpRegion *pCfgInfo, T_zOss_RamdumpRegionInfo *pParsedInfo);
+static VOID ramdump_ParseRegionInfo(T_zOss_RamdumpRegionInfo *pCfgInfo, T_zOss_RamdumpRegionInfo *pParsedInfo);
+static VOID ramdump_SaveFileInfo(const CHAR *name, UINT32 baseServer, UINT32 size);
+static VOID ramdump_SaveRegionFileInfo(T_zOss_RamdumpRegionInfo *pRegionInfo, const CHAR *pFileName);
+static VOID ramdump_SaveAgentFileInfo(const CHAR *name, UINT32 baseServer, UINT32 size );
+static VOID ramdump_SaveAllFilesInfo(VOID);
+static VOID ramdump_Main(VOID);
+#if defined (_OS_TOS) && defined (CYGOPT_HAL_ARM_MMU)
+static VOID ramdump_GetConfigRegion(VOID);
+#endif
+static VOID ramdump_SetPartition(VOID);
+static VOID except_RecordExceptInfo(UINT32 exceptCoreID);
+static BOOL ramdump_delay(UINT32 ms, volatile UINT32 *addr, UINT32 flag);
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+#ifdef _USE_ARM1_RAMDUMP
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_CheckArm1InitFinish
+ * ¹¦ÄÜÃèÊö£ºÅжÏarm1³õʼ»¯ÊÇ·ñ³õʼ»¯Íê³É£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static BOOL ramdump_CheckArm1InitFinish(VOID)
+{
+ return (*(volatile UINT32 *)ZOSS_RAMDUMP_ARM1_FLAG_ARM12ARM0_BASE == 0);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ProcessMsgFromArm1
+ * ¹¦ÄÜÃèÊö£ºserver ´¦Àíarm1µÄICPÏûÏ¢º¯Êý
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ProcessMsgFromArm1(const T_HalIcp_Msg *pMsg)
+{
+ T_HalIcp_Dword state = { 0 };
+
+ zDrvIcp_GetState(ICP_MSG_ACTOR_ARM, &state);
+ zDrvIcp_ClearState(ICP_MSG_ACTOR_ARM, state);
+ except_RecordExceptInfo(ZOSS_RAMDUMP_PHY_COREDID);
+ sprintf((char *)g_zRamdump_ServerInfo.pErrInfo->pBuff, "%d_s_core: force error!\n", (int)s_zRamdump_ServerCfgInfo.serverId);
+#ifdef _OS_LINUX
+ linux_ramdump_entry();
+#else
+ zOss_RamdumpHandle(1, 1, 1);
+#endif
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_Arm1Init
+ * ¹¦ÄÜÃèÊö£ºarm1³õʼ»¯£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_Arm1Init(VOID)
+{
+ *(volatile UINT32 *)ZOSS_RAMDUMP_ARM1_FLAG_ARM02ARM1_BASE = 0;
+#ifdef _OS_TOS
+ TOS_CACHE_CLEAN_ALL();
+#endif
+ zDrvIcp_RegCallback(ICP_ARM0_MODULE_ID_OS, ICP_ARM1_MODULE_ID_OS, ramdump_ProcessMsgFromArm1, ICP_ISR_CALLBACK);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SendMsgToArm1
+ * ¹¦ÄÜÃèÊö£ºÏòarm1·¢ËÍICPÏûÏ¢£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SendMsgToArm1(UINT32 exceptType)
+{
+ T_HalIcp_Msg icpMsg = { 0 };
+
+ icpMsg.SrcModId = ICP_ARM0_MODULE_ID_OS;
+ icpMsg.desModId = ICP_ARM1_MODULE_ID_OS;
+ icpMsg.len = exceptType;
+ icpMsg.IntInfo.high_word = ZPLAT_PS2PHY_RAMDUMP_INT_ICP_CF;
+ zDrvIcp_SendMsg( (const T_HalIcp_Msg *)&icpMsg );
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_GetArm1AvailableRegion
+ * ¹¦ÄÜÃèÊö£º¶ÔĬÈÏÅäÖõÄÄÚ´æ¿éÊý¾ÝÓëMMU½âÎöµÄÄÚ´æ¿éÊý¾Ý¶Ô±È£¬
+ ±£´æ¿Éµ¼³öÀ´µÄÄÚ´æ¿é
+ * ²ÎÊý˵Ã÷£º(IN):
+ * pCfgInfo: ÅäÖõĵØÖ·ÐÅÏ¢Ö¸Õ룻
+ * pParsedInfo: ½âÎöºóµÄµØÖ·ÐÅÏ¢Ö¸Õ룻
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_GetArm1AvailableRegion(T_zOss_RamdumpArm1Region *pCfgInfo, T_zOss_RadmumpArm1RegionInfo *pParsedInfo)
+{
+ UINT32 i = 0;
+ T_zTos_MmuRamdumpTable mmuTable = { 0 };
+ T_zOss_RamdumpArm1Region *pParseRegion = &(pParsedInfo->regions[0]);
+
+ if (zTos_MmuGetMappingRegion(pCfgInfo->startAddr, (pCfgInfo->endAddr - pCfgInfo->startAddr + 1), &mmuTable))
+ {
+ for (i= 0; i < mmuTable.count; i++, pParsedInfo->regionNum++)
+ {
+ pParseRegion[pParsedInfo->regionNum].startAddr = mmuTable.item[i].virBase;
+ pParseRegion[pParsedInfo->regionNum].mapAddr = pCfgInfo->startAddr != pCfgInfo->mapAddr ?
+ (pCfgInfo->mapAddr + mmuTable.item[i].phyBase - pCfgInfo->startAddr) : mmuTable.item[i].virBase;
+ pParseRegion[pParsedInfo->regionNum].copyAddr = pCfgInfo->copyAddr != 0 ? (pCfgInfo->copyAddr + mmuTable.item[i].phyBase - pCfgInfo->startAddr) : 0;
+ pParseRegion[pParsedInfo->regionNum].endAddr = mmuTable.item[i].virBase + mmuTable.item[i].size - 1;
+ }
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ParseArm1RegionInfo
+ * ¹¦ÄÜÃèÊö£º½âÎöÄÚ´æ¿éÎļþÊý¾Ý
+ * ²ÎÊý˵Ã÷£º(IN):
+ * pCfgInfo: ÅäÖÃÇøÓòÊý¾ÝÐÅÏ¢Ö¸Õ룻
+ * pParsedInfo: ½âÎöÇøÓòÊý¾ÝÐÅÏ¢Ö¸Õ룻
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ParseArm1RegionInfo(T_zOss_RadmumpArm1RegionInfo *pCfgInfo, T_zOss_RadmumpArm1RegionInfo *pParsedInfo)
+{
+ UINT32 i = 0;
+
+ for (i = 0; i < pCfgInfo->regionNum; i++)
+ {
+ ramdump_GetArm1AvailableRegion(&(pCfgInfo->regions[i]), pParsedInfo);
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SaveArm1RegionFileInfo
+ * ¹¦ÄÜÃèÊö£º±£´æarm1 RegionÎļþÐÅÏ¢£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * pRegionInfo: ½âÎöºóµÄÊý¾Ý¶ÎµÄÖ¸Õ룻
+ * pFileName : ÎļþÃû×Ö£»
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SaveArm1RegionFileInfo(T_zOss_RadmumpArm1RegionInfo *pRegionInfo, const CHAR *pFileName)
+{
+ UINT32 i = 0;
+ CHAR name[ZOSS_RAMDUMP_FILENAME_LEN] = {0};
+ T_zOss_RamdumpRegion serverRegion = { 0 };
+
+ for (i = 0; i < pRegionInfo->regionNum; i++)
+ {
+ serverRegion.baseForServer = pRegionInfo->regions[i].startAddr;
+ serverRegion.baseForSelf = pRegionInfo->regions[i].mapAddr;
+ serverRegion.baseForCopy = pRegionInfo->regions[i].copyAddr;
+ serverRegion.size = pRegionInfo->regions[i].endAddr - pRegionInfo->regions[i].startAddr + 1;
+ sprintf(name, "%s_%d", pFileName, (int)i);
+ ramdump_SaveFileInfo(name, serverRegion.baseForServer, serverRegion.size);
+ ramdump_SaveAgentFileInfo(name, serverRegion.baseForServer, serverRegion.size);
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SaveArm1FilesInfo
+ * ¹¦ÄÜÃèÊö£º±£´æarm1 ÎļþÐÅÏ¢£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SaveArm1FilesInfo(VOID)
+{
+ if (s_zRamdump_Arm1WaitFlag)
+ {
+ ramdump_SaveArm1RegionFileInfo((T_zOss_RadmumpArm1RegionInfo *)ZOSS_RAMDUMP_ARM1_PARSED_REGION_BASE, ZOSS_RAMDUMP_ARM1_NAME);
+ ramdump_SaveFileInfo("arm1_targetstate.cmm", ZOSS_RAMDUMP_CMM_FILE_BUF_BASE(ZOSS_RAMDUMP_ARM1_CMM_INFO_BASE),
+ ZOSS_RAMDUMP_CMM_FILE_BUF_SIZE(ZOSS_RAMDUMP_ARM1_CMM_INFO_BASE));
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ProcessArm1Exception
+ * ¹¦ÄÜÃèÊö£º´¦ÀíArm1Òì³££»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ProcessArm1Exception(VOID)
+{
+ if (ramdump_CheckArm1InitFinish())
+ {
+ UINT32 delayTimeLen = 1000; /* ʱ¼ä´óÔ¼ÔÚ1s×óÓÒ*/
+ ramdump_ParseArm1RegionInfo((T_zOss_RadmumpArm1RegionInfo *)ZOSS_RAMDUMP_CFG_REGION_BASE, (T_zOss_RadmumpArm1RegionInfo *)ZOSS_RAMDUMP_ARM1_PARSED_REGION_BASE);
+ *(volatile UINT32 *)ZOSS_RAMDUMP_ARM1_FLAG_ARM02ARM1_BASE = ZOSS_RAMDUMP_FLAG_SECOND_VALUE;
+#ifdef _OS_TOS
+ TOS_CACHE_CLEAN_ALL();
+#endif
+ s_zRamdump_Arm1WaitFlag = ramdump_delay(delayTimeLen, (UINT32 *)ZOSS_RAMDUMP_ARM1_FLAG_ARM12ARM0_BASE, ZOSS_RAMDUMP_FLAG_SECOND_VALUE);
+ }
+}
+
+#endif
+
+#ifdef _USE_ZSP_RAMDUMP
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ZspRegionCfg
+ * ¹¦ÄÜÃèÊö£ºzsp µ¼³öÇøÓòÅäÖã»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ZspRegionCfg(VOID)
+{
+ T_ZDrvSys_PowerOn_Type powOnType;
+
+ powOnType = zDrvComm_GetPowerOnState();
+ if(POWER_ON_FOTA == powOnType || POWER_ON_CHARGING == powOnType)
+ return;
+
+ ramdump_SaveFileInfo("DTCM.bin", RAMDUMP_ZSP_DTCM_BASE, RAMDUMP_ZSP_DTCM_SIZE);
+ ramdump_SaveFileInfo("DDDR.bin", RAMDUMP_ZSP_DDDR_BASE, RAMDUMP_ZSP_DDDR_SIZE);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SendMsgToZsp
+ * ¹¦ÄÜÃèÊö£ºÏòzsp·¢ËÍICPÏûÏ¢£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º ·¢ËÍicpÏûÏ¢£¬Í¨Öªzsp²»ÒªÐÝÃߣ¬ÒÔ·À˯ÃßzspʱµÄÄÚ´æ²»ÄÜ·ÃÎÊ£»
+**************************************************************************/
+static VOID ramdump_SendMsgToZsp(VOID)
+{
+ T_HalIcp_Msg icpMsg = { 0 };
+
+ icpMsg.SrcModId = ICP_ARM0_MODULE_ID_OS;
+ icpMsg.desModId = ICP_ARM1_MODULE_ID_OS;
+ // icpMsg.len = exceptType;
+ icpMsg.IntInfo.high_word = ZPLAT_PS2PHY_RAMDUMP_INT_ICP_CF;
+ zDrvIcp_SendMsg((const T_HalIcp_Msg *)&icpMsg);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ProcessMsgFromZsp
+ * ¹¦ÄÜÃèÊö£ºserver ´¦ÀízspµÄICPÏûÏ¢º¯Êý
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ProcessMsgFromZsp(const T_HalIcp_Msg *pMsg)
+{
+ T_HalIcp_Dword state = { 0 };
+
+ zDrvIcp_GetState(ICP_MSG_ACTOR_ARM, &state);
+ zDrvIcp_ClearState(ICP_MSG_ACTOR_ARM, state);
+ sprintf((char *)g_zRamdump_ServerInfo.pErrInfo->pBuff, "zsp: exact error!\n");
+#ifdef _OS_LINUX
+ linux_ramdump_entry();
+#else
+ zOss_RamdumpHandle(1, 1, 1);
+#endif
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ZspInit
+ * ¹¦ÄÜÃèÊö£ºzsp³õʼ»¯£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ZspInit(VOID)
+{
+ zDrvIcp_RegCallback(ICP_ARM0_MODULE_ID_OS, ICP_ARM1_MODULE_ID_OS, ramdump_ProcessMsgFromZsp, ICP_ISR_CALLBACK);
+}
+
+#endif
+
+/******************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_TransferData
+ * ¹¦ÄÜÃèÊö£ºÓëPC²à¹¤¾ß½øÐн»»¥£¬´«µÝÐèÒª±£´æµÄÊý¾Ý
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ *******************************************************************************/
+static VOID ramdump_TransferData(VOID)
+{
+ UINT32 rspDataLen = 0;
+ CHAR *reqBuffer = (CHAR *)g_zRamdump_ServerInfo.pIoReadbuf->pBuff;
+ CHAR *rspBuffer = (CHAR *)g_zRamdump_ServerInfo.pIoWritebuf->pBuff;
+ UINT32 *reqCmd = (UINT32 *)reqBuffer;
+ UINT32 *rspCmd = (UINT32 *)rspBuffer;
+ T_zOss_RamdumpFile *fileInfo = g_zRamdump_ServerInfo.pFileInfo->fileInfo;
+
+ g_zRamdumpIoOpt.init();
+
+ for(;;)
+ {
+ g_zRamdumpIoOpt.read((UINT8 *)reqBuffer, ZOSS_RAMDUMP_CMD_BUFFER_LEN);
+ switch (*reqCmd)
+ {
+ case ZOSS_RAMDUMP_FILE_LINK_REQ: /* ͬ²½ÇëÇó */
+ {
+ T_zOss_RamumpFileLinkRsp *rspMsg = (T_zOss_RamumpFileLinkRsp *)ZOSS_RAMDUMP_IO_DATA_BASE(rspBuffer);
+ *rspCmd = ZOSS_RAMDUMP_FILE_LINK_RSP;
+
+ rspMsg->fileNum = g_zRamdump_ServerInfo.pFileInfo->fileNum;
+ rspDataLen = sizeof(*rspCmd) + sizeof(T_zOss_RamumpFileLinkRsp);
+ break;
+ }
+ case ZOSS_RAMDUMP_FILE_FILE_REQ: /* ¶ÁÈ¡ÎļþÐÅÏ¢£¬¿ªÊ¼´«ÊäÎļþÇëÇó */
+ {
+ T_zOss_RamdumpFileFileReq *reqMsg = (T_zOss_RamdumpFileFileReq *)ZOSS_RAMDUMP_IO_DATA_BASE(reqBuffer);
+ T_zOss_RamdumpFileFileRsp *rspMsg = (T_zOss_RamdumpFileFileRsp *)ZOSS_RAMDUMP_IO_DATA_BASE(rspBuffer);
+
+ zOss_AssertExN(reqMsg->fileNo < g_zRamdump_ServerInfo.pFileInfo->fileNum);
+ *rspCmd = ZOSS_RAMDUMP_FILE_FILE_RSP;
+ strcpy((char *)rspMsg->fileName, (char *)fileInfo[reqMsg->fileNo].fileName);
+ rspMsg->size = fileInfo[reqMsg->fileNo].size;
+ rspDataLen = sizeof(*rspCmd) + sizeof(T_zOss_RamdumpFileFileRsp);
+ break;
+ }
+ case ZOSS_RAMDUMP_FILE_READ_REQ: /* ¶ÁÈ¡ÎļþÄÚÈÝ */
+ {
+ T_zOss_RamdumpFileReadReq *reqMsg = (T_zOss_RamdumpFileReadReq *)ZOSS_RAMDUMP_IO_DATA_BASE(reqBuffer);
+ *rspCmd = ZOSS_RAMDUMP_FILE_READ_RSP;
+
+ zOss_AssertExN(reqMsg->fileNo <= g_zRamdump_ServerInfo.pFileInfo->fileNum);
+ zOss_AssertExN(reqMsg->offset + reqMsg->length <= fileInfo[reqMsg->fileNo].size);
+ g_zRamdumpIoOpt.write((UINT8 *)rspBuffer, sizeof(*rspCmd));
+ g_zRamdumpIoOpt.write((UINT8 *)(fileInfo[reqMsg->fileNo].baseforServer + reqMsg->offset), reqMsg->length);
+ continue; /* ¼ÌÐøÖ´ÐÐÏÂÒ»´Î¶Á */
+ }
+ case ZOSS_RAMDUMP_FILE_END_REQ: /* ´«Êä½áÊø */
+ {
+ *rspCmd = ZOSS_RAMDUMP_FILE_END_RSP;
+ g_zRamdumpIoOpt.write((UINT8 *)rspBuffer, sizeof(*rspCmd));
+ g_zRamdumpIoOpt.finish();
+ return;
+ }
+ default: /* ´íÎóÖ¸Áî */
+ {
+ *rspCmd = ZOSS_RAMDUMP_FILE_CMD_FAIL;
+ rspDataLen = sizeof(*rspCmd);
+ break;
+ }
+ }
+ zOss_AssertExN(rspDataLen < g_zRamdump_ServerInfo.pIoWritebuf->buffLen);
+ g_zRamdumpIoOpt.write((UINT8 *)rspBuffer, rspDataLen);
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_get_available_region
+ * ¹¦ÄÜÃèÊö£º¶ÔĬÈÏÅäÖõÄÄÚ´æ¿éÊý¾ÝÓëMMU½âÎöµÄÄÚ´æ¿éÊý¾Ý¶Ô±È£¬
+ ±£´æ¿Éµ¼³öÀ´µÄÄÚ´æ¿é
+ * ²ÎÊý˵Ã÷£º(IN):
+ * pCfgInfo: ÅäÖõĵØÖ·ÐÅÏ¢Ö¸Õ룻
+ * pParsedInfo: ½âÎöºóµÄµØÖ·ÐÅÏ¢Ö¸Õ룻
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+#if defined (_OS_TOS) && defined (CYGOPT_HAL_ARM_MMU)
+static VOID ramdump_GetAvailableRegion(T_zOss_RamdumpRegion *pCfgInfo, T_zOss_RamdumpRegionInfo *pParsedInfo)
+{
+ UINT32 i = 0;
+ T_zTos_MmuRamdumpTable mmuTable = { 0 };
+ T_zOss_RamdumpRegion *pParseRegion = &(pParsedInfo->regions[0]);
+
+ if (zTos_MmuGetMappingRegion(pCfgInfo->baseForServer, pCfgInfo->size, &mmuTable))
+ {
+ zOss_AssertExN((pParsedInfo->regionMaxNum - pParsedInfo->regionNum) >= mmuTable.count);
+ for (i= 0; i < mmuTable.count; i++, pParsedInfo->regionNum++)
+ {
+ pParseRegion[pParsedInfo->regionNum].baseForServer = mmuTable.item[i].virBase;
+ pParseRegion[pParsedInfo->regionNum].baseForSelf = pCfgInfo->baseForServer != pCfgInfo->baseForSelf ?
+ (pCfgInfo->baseForSelf + mmuTable.item[i].phyBase - pCfgInfo->baseForServer) : mmuTable.item[i].virBase;
+ pParseRegion[pParsedInfo->regionNum].baseForCopy = pCfgInfo->baseForCopy != 0 ? (pCfgInfo->baseForCopy + mmuTable.item[i].phyBase - pCfgInfo->baseForServer) : 0;
+ pParseRegion[pParsedInfo->regionNum].size = mmuTable.item[i].size;
+ }
+ }
+}
+#else
+static VOID ramdump_GetAvailableRegion(T_zOss_RamdumpRegion *pCfgInfo, T_zOss_RamdumpRegionInfo *pParsedInfo)
+{
+ T_zOss_RamdumpRegion *pParseRegion = &(pParsedInfo->regions[0]);
+
+ pParseRegion[pParsedInfo->regionNum].baseForServer = pCfgInfo->baseForServer;
+ pParseRegion[pParsedInfo->regionNum].baseForSelf = pCfgInfo->baseForSelf;
+ pParseRegion[pParsedInfo->regionNum].baseForCopy = pCfgInfo->baseForCopy;
+ pParseRegion[pParsedInfo->regionNum].size = pCfgInfo->size;
+ pParsedInfo->regionNum++;
+}
+#endif
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ParseRegioInfo
+ * ¹¦ÄÜÃèÊö£º½âÎöÄÚ´æ¿éÎļþÊý¾Ý
+ * ²ÎÊý˵Ã÷£º(IN):
+ * pCfgInfo: ÅäÖÃÇøÓòÊý¾ÝÐÅÏ¢Ö¸Õ룻
+ * pParsedInfo: ½âÎöÇøÓòÊý¾ÝÐÅÏ¢Ö¸Õ룻
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ParseRegionInfo(T_zOss_RamdumpRegionInfo *pCfgInfo, T_zOss_RamdumpRegionInfo *pParsedInfo)
+{
+ UINT32 i = 0;
+
+ for (i = 0; i < pCfgInfo->regionNum; i++)
+ {
+ ramdump_GetAvailableRegion(&(pCfgInfo->regions[i]), pParsedInfo);
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SaveAgentFileInfo
+ * ¹¦ÄÜÃèÊö£º½«ÎļþÐÅÏ¢±£´æÖÁ¸ß¶ÎÄÚ´æ,ÓÃÓÚºÍAGENT½øÐÐͨÐÅ£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * name: ÎļþÃû×Ö£»
+ * baseServer:µØÖ·£»
+ * size: Êý¾Ý´óС£»
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SaveAgentFileInfo(const CHAR *name, UINT32 baseServer, UINT32 size )
+{
+ T_zOss_RamdumpFile *pFileInfo = g_zRamdump_ServerInfo.pAgentFileInfo->fileInfo + g_zRamdump_ServerInfo.pAgentFileInfo->fileNum;
+
+ strcpy((char *)pFileInfo->fileName, name);
+#ifdef _OS_TOS
+# ifdef CYGOPT_HAL_ARM_MMU
+ zTos_MmuGetPaddrByVaddr(baseServer,(cyg_uint32 *)&(pFileInfo->baseforServer));
+# elif defined (CYGOPT_HAL_ARM_MPU)
+ pFileInfo->baseforServer = baseServer;
+# endif
+#elif defined (_OS_LINUX)
+# ifdef CONFIG_MMU
+ /* FIXME */
+# else
+ pFileInfo->baseforServer = baseServer;
+# endif
+#endif
+ pFileInfo->size = size;
+ g_zRamdump_ServerInfo.pAgentFileInfo->fileNum++;
+ zOss_AssertExN(g_zRamdump_ServerInfo.pAgentFileInfo->fileNum < g_zRamdump_ServerInfo.pAgentFileInfo->fileMaxNum);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SaveFileInfo
+ * ¹¦ÄÜÃèÊö£º½«ÎļþÐÅÏ¢±£´æÖÁ¸ß¶ÎÄÚ´æ
+ * ²ÎÊý˵Ã÷£º(IN):
+ * name: Ãû×Ö£»
+ * baseServer: µØÖ·£»
+ * size: Êý¾Ý´óС£»
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SaveFileInfo(const CHAR *name, UINT32 baseServer, UINT32 size )
+{
+ T_zOss_RamdumpFile *pFileInfo = g_zRamdump_ServerInfo.pFileInfo->fileInfo + g_zRamdump_ServerInfo.pFileInfo->fileNum;
+
+ strcpy((char *)pFileInfo->fileName, name);
+ pFileInfo->baseforServer = baseServer;
+ pFileInfo->size = size;
+ g_zRamdump_ServerInfo.pFileInfo->fileNum++;
+ zOss_AssertExN(g_zRamdump_ServerInfo.pFileInfo->fileNum < g_zRamdump_ServerInfo.pFileInfo->fileMaxNum);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SaveRegionFileInfo
+ * ¹¦ÄÜÃèÊö£ºÕûÀíÄÚ´æ¿éµ¼³öÎļþÊý¾Ý
+ * ²ÎÊý˵Ã÷£º(IN):
+ * p_region_info: ½âÎöºóµÄÊý¾Ý¶ÎµÄÖ¸Õ룻
+ * file_name : ÎļþÃû×Ö£»
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SaveRegionFileInfo(T_zOss_RamdumpRegionInfo *pRegionInfo, const CHAR *pFileName)
+{
+ UINT32 i = 0;
+ CHAR name[ZOSS_RAMDUMP_FILENAME_LEN] = {0};
+
+ for (i = 0; i < pRegionInfo->regionNum; i++)
+ {
+ sprintf(name, "%d_%s", (int)i, pFileName);
+ ramdump_SaveFileInfo(name, pRegionInfo->regions[i].baseForServer, pRegionInfo->regions[i].size);
+ ramdump_SaveAgentFileInfo(name, pRegionInfo->regions[i].baseForServer, pRegionInfo->regions[i].size);
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SaveServerFilesInfo
+ * ¹¦ÄÜÃèÊö£º±£´æserverµ¼³öÎļþÊý¾Ý
+ * ²ÎÊý˵Ã÷£º (IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SaveServerFilesInfo(VOID)
+{
+ CHAR binName[ZOSS_RAMDUMP_FILENAME_LEN] = {0};
+ CHAR cmmName[ZOSS_RAMDUMP_FILENAME_LEN] = {0};
+ T_zOss_RamdumpCmmFileInfo *pCmmInfo = g_zRamdump_ServerInfo.pCmmInfo;
+
+ sprintf(binName, "%d_s_mem.bin", (int)s_zRamdump_ServerCfgInfo.serverId);
+ ramdump_SaveRegionFileInfo(g_zRamdump_ServerInfo.pParsedInfo, binName);
+ sprintf(cmmName, "%d_s_targetstate.cmm", (int)s_zRamdump_ServerCfgInfo.serverId);
+ ramdump_SaveFileInfo(cmmName, (UINT32)pCmmInfo->cmmFileBuffer, pCmmInfo->cmmFileSize);
+ ramdump_SaveAgentFileInfo(cmmName, (UINT32)pCmmInfo->cmmFileBuffer, pCmmInfo->cmmFileSize);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SaveClientFilesInfo
+ * ¹¦ÄÜÃèÊö£º±£´æclientµ¼³öÎļþÊý¾Ý
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SaveClientFilesInfo(VOID)
+{
+ CHAR binName[ZOSS_RAMDUMP_FILENAME_LEN] = {0};
+ CHAR cmmName[ZOSS_RAMDUMP_FILENAME_LEN] = {0};
+ UINT32 cnt = 0;
+
+ for (cnt = 0; cnt < sizeof(g_zRamdump_ClientIcpInfo)/sizeof(T_zOss_RamdumpIcpInfo); cnt++)
+ {
+ if ((s_zRamdump_ClientInfo[cnt] != NULL) && g_zRamdump_ServerInfo.pWaitMsgFlag[cnt])
+ {
+ T_zOss_RamdumpCmmFileInfo *pCmmInfo = s_zRamdump_ClientInfo[cnt]->pCmmInfo;
+
+ sprintf(binName, "%d_c_mem.bin", (int)s_zRamdump_ClientInfo[cnt]->clientId);
+ ramdump_SaveRegionFileInfo(s_zRamdump_ClientInfo[cnt]->pParsedInfo, binName);
+ sprintf(cmmName, "%d_c_targetstate.cmm",(int)s_zRamdump_ClientInfo[cnt]->clientId);
+ ramdump_SaveFileInfo(cmmName, (UINT32)pCmmInfo->cmmFileBuffer, pCmmInfo->cmmFileSize);
+ ramdump_SaveAgentFileInfo(cmmName, (UINT32)pCmmInfo->cmmFileBuffer, pCmmInfo->cmmFileSize);
+ }
+ }
+
+#ifdef _USE_ARM1_RAMDUMP
+ ramdump_SaveArm1FilesInfo();
+#endif
+
+#ifdef _USE_ZSP_RAMDUMP
+ ramdump_ZspRegionCfg();
+#endif
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SaveErrorFileInfo
+ * ¹¦ÄÜÃèÊö£º±£´æ´íÎóÐÅÏ¢ÎļþÊý¾Ý
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SaveErrorFileInfo(VOID)
+{
+ T_zOss_RamdumpBuffInfo *pErrInfo = g_zRamdump_ServerInfo.pErrInfo;
+ UINT32 cnt = 0;
+ UINT32 len = 0;
+ UINT32 errLogLen = strlen((const char *)pErrInfo->pBuff);
+
+ for (cnt = 0; cnt < sizeof(g_zRamdump_ClientIcpInfo)/sizeof(T_zOss_RamdumpIcpInfo); cnt++)
+ {
+ if ((s_zRamdump_ClientInfo[cnt] != NULL) && g_zRamdump_ServerInfo.pWaitMsgFlag[cnt])
+ {
+ len = errLogLen;
+ errLogLen += strlen(s_zRamdump_ClientInfo[cnt]->pErrInfo->pBuff);
+ zOss_AssertExN(errLogLen < pErrInfo->buffLen);
+ strcpy((char *)(pErrInfo->pBuff+ len), (char *)s_zRamdump_ClientInfo[cnt]->pErrInfo->pBuff);
+ }
+ }
+
+#ifdef _USE_ARM1_RAMDUMP
+ if (s_zRamdump_Arm1WaitFlag)
+ {
+ len = errLogLen;
+ errLogLen += strlen((char *)ZOSS_RADMUMP_ARM1_ERROR_FILE_BASE);
+ zOss_AssertExN(errLogLen < pErrInfo->buffLen);
+ strcpy((char *)(pErrInfo->pBuff+ len), (char *)ZOSS_RADMUMP_ARM1_ERROR_FILE_BASE);
+ }
+#endif
+
+ ramdump_SaveFileInfo("err_log.txt", (UINT32)pErrInfo->pBuff, errLogLen);
+ ramdump_SaveAgentFileInfo("err_log.txt", (UINT32)pErrInfo->pBuff, errLogLen);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SaveAllFilesInfo
+ * ¹¦ÄÜÃèÊö£ºÕûÀíµ¼³öÎļþÊý¾Ý
+ * ²ÎÊý˵Ã÷£º (IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SaveAllFilesInfo(VOID)
+{
+ ramdump_SaveServerFilesInfo();
+ ramdump_SaveClientFilesInfo();
+ ramdump_SaveErrorFileInfo();
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ServerSendMsg
+ * ¹¦ÄÜÃèÊö£ººË¼äͨѶÏûÏ¢·¢ËͽӿÚ
+ * ²ÎÊý˵Ã÷£º(IN):
+ * pIcpInfo: ICPÐÅÏ¢Ö¸Õ룻
+ * pMsgInfo: ÏûÏ¢Ö¸Õ룻
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ServerSendMsg(T_zOss_RamdumpIcpInfo *pIcpInfo ,T_zOss_RamdumpServerMsgInfo *pMsgInfo)
+{
+ T_HalIcp_Msg icpMsg;
+ icpMsg.SrcModId = pIcpInfo->srcModId;
+ icpMsg.desModId = pIcpInfo->desModId;
+ icpMsg.IntInfo.high_word = pIcpInfo->intInfo.high_word;
+ icpMsg.pBuf = pMsgInfo;
+ icpMsg.len = sizeof(T_zOss_RamdumpServerMsgInfo);
+ zDrvIcp_SendMsg((const T_HalIcp_Msg *)&icpMsg);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºexcept_RecordExceptInfo
+ * ¹¦ÄÜÃèÊö£º¼Ç¼Òì³£ÐÅÏ¢£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * exceptCore: Òì³£ºËID
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID except_RecordExceptInfo(UINT32 exceptCoreID)
+{
+ if(!s_zRamdump_ExceptCore.exceptFlag)
+ {
+ s_zRamdump_ExceptCore.exceptFlag = TRUE;
+ s_zRamdump_ExceptCore.exceptCore = exceptCoreID;
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ServerProcessClientMsg
+ * ¹¦ÄÜÃèÊö£ººË¼äͨѶclientÏûÏ¢´¦Àí½Ó¿Ú
+ * ²ÎÊý˵Ã÷£º(IN):
+ * pBuff: ÏûÏ¢buffÖ¸Õ룻
+ * len : ÏûÏ¢´óС£»
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ServerProcessClientMsg(const T_HalIcp_Msg *pMsg)
+{
+ UINT32 cnt = 0;
+ T_zOss_RamdumpClientMsgInfo *ramdumpMsg = (T_zOss_RamdumpClientMsgInfo *)pMsg->pBuf;
+
+ switch(ramdumpMsg->msgType)
+ {
+ case ZOSS_RAMDUMP_INIT_TYPE:
+ {
+ for (cnt = 0; cnt < sizeof(g_zRamdump_ClientIcpInfo)/sizeof(T_zOss_RamdumpIcpInfo); cnt++)
+ {
+ if (ramdumpMsg->srcModId == g_zRamdump_ClientIcpInfo[cnt].srcModId)
+ s_zRamdump_ClientInfo[cnt] = (T_zOss_RamdumpClientInfo *)ramdumpMsg->pRamdumpStartAddr;
+ }
+ break;
+ }
+ case ZOSS_RAMDUMP_EXCPT_TYPE:
+ {
+ except_RecordExceptInfo(ramdumpMsg->srcModId);
+ sprintf((char *)g_zRamdump_ServerInfo.pErrInfo->pBuff, "%d_s_core: force error!\n", (int)s_zRamdump_ServerCfgInfo.serverId);
+ zOss_RamdumpHandle(1, 1, 1);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ServerProcessAgentMsg
+ * ¹¦ÄÜÃèÊö£ººË¼äͨѶagentÏûÏ¢´¦Àí½Ó¿Ú
+ * ²ÎÊý˵Ã÷£º(IN):
+ * pBuff: ÏûÏ¢bufferÖ¸Õ룻
+ * len : ÏûÏ¢´óС£»
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ServerProcessAgentMsg(const T_HalIcp_Msg *pMsg)
+{
+ T_zOss_RamdumpAgentMsgInfo *ramdumpMsg = (T_zOss_RamdumpAgentMsgInfo *)pMsg->pBuf;
+
+ switch(ramdumpMsg->msgType)
+ {
+
+ default:
+ {
+ break;
+ }
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_delay
+ * ¹¦ÄÜÃèÊö£º³¬Ê±µÈ´ýÅж϶àºËramdumpµÄͬ²½±êÖ¾£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * ms : 550MhzÖ÷Ƶϵ¥Î»ÊÇ1ms
+ * addr: µØÖ·
+ * falg: µÈ´ý±êÖ¾
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static BOOL ramdump_delay(UINT32 ms, volatile UINT32 *addr, UINT32 flag)
+{
+ UINT32 i, j;
+
+ for (j = 0; j < ZOSS_RAMDUMP_DELAYTIME_CNT; j++)
+ {
+ for (i = 0; i < ms; i++)
+ {
+ if (*addr == flag)
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_GetConfigRegion
+ * ¹¦ÄÜÃèÊö£º»ñÈ¡radmumpÒªµ¼³öµÄÇøÓò£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+#if defined (_OS_TOS) && defined (CYGOPT_HAL_ARM_MMU)
+static VOID ramdump_GetConfigRegion(VOID)
+{
+ T_zOss_RamdumpRegion regionInfo = {0};
+ UINT32 cnt = 0;
+ T_zTos_MmuConfigItem *pItem = NULL;
+
+ for (cnt = 0; cnt < g_zTos_MmuConfigTable.count; cnt++)
+ {
+ pItem = &g_zTos_MmuConfigTable.item[cnt];
+ if (pItem->attr & ZTOS_MMU_REGION_DUMP)
+ {
+ regionInfo.baseForServer = pItem->server_base;
+ regionInfo.baseForSelf = pItem->physical_base;
+ regionInfo.size = pItem->size;
+ regionInfo.baseForCopy = (pItem->attr & ZTOS_MMU_REGION_COPY) ? pItem->server_base : 0;
+ zOss_RamdumpConfigureMem(®ionInfo);
+ }
+ }
+}
+#endif
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_SetPartition
+ * ¹¦ÄÜÃèÊö£ºramdump¿Õ¼ä»®·Ö£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_SetPartition(VOID)
+{
+ UINT32 size = 0;
+ UINT32 sizeUnit = s_zRamdump_ServerCfgInfo.ramdumpSize/ZOSS_RAMDUMP_SERVER_TOTAL_RATE;
+
+ g_zRamdump_ServerInfo.pCmmInfo = (T_zOss_RamdumpCmmFileInfo *)(((UINT32)s_zRamdump_ServerCfgInfo.pRamdumpStartAddr + sizeof(UINT32) - 1) & ~(sizeof(UINT32) - 1));
+ g_zRamdump_ServerInfo.pCmmInfo->cmmFileSize = 0;
+ size = (sizeUnit * ZOSS_RAMDUMP_CMM_INFO_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ServerInfo.pCmmInfo->cmmFileMaxSize = size - sizeof(T_zOss_RamdumpCmmFileInfo);
+
+ g_zRamdump_ServerInfo.pConfigureInfo = (T_zOss_RamdumpRegionInfo *)((CHAR*)g_zRamdump_ServerInfo.pCmmInfo + size);
+ g_zRamdump_ServerInfo.pConfigureInfo->regionNum = 0;
+ size = (sizeUnit * ZOSS_RAMDUMP_CONFIGURED_REGION_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ServerInfo.pConfigureInfo->regionMaxNum = (size - sizeof(T_zOss_RamdumpRegionInfo)) / sizeof(T_zOss_RamdumpRegion);
+
+ g_zRamdump_ServerInfo.pParsedInfo = (T_zOss_RamdumpRegionInfo *)((CHAR*)g_zRamdump_ServerInfo.pConfigureInfo+size);
+ g_zRamdump_ServerInfo.pParsedInfo->regionNum = 0;
+ size = (sizeUnit * ZOSS_RAMDUMP_PARSED_REGION_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ServerInfo.pParsedInfo->regionMaxNum = (size - sizeof(T_zOss_RamdumpRegionInfo)) / sizeof(T_zOss_RamdumpRegion);
+
+ g_zRamdump_ServerInfo.pFileInfo = (T_zOss_RamdumpFileInfo*)((CHAR*)g_zRamdump_ServerInfo.pParsedInfo + size);
+ g_zRamdump_ServerInfo.pFileInfo->fileNum = 0;
+ size = (sizeUnit * ZOSS_RAMDUMP_FILE_INFO_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ServerInfo.pFileInfo->fileMaxNum = (size - sizeof(T_zOss_RamdumpFileInfo)) / sizeof(T_zOss_RamdumpFile);
+
+ g_zRamdump_ServerInfo.pAgentFileInfo = (T_zOss_RamdumpFileInfo*)((CHAR*)g_zRamdump_ServerInfo.pFileInfo + size);
+ g_zRamdump_ServerInfo.pAgentFileInfo->fileNum = 0;
+ size = (sizeUnit * ZOSS_RAMDUMP_FILE_INFO_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ServerInfo.pAgentFileInfo->fileMaxNum = (size - sizeof(T_zOss_RamdumpFileInfo)) / sizeof(T_zOss_RamdumpFile);
+
+ g_zRamdump_ServerInfo.pErrInfo = (T_zOss_RamdumpBuffInfo *)((CHAR*)g_zRamdump_ServerInfo.pAgentFileInfo + size);
+ size = (sizeUnit * ZOSS_RAMDUMP_ERR_INFO_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ServerInfo.pErrInfo->pBuff = (CHAR*)g_zRamdump_ServerInfo.pErrInfo + sizeof(T_zOss_RamdumpBuffInfo);
+ g_zRamdump_ServerInfo.pErrInfo->buffLen = size - sizeof(T_zOss_RamdumpBuffInfo);
+ sprintf( (char *)g_zRamdump_ServerInfo.pErrInfo->pBuff, "%d_s_core: exact error!\n", (int)s_zRamdump_ServerCfgInfo.serverId);
+
+ g_zRamdump_ServerInfo.pIoReadbuf = (T_zOss_RamdumpBuffInfo *)((CHAR *)g_zRamdump_ServerInfo.pErrInfo + size);
+ size = (sizeUnit * ZOSS_RAMDUMP_IO_READBUF_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ServerInfo.pIoReadbuf->pBuff = (CHAR*)g_zRamdump_ServerInfo.pIoReadbuf + sizeof(T_zOss_RamdumpBuffInfo);
+ g_zRamdump_ServerInfo.pIoReadbuf->buffLen = size - sizeof(T_zOss_RamdumpBuffInfo);
+
+ g_zRamdump_ServerInfo.pIoWritebuf = (T_zOss_RamdumpBuffInfo *)((CHAR *)g_zRamdump_ServerInfo.pIoReadbuf + size);
+ size = (sizeUnit * ZOSS_RAMDUMP_IO_WRITEBUF_RATE - sizeof(UINT32) + 1) & ~(sizeof(UINT32) - 1);
+ g_zRamdump_ServerInfo.pIoWritebuf->pBuff = (CHAR*)g_zRamdump_ServerInfo.pIoWritebuf + sizeof(T_zOss_RamdumpBuffInfo);
+ g_zRamdump_ServerInfo.pIoWritebuf->buffLen = size - sizeof(T_zOss_RamdumpBuffInfo);
+
+ zOss_AssertExN(((CHAR *)g_zRamdump_ServerInfo.pIoWritebuf + size) <=
+ (s_zRamdump_ServerCfgInfo.pRamdumpStartAddr + s_zRamdump_ServerCfgInfo.ramdumpSize));
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ClientIcpInit
+ * ¹¦ÄÜÃèÊö£ºclient ICP ³õʼ»¯£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ClientIcpInit(VOID)
+{
+ UINT32 cnt = 0;
+ UINT32 clientNum = sizeof(g_zRamdump_ClientIcpInfo)/sizeof(T_zOss_RamdumpIcpInfo);
+
+ if(clientNum != 0)
+ {
+ s_zRamdump_ClientInfo = (T_zOss_RamdumpClientInfo **)zOss_Malloc(sizeof(VOID *) * clientNum);
+ zOss_Memset(s_zRamdump_ClientInfo, 0, sizeof(VOID *) * clientNum);
+ g_zRamdump_ServerInfo.pWaitMsgFlag= (BOOL *)zOss_Malloc(sizeof(BOOL) * clientNum);
+ zOss_Memset(g_zRamdump_ServerInfo.pWaitMsgFlag, 0, sizeof(BOOL) * clientNum);
+ }
+
+ for (cnt = 0; cnt < clientNum; cnt++)
+ {
+ zDrvIcp_RegCallback(g_zRamdump_ClientIcpInfo[cnt].srcModId, g_zRamdump_ClientIcpInfo[cnt].desModId, ramdump_ServerProcessClientMsg, ICP_ISR_CALLBACK);
+ }
+
+#ifdef _USE_ARM1_RAMDUMP
+ ramdump_Arm1Init();
+#endif
+
+#ifdef _USE_ZSP_RAMDUMP
+ ramdump_ZspInit();
+#endif
+
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_NotifyClientExceptionOccur
+ * ¹¦ÄÜÃèÊö£ºÍ¨Öªclient·¢ÉúÁËÒì³££»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_NotifyClientExceptionOccur(VOID)
+{
+ UINT32 cnt = 0;
+ T_zOss_RamdumpServerMsgInfo msgInfo = {0};
+
+ for (cnt = 0; cnt < sizeof(g_zRamdump_ClientIcpInfo)/sizeof(T_zOss_RamdumpIcpInfo); cnt++)
+ {
+ msgInfo.msgType = ZOSS_RAMDUMP_EXCPT_TYPE;
+ msgInfo.pServerConInfo = NULL;
+ ramdump_ServerSendMsg(g_zRamdump_ClientIcpInfo, &msgInfo);
+ }
+
+#ifdef _USE_ARM1_RAMDUMP
+ if (ramdump_CheckArm1InitFinish())
+ ramdump_SendMsgToArm1(ZOSS_RAMDUMP_EXCPT_TYPE);
+#endif
+
+#ifdef _USE_ZSP_RAMDUMP
+ ramdump_SendMsgToZsp();
+#endif
+
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_ProcessClientException
+ * ¹¦ÄÜÃèÊö£º´¦ÀíclientÒì³££»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_ProcessClientException(VOID)
+{
+ UINT32 cnt = 0;
+ UINT32 delayTimeLen = 1000; /* ʱ¼ä´óÔ¼ÔÚ1s×óÓÒ*/
+
+ for (cnt = 0; cnt < sizeof(g_zRamdump_ClientIcpInfo)/sizeof(T_zOss_RamdumpIcpInfo); cnt++)
+ {
+ if (s_zRamdump_ClientInfo[cnt] != NULL)
+ {
+ g_zRamdump_ServerInfo.pWaitMsgFlag[cnt] = ramdump_delay(delayTimeLen, (volatile UINT32 *)(s_zRamdump_ClientInfo[cnt]->clientFlagBase), ZOSS_RAMDUMP_FLAG_SECOND_VALUE);
+ if (g_zRamdump_ServerInfo.pWaitMsgFlag[cnt])
+ {
+ ramdump_ParseRegionInfo(s_zRamdump_ClientInfo[cnt]->pConfigureInfo, s_zRamdump_ClientInfo[cnt]->pParsedInfo);
+ *(UINT32 *)s_zRamdump_ClientInfo[cnt]->clientFlagBase = ZOSS_RAMDUMP_FLAG_THIRD_VALUE;
+#ifdef _OS_TOS
+ TOS_CACHE_CLEAN_ALL();
+#endif
+ g_zRamdump_ServerInfo.pWaitMsgFlag[cnt] = ramdump_delay(delayTimeLen, (volatile UINT32 *)(s_zRamdump_ClientInfo[cnt]->clientFlagBase), ZOSS_RAMDUMP_FLAG_FOUR_VALUE);
+ }
+ }
+ }
+
+#ifdef _USE_ARM1_RAMDUMP
+ ramdump_ProcessArm1Exception();
+#endif
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_AgentIcpInit
+ * ¹¦ÄÜÃèÊö£ºAGENT ICP ×ÊÔ´³õʼ»¯£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_AgentIcpInit(VOID)
+{
+ UINT32 cnt = 0;
+
+ for (cnt = 0; cnt < sizeof(s_zRamdump_AgentIcpInfo)/sizeof(T_zOss_RamdumpIcpInfo); cnt++)
+ {
+ zDrvIcp_RegCallback(s_zRamdump_AgentIcpInfo[cnt].srcModId, s_zRamdump_AgentIcpInfo[cnt].desModId, ramdump_ServerProcessAgentMsg, ICP_ISR_CALLBACK);
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_NotifyAgentExceptionOccur
+ * ¹¦ÄÜÃèÊö£ºÍ¨Öªagent·¢ÉúÁËÒì³££»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_NotifyAgentExceptionOccur(VOID)
+{
+ UINT32 cnt = 0;
+ T_zOss_RamdumpServerMsgInfo msgInfo = {0};
+
+ for (cnt = 0; cnt < sizeof(s_zRamdump_AgentIcpInfo)/sizeof(T_zOss_RamdumpIcpInfo); cnt++)
+ {
+ msgInfo.msgType = ZOSS_RAMDUMP_EXCPT_TYPE;
+ msgInfo.pServerConInfo = NULL;
+ ramdump_ServerSendMsg(&s_zRamdump_AgentIcpInfo[cnt], &msgInfo);
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_NotifyAgentSaveData
+ * ¹¦ÄÜÃèÊö£ºÍ¨ÖªAGENT¿ÉÒÔ±£´æÊý¾Ý£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ramdump_NotifyAgentSaveData(VOID)
+{
+ UINT32 cnt = 0;
+ T_zOss_RamdumpServerMsgInfo msgInfo = {0};
+
+ for (cnt = 0; cnt < sizeof(s_zRamdump_AgentIcpInfo)/sizeof(T_zOss_RamdumpIcpInfo); cnt++)
+ {
+ msgInfo.msgType = ZOSS_RAMDUMP_DATA_READY_TYPE;
+#ifdef _OS_TOS
+ zTos_MmuGetPaddrByVaddr((cyg_uint32)g_zRamdump_ServerInfo.pAgentFileInfo,(cyg_uint32 *)&(msgInfo.pServerConInfo));
+#endif
+ ramdump_ServerSendMsg(&s_zRamdump_AgentIcpInfo[cnt], &msgInfo);
+ }
+}
+
+/*****************************************************************************
+ * º¯ÊýÃû³Æ£º ramdump_Main
+ * ¹¦ÄÜÃèÊö£º Ö´ÐÐramdump£¬ÓëPC²à¹¤¾ßÒÔ¼°´úÀí²à½øÐн»»¥£¬´«µÝÐèÒª±£´æµÄÊý¾Ý
+ * ²ÎÊý˵Ã÷£º (IN):ÎÞ
+ * (OUT):ÎÞ
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ****************************************************************************/
+static VOID ramdump_Main(VOID)
+{
+ ramdump_ParseRegionInfo(g_zRamdump_ServerInfo.pConfigureInfo, g_zRamdump_ServerInfo.pParsedInfo);
+ zOss_RamdumpCreateCmmFile(g_zRamdump_ServerInfo.pCmmInfo);
+ ramdump_NotifyAgentExceptionOccur();
+ ramdump_NotifyClientExceptionOccur();
+ ramdump_ProcessClientException();
+ ramdump_SaveAllFilesInfo();
+ ramdump_NotifyAgentSaveData();
+
+ if (g_zRamdump_Optfunc.ramdump_Process_AftHook != NULL)
+ {
+ g_zRamdump_Optfunc.ramdump_Process_AftHook();
+ }
+ ramdump_TransferData();
+}
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£º zOss_RamdumpHandle
+ * ¹¦ÄÜÃèÊö£º Ramdump´¦Àíº¯Êý
+ * ²ÎÊý˵Ã÷£º (IN)
+ * ser_called:ΪÕæʱ,±íʾ´íÎóÀ´×ÔÓû§µ÷ÓÃ,Ϊ¼Ùʱ,±íʾ´íÎóÀ´×ÔÄÚºË
+ * ecode:´íÎóÂë
+ * extra:´íÎ󸽼ÓÂë
+ * (OUT)
+ * ÎÞ£»
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º ²ÎÊýÔÚTOS²Ù×÷ϵͳÉÏûÓÐʵ¼ÊÒâÒå;
+ **************************************************************************/
+VOID zOss_RamdumpHandle(UINT16 user_called, UINT16 ecode, UINT16 extra)
+{
+ static UINT32 excepNum = 0;
+ ZOSS_INTR old_intr;
+
+ ZOSS_SAVE_IRQ(old_intr);
+ if(++excepNum > 1 || !s_zRamdump_InitFlag) /* Ö»±£´æµÚÒ»´Î³ö´íÏÖ³¡ */
+ {
+ for ( ; ; ) ;
+ }
+
+ if (zOss_GetExceptResetFlag() != EXCEPT_RESET_ENABLE)
+ {
+ zOss_RamdumpEncodeError(g_zRamdump_ServerInfo.pErrInfo->pBuff, user_called, ecode, extra);
+ /* Ö´ÐÐramdumpÒì³£´¦Àíº¯Êý */
+ ramdump_Main();
+ if(zOss_GetRamdumpResetFlag() == 0)
+ {
+ for ( ; ; ) ;
+ }
+ else
+ {
+ zSys_ExceptReboot(s_zRamdump_ExceptCore.exceptCore);
+ }
+ }
+ else
+ {
+ except_RecordExceptInfo(s_zRamdump_ServerCfgInfo.serverId);
+ zSys_ExceptReboot(s_zRamdump_ExceptCore.exceptCore);
+ }
+
+ ZOSS_RESTORE_IRQ(old_intr);
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºramdump_RegionsCmmFile
+ * ¹¦ÄÜÃèÊö£ºT32cmm½Å±¾ÄÚ´æ¶ÎдÈë
+ * ²ÎÊý˵Ã÷£º(IN):
+ * address: cmm½Å±¾Ö¸Õ룻
+ * (OUT):
+ * ·µ »Ø Öµ£º·µ»Ø½Å±¾Ö¸Õ룻
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+CHAR *zOss_RamdumpCreateRegionsCmmFile(CHAR *address)
+{
+ CHAR fileName[ZOSS_RAMDUMP_FILENAME_LEN] = {0};
+ UINT32 i = 0;
+
+ sprintf(fileName, "%d_s_mem.bin", (int)s_zRamdump_ServerCfgInfo.serverId);
+ /* Êä³öramdump ÄÚ´æ¶ÎÎļþ */
+ for (i = 0; i < g_zRamdump_ServerInfo.pParsedInfo->regionNum; i++)
+ {
+ T_zOss_RamdumpRegion *pRegion = &g_zRamdump_ServerInfo.pParsedInfo->regions[i];
+ address += sprintf(address, "data.load.binary &%s\\%d_%s %#lx--%#lx /noclear\r\n", ZOSS_RAMDUMP_DIR_NAME,
+ (int)i, fileName, pRegion->baseForSelf, pRegion->baseForSelf + pRegion->size - 1);
+ }
+ return address;
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpConfigureMem
+ * ¹¦ÄÜÃèÊö£º±£´æÄÚ´æ¶ÎÊý¾ÝÅäÖÃÐÅÏ¢
+ * ²ÎÊý˵Ã÷£º(IN):
+ * regionInfo: Êý¾ÝÅäÖÃÇøÓò£»
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID zOss_RamdumpConfigureMem(T_zOss_RamdumpRegion *regionInfo)
+{
+ T_zOss_RamdumpRegionInfo *pCfgInfo = g_zRamdump_ServerInfo.pConfigureInfo;
+
+ if (regionInfo->size == 0)
+ return;
+ zOss_AssertExN(pCfgInfo->regionNum < pCfgInfo->regionMaxNum);
+ pCfgInfo->regions[pCfgInfo->regionNum].baseForServer = regionInfo->baseForServer;
+ pCfgInfo->regions[pCfgInfo->regionNum].baseForSelf = regionInfo->baseForSelf;
+ pCfgInfo->regions[pCfgInfo->regionNum].baseForCopy = regionInfo->baseForCopy;
+ pCfgInfo->regions[pCfgInfo->regionNum].size = regionInfo->size;
+ (pCfgInfo->regionNum)++;
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpSetOperation
+ * ¹¦ÄÜÃèÊö£ºramdumpÓû§×¢²á½Ó¿Ú£»
+ * ²ÎÊý˵Ã÷£º(IN):
+ * funcObjPtr: »Øµ÷º¯ÊýµÄÖ¸Õ룻
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID zOss_RamdumpSetOperation(T_zOss_RamdumpOpt *funcObjPtr)
+{
+ zOss_AssertExN(funcObjPtr != NULL);
+
+ if (funcObjPtr->ramdump_Process_PreHook != NULL)
+ {
+ g_zRamdump_Optfunc.ramdump_Process_PreHook = funcObjPtr->ramdump_Process_PreHook;
+ }
+ if (funcObjPtr->ramdump_Process_AftHook != NULL)
+ {
+ g_zRamdump_Optfunc.ramdump_Process_AftHook = funcObjPtr->ramdump_Process_AftHook;
+ }
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpInit
+ * ¹¦ÄÜÃèÊö£ºramdump³õʼ»¯£»
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ ***************************************************************************/
+VOID zOss_RamdumpInit(VOID)
+{
+ ramdump_SetPartition();
+#if defined (_OS_TOS) && defined (CYGOPT_HAL_ARM_MMU)
+ ramdump_GetConfigRegion();
+#endif
+ ramdump_ClientIcpInit();
+ ramdump_AgentIcpInit();
+
+#ifdef _USE_CP_USB
+ zOss_RamdumpSetUsbOpt();
+#else
+ zOss_RamdumpSetIcpOpt();
+#endif
+
+ s_zRamdump_InitFlag = TRUE;
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpForceClientException
+ * ¹¦ÄÜÃèÊö£ºÖÆÔìclientËÀ»ú£»
+ * ²ÎÊý˵Ã÷£º(IN)
+ * coreId: client ID
+ * (OUT)
+ * ÎÞ
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º²»ÒªÒªÇóÈ·¶¨ÄǸöclientºËËÀ»úµ«ÊÇÒªÇóÿ¸öclientºË¿ÉÒÔËÀ»ú£»
+ ***************************************************************************/
+UINT32 zOss_RamdumpForceClientException(UINT32 coreId)
+{
+#ifdef _USE_ARM1_RAMDUMP
+ if (coreId == ZOSS_RAMDUMP_PHY_COREDID)
+ {
+ ramdump_SendMsgToArm1(ZOSS_RAMDUMP_TEST_EXCPT_TYPE);
+ }
+ else
+#endif
+ {
+ T_zOss_RamdumpServerMsgInfo msgInfo = {0};
+
+ zOss_AssertEx(coreId <= sizeof(g_zRamdump_ClientIcpInfo)/sizeof(T_zOss_RamdumpIcpInfo), ZOSS_ERROR);
+ msgInfo.msgType = ZOSS_RAMDUMP_TEST_EXCPT_TYPE;
+ msgInfo.pServerConInfo = NULL;
+ ramdump_ServerSendMsg(&g_zRamdump_ClientIcpInfo[coreId-1], &msgInfo);
+ }
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºOsa_SysErrHndInit
+ * ¹¦ÄÜÃèÊö£ºµØÖ·È«¾Ö±äÁ¿³õʼ»¯,»ñÈ¡ramdumpÄÚ´æ¿éĬÈÏÅäÖÃ
+ * arm0ºÍarm1ͬ²½»úÖÆ
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º´ò×®£¬ÎªÁ˼æÈÝose¡¢cskyµÈramdump¹¦ÄÜ£»
+ ***************************************************************************/
+VOID Osa_SysErrHndInit(VOID)
+{
+
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£º zOss_RamdumpSetIoOpt
+ * ¹¦ÄÜÃèÊö£º ÉèÖÃramdump Io ͨµÀ£»
+ * ²ÎÊý˵Ã÷£º (IN):
+ * (OUT):
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID zOss_RamdumpSetIoOpt(T_zOss_RamdumpIoOpt hook)
+{
+ g_zRamdumpIoOpt.init = hook.init;
+ g_zRamdumpIoOpt.read = hook.read;
+ g_zRamdumpIoOpt.write = hook.write;
+ g_zRamdumpIoOpt.finish = hook.finish;
+}
+
+/**************************************************************************
+ * º¯ÊýÃû³Æ£ºzOss_RamdumpGetParsedRegions
+ * ¹¦ÄÜÃèÊö£º»ñÈ¡MMU½âÎöÇøÓò
+ *
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º½öΪT32 CMM½Å±¾Ê¹Óã»
+ ***************************************************************************/
+VOID zOss_RamdumpGetParsedRegions(VOID)
+{
+ if(s_zRamdump_InitFlag)
+ {
+ g_zRamdump_ServerInfo.pParsedInfo->regionNum = 0;
+ ramdump_ParseRegionInfo(g_zRamdump_ServerInfo.pConfigureInfo, g_zRamdump_ServerInfo.pParsedInfo);
+ for ( ; ; ) ;
+ }
+ else
+ {
+ for ( ; ; ) ;
+ }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_ramlog.c b/cp/ps/plat/src/oss/sup/src/sup_ramlog.c
new file mode 100644
index 0000000..84e74f2
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_ramlog.c
@@ -0,0 +1,135 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : Ramlog.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : ³õʼ»¯´òÓ¡Îļþ
+* ×÷ Õß : gongyi
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2008-04-30
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001782014
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0002
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-27
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é EC:617001782003
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#define ZOSS_RAMLOG_MAX_LEN 59
+#define ZOSS_RAMLOG_MAX_ENTRIES 30
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+typedef struct
+{
+ UINT8 is_use;
+ CHAR Ram[ZOSS_RAMLOG_MAX_LEN+1];
+}T_Comm_Ram;
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+static T_Comm_Ram gCommRam[ZOSS_RAMLOG_MAX_ENTRIES] = {0};
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_RamLog
+* ¹¦ÄÜÃèÊö£º¼Ç¼³õʼ»¯ÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN)
+ rambuf: ´òÓ¡µ½RAMLOGµÄÊý¾Ý
+ restrict: Êý¾Ý¸ñʽ»¯ÀàÐÍ
+ (OUT)
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£ºrambuf»º³åÇøµÄ×Ö·û³¤¶È²»ÄÜ´óÓÚZOSS_RAMLOG_MAX_LEN¸ö×Ö½Ú£¬·ñÔòÖ±½Ó·µ»Ø
+**************************************************************************/
+VOID zOss_RamLog( CHAR * rambuf, UINT32 restric )
+{
+ UINT32 i = 0;
+
+ if (strlen((char *)rambuf) > ZOSS_RAMLOG_MAX_LEN)
+ {
+ return;
+ }
+
+ for (i = 0; i < ZOSS_RAMLOG_MAX_ENTRIES; i++)
+ {
+ if (gCommRam[i].is_use == 0)
+ {
+ SINT32 ret = sprintf((char *)gCommRam[i].Ram, (char *)rambuf, restric);
+ if (ret <= 0)
+ {
+ break;
+ }
+
+ gCommRam[i].is_use = 1;
+ break;
+ }
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_RamPrintf
+* ¹¦ÄÜÃèÊö£º´òÓ¡³õʼ»¯ÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£ºÔÚϵͳ³õʼ»¯Íê³Éºóµ÷ÓÃ
+**************************************************************************/
+VOID zOss_RamPrintf(VOID)
+{
+ UINT32 i = 0;
+
+ for( ; i < ZOSS_RAMLOG_MAX_ENTRIES; i++)
+ {
+ if(gCommRam[i].is_use == 0)
+ {
+ return;
+ }
+
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "%s", gCommRam[i].Ram);
+ }
+}
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_shell.c b/cp/ps/plat/src/oss/sup/src/sup_shell.c
new file mode 100755
index 0000000..53f9127
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_shell.c
@@ -0,0 +1,790 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : sup_shell.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : shell·½°¸ÊµÏÖÎļþ
+* ×÷ Õß : ÖܹúÆÂ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2008-04-21
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001782014
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0002
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-27
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é EC:617001782003
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_shell_cmd.h"
+#include "drv_api.h"
+#include "commgt_api.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#ifndef _OS_WIN
+#ifndef stricmp
+#define stricmp strcasecmp
+#endif
+
+#ifndef strnicmp
+#define strnicmp strncasecmp
+#endif
+#endif
+
+#define EV_ZOSS_SHELL_COMM_CMD 1000
+#define SHELL_MAX_DYNAMIC_CMD 100
+
+#define SHELL_ISNUMBER(x) ((x) >= '0' && (x) <= '9')
+#define SHELL_ISHEXNUMBER(x) (SHELL_ISNUMBER((x)) || ((x) >= 'a' && (x) <= 'f') || ((x) >= 'A' && (x) <= 'F'))
+#define SHELL_ISIDENTIFIER(x) (SHELL_ISNUMBER((x)) || ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || (x) == '_')
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+VOID Shell_TaskEntry(UINT8 state, UINT32 msg_id, UINT8 *buf, UINT16 msg_len, UINT8 *private_data);
+
+static SINT32 Shell_findCmd(CHAR *cmd);
+static VOID ShellHelpProcess(T_Shell_CommandMessage *CmdMsg);
+static UINT32 Shell_FindDynamicCmd(const CHAR *cmd);
+static VOID Shell_help(T_Shell_CommandMessage *pCmdMsg);
+static VOID Shell_MessageDivide(T_Shell_CommandMessage *msg);
+static UINT32 Shell_Process(T_Shell_CommandMessage *CmdMsg);
+static VOID Shell_CommCallBack(UINT32 msgID, const UINT8 *msg, UINT16 msgLen);
+static UINT32 Shell_ParseMessageFromCommData(T_Shell_CommandMessage *CmdMsg, const UINT8 *buf, UINT32 bufLen);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+ZOSS_THREAD_ID gShellTaskID = NULL; /* È«¾ÖµÄshell ÈÎÎñID */
+static UINT32 gShell_WintracePrintFlag = 1;
+
+/* ÃüÁî±í */
+static T_Shell_Cmd gShell_Cmds[] =
+{
+ /*ÃüÁîÃû³Æ Èë¿Úº¯Êý ˵Ã÷ */
+
+ {(CHAR *)"help", (Shell_Func)Shell_help, (CHAR *)"ÌṩSHELLÃüÁîµÄ°ïÖúÐÅÏ¢" },
+#ifdef _USE_OSS_SHELL_MISC
+ /* »ù±¾ÃüÁî */
+ {(CHAR *)"bootInfo", (Shell_Func)OSS_DbgShowBootInfo, (CHAR *)"ÏÔʾÆô¶¯ÐÅÏ¢" },
+ {(CHAR *)"threadSuspend", (Shell_Func)OSS_DbgSuspendThread, (CHAR *)"¹ÒÆðÏß³Ì" },
+ {(CHAR *)"threadResume", (Shell_Func)OSS_DbgResumeThread, (CHAR *)"»Ö¸´Ïß³Ì" },
+ {(CHAR *)"setThreadPrior", (Shell_Func)OSS_DbgSetThreadPri, (CHAR *)"¸Ä±äÏß³ÌÓÅÏȼ¶" },
+ {(CHAR *)"showMsg", (Shell_Func)OSS_DbgShowMsg, (CHAR *)"ÏÔʾ/¹Ø±ÕÏûÏ¢¸ú×Ù" },
+ {(CHAR *)"showReg", (Shell_Func)OSS_DbgShowRegInfo, (CHAR *)"»ñÈ¡¼Ä´æÆ÷ÐÅÏ¢" },
+ {(CHAR *)"ramdumpConfigRegion", (Shell_Func)OSS_DbgRamdumpConfigRegionInfo, (CHAR *)"ÉèÖÃÐèÒªµ¼³öµÄÄÚ´æÇøÓò" },
+ {(CHAR *)"showProcSig", (Shell_Func)Shell_ShowProcSig, (CHAR *)"ÏÔʾÏß³ÌsignalʹÓÃÇé¿ö" },
+ {(CHAR *)"forceRamdump", (Shell_Func)OSA_ForceRamdump, (CHAR *)"ÖÆÔìÒ쳣ǿÖÆramdump" },
+ {(CHAR *)"reboot", (Shell_Func)OSS_DbgReboot, (CHAR *)"ÖØÆô" },
+ {(CHAR *)"setWintracePrint", (Shell_Func)OSS_DbgSetWintracePrintFlag, (CHAR *)"´ò¿ª¹Ø±Õwintrace´òÓ¡" },
+ {(CHAR *)"trace", (Shell_Func)OSA_DbgTrace, (CHAR *)"²é¿´¸ú×ÙÄ£¿éÐÅÏ¢" },
+ {(CHAR *)"profile", (Shell_Func)OSS_DbgProfile, (CHAR *)"½«gmon.outдÈëÎļþϵͳ" },
+ {(CHAR *)"openTraceSwitch", (Shell_Func)OSS_OpenTraceSwitch, (CHAR *)"´ò¿ªÖжϺÍÏ̵߳ĸú×ÙÐÅÏ¢¿ª¹Ø" },
+ {(CHAR *)"setAssertLevel", (Shell_Func)OSS_SetAssertLevel, (CHAR *)"ÉèÖÃÄں˶ÏÑÔµ÷ÊÔ¼¶±ð" },
+#endif
+#ifdef _USE_OSS_SHELL_MEM
+ /* ÄÚ´æ¹Û²ì */
+ {(CHAR *)"mem", (Shell_Func)OSS_DbgShowMemInfo, (CHAR *)"´òӡϵͳÄÚ´æÐÅÏ¢" },
+ {(CHAR *)"ub", (Shell_Func)OSS_DbgShowUbInfo, (CHAR *)"´òӡϵͳÄÚ´æ´æ³ØÐÅÏ¢" },
+ {(CHAR *)"threadUB", (Shell_Func)OSS_DbgShowThreadUbInfo, (CHAR *)"´òÓ¡Ö¸¶¨Ï̵߳ÄUBÐÅÏ¢" },
+ {(CHAR *)"taskUB", (Shell_Func)OSS_DbgShowTaskUbInfo, (CHAR *)"´òÓ¡Ö¸¶¨ÈÎÎñµÄUBÐÅÏ¢" },
+ {(CHAR *)"showPoolInfo", (Shell_Func)Shell_ShowPoolInfo, (CHAR *)"ÏÔʾpoolÐÅÏ¢" },
+ {(CHAR *)"opendbgub", (Shell_Func)OSA_SetUBDbgSwitch, (CHAR *)"´ò¿ªubµ÷ÊÔ¿ª¹Ø" },
+ {(CHAR *)"checkUb", (Shell_Func)OSA_DbgUbInfo, (CHAR *)"¼ì²éubÐÅÏ¢" },
+ {(CHAR *)"showMem", (Shell_Func)OSS_DbgGetMem, (CHAR *)"²é¿´ÄÚ´æÐÅÏ¢" },
+ {(CHAR *)"setMem", (Shell_Func)OSS_DbgSetMem, (CHAR *)"ÐÞ¸ÄÄÚ´æÐÅÏ¢" },
+ {(CHAR *)"checkMem", (Shell_Func)OSA_DbgMemInfo, (CHAR *)"¼ì²émemµÄʹÓÃÐÅÏ¢(й¶ºÍÔ½½ç)" },
+ {(CHAR *)"checkLeakMem", (Shell_Func)OSA_DbgMemTimeLeakInfo, (CHAR *)"¼ì²éµÄij¸öʱ¼ä¶ÎMemµÄй¶ÐÅÏ¢" },
+#endif
+#ifdef _USE_OSS_SHELL_THREAD
+ /* µ÷¶ÈͨѶ */
+ {(CHAR *)"threadInfo", (Shell_Func)OSS_DbgShowThreadInfo, (CHAR *)"²é¿´Ïß³ÌÐÅÏ¢" },
+ {(CHAR *)"taskInfo", (Shell_Func)OSS_DbgShowTaskInfo, (CHAR *)"´òӡϵͳËùÓÐÈÎÎñÐÅÏ¢" },
+ {(CHAR *)"threadCpu", (Shell_Func)OSS_DbgDisplayThreadExecInfo, (CHAR *)"ÏÔʾij¸öÏ̵߳ÄÖ´ÐÐʱ¼ä" },
+ {(CHAR *)"threadsCpu", (Shell_Func)OSS_DbgDisplayThreadsExecInfo, (CHAR *)"ÏÔʾËùÓÐÏ̵߳ÄÖ´ÐÐʱ¼ä" },
+ {(CHAR *)"threadSwapflag", (Shell_Func)OSS_DbgThreadSetFlag, (CHAR *)"¹Ø±Õ/´ò¿ª¼Ç¼Ïß³ÌCPUʱ¼ä¿ª¹Ø" },
+ {(CHAR *)"syscpu", (Shell_Func)OSS_DbgGetSysCPU, (CHAR *)"»ñµÃϵͳCPUÕ¼ÓÃÂÊ" },
+ {(CHAR *)"setUpdateCpuTime", (Shell_Func)OSS_DbgSetUpdateCPUTime, (CHAR *)"ÉèÖÃCPUʹÓÃÂÊË¢ÐÂʱ¼ä" },
+ {(CHAR *)"startDaemonTask", (Shell_Func)OSS_StartDaemonTask, (CHAR *)"Æô¶¯ÈÎÎñËÀÑ»·¼à²â" },
+#endif
+
+#ifdef _USE_OSS_SHELL_PSM
+#ifdef _USE_PSM
+ {(CHAR *)"psminfo", (Shell_Func)OSS_PsmTraceInfo, (CHAR *)"Êä³öpsmµ÷ÊÔÐÅÏ¢" },
+#ifdef _USE_CPU_DFM
+ {(CHAR *)"dfmifno", (Shell_Func)OSS_DfmTraceInfo, (CHAR *)"Êä³ödfmµ÷ÊÔÐÅÏ¢" },
+#endif
+#endif
+#endif
+};
+
+static T_Shell_Cmd gShell_DynamicCmds[SHELL_MAX_DYNAMIC_CMD] = { 0 };
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShell_TaskEntry
+* ¹¦ÄÜÃèÊö£ºSHELLÈÎÎñÈë¿Úº¯Êý
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID Shell_TaskEntry(UINT8 state, UINT32 msg_id, UINT8 *buf, UINT16 msg_len, UINT8 *private_data)
+{
+ UINT32 status = ZOSS_ERROR;
+
+ switch (state)
+ {
+ case ZOSS_STATUS_INIT:
+ {
+ switch (msg_id)
+ {
+ case EV_INIT:
+ {
+ break;
+ }
+ case EV_POWERON:
+ {
+ gShellTaskID = zOss_GetSelfTaskID();
+ /* ÏòͨѶģ¿é×¢²áµ±Ç°×ÓÄ£¿é */
+ #ifdef _USE_WINCOMM_SERVER
+ status = zTools_CommReg(SUBMDL_SHELL, ZDRV_DEV_USBSIO_2, (ModuleFunc)Shell_CommCallBack);
+ #else
+ status = zOss_CommReg(SUBMDL_SHELL, ZDRV_DEV_USBSIO_2, Shell_CommCallBack);
+ #endif
+ if (status != ZOSS_SUCCESS)
+ {
+ zOss_ASSERT(0);
+ zOss_Printf(SUBMDL_SHELL, PRINT_LEVEL_ABNORMAL, "SHELL_POWERON:Fail to register submodule!");
+ break;
+ }
+ status = zOss_SetState(ZOSS_STATUS_WORK);
+ if (status != ZOSS_SUCCESS)
+ {
+ zOss_ASSERT(0);
+ zOss_Printf(SUBMDL_SHELL, PRINT_LEVEL_ABNORMAL, "SHELL_POWERON:Fail to set state!");
+ break;
+ }
+
+ break;
+ }
+ default:
+ {
+ zOss_Printf(SUBMDL_SHELL, PRINT_LEVEL_ABNORMAL, "SHELL:Receive a invalid message");
+ break;
+ }
+ }
+ break;
+ }
+ case ZOSS_STATUS_WORK:
+ {
+ switch (msg_id)
+ {
+ case EV_ZOSS_SHELL_COMM_CMD:
+ {
+ T_Shell_CommandMessage cmdMsg = {0};
+
+ /* ´Ó½ÓÊÕµ½µÄÊý¾Ý·ÖÀë³öÃüÁî */
+ if (ZOSS_SUCCESS == Shell_ParseMessageFromCommData(&cmdMsg, (UINT8 *)buf, msg_len))
+ {
+ /* ¸ù¾ÝÃüÁîÖ´ÐвÙ×÷ */
+ Shell_MessageDivide(&cmdMsg);
+ }
+
+ break;
+ }
+ default:
+ {
+ zOss_Printf(SUBMDL_SHELL, PRINT_LEVEL_ABNORMAL, "SHELL:Receive a invalid message");
+ break;
+ }
+ }
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_AddShellCmd
+* ¹¦ÄÜÃèÊö£ºÌí¼Ó¶¯Ì¬ÃüÁî
+* ²ÎÊý˵Ã÷£º(IN)
+ cmd:ÃüÁî×Ö·û´®,²»ÄÜΪ¿Õ
+ func:ÃüÁîÖ´Ðк¯Êý,²»ÄÜΪNULL
+ description:ÃüÁîÃèÊö,¿ÉÒÔΪNULL
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS,ʧ°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º¶à´Îµ÷Óú¯Êý,ÏàͬµÄcmd_name,ºóÃæµ÷ÓõĻḲ¸ÇÇ°Ãæµ÷ÓõÄ
+**************************************************************************/
+UINT32 zOss_AddShellCmd(const CHAR *cmd_name, const Shell_Func func, const CHAR *description)
+{
+ UINT32 i = 0;
+ UINT32 name_size = 0;
+ UINT32 desc_size = 0;
+
+ zOss_AssertEx((NULL != cmd_name) && (func != NULL), ZOSS_ERROR);
+
+ i = Shell_FindDynamicCmd(cmd_name);
+ zOss_AssertEx(i < SHELL_MAX_DYNAMIC_CMD, ZOSS_ERROR);
+
+ name_size = strlen((char *)cmd_name);
+ if (NULL != description)
+ {
+ desc_size = strlen((char *)description);
+ }
+
+ if (NULL != gShell_DynamicCmds[i].cmd)
+ {
+ zOss_Free(gShell_DynamicCmds[i].cmd);
+ zOss_Free(gShell_DynamicCmds[i].desc);
+ gShell_DynamicCmds[i].cmd = NULL;
+ gShell_DynamicCmds[i].func = NULL;
+ gShell_DynamicCmds[i].desc = NULL;
+ }
+
+ gShell_DynamicCmds[i].cmd = (CHAR *)zOss_Malloc(name_size + 1);
+ if (NULL == gShell_DynamicCmds[i].cmd)
+ {
+ return ZOSS_ERROR;
+ }
+ zOss_Memset(gShell_DynamicCmds[i].cmd, 0, name_size + 1);
+ zOss_Memcpy(gShell_DynamicCmds[i].cmd, cmd_name, name_size);
+
+ gShell_DynamicCmds[i].desc = (CHAR *)zOss_Malloc(desc_size + 1); /* Èç¹ûdescΪNULL,ÉêÇë1¸ö×Ö·û¿Õ¼ä */
+ if (NULL == gShell_DynamicCmds[i].desc)
+ {
+ zOss_Free(gShell_DynamicCmds[i].cmd);
+ gShell_DynamicCmds[i].cmd = NULL;
+ return ZOSS_ERROR;
+ }
+ zOss_Memset(gShell_DynamicCmds[i].desc, 0, desc_size + 1);
+ if (0 != desc_size)
+ {
+ zOss_Memcpy(gShell_DynamicCmds[i].desc, description, desc_size);
+ }
+
+ gShell_DynamicCmds[i].func = func;
+
+ return ZOSS_SUCCESS;
+}
+
+UINT32 Shell_GetWintracePrintFlag(VOID)
+{
+ return gShell_WintracePrintFlag;
+}
+
+UINT32 Shell_SetPrintFlag(UINT32 WintraceFlag)
+{
+ zOss_AssertEx(WintraceFlag < 2 , ZOSS_ERROR);
+
+ gShell_WintracePrintFlag = WintraceFlag;
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShell_StrisNumber
+* ¹¦ÄÜÃèÊö£º×Ö·û´®ÊÇ·ñÈ«²¿ÊÇÊý×Ö
+* ²ÎÊý˵Ã÷£º(IN)
+ pStr:×Ö·û´®Ö¸Õë
+ (OUT)
+* ·µ »Ø Öµ£º0±íʾȫ²¿ÊÇÊý×Ö£¬-1±íʾ°üº¬·ÇÊý×Ö
+* ÆäËü˵Ã÷£ºÖ§³Ö10½øÖƺÍ16½øÖÆ£¬16½øÖÆÒªÇó0x»ò0XµÄǰ׺
+**************************************************************************/
+SINT32 Shell_StrisNumber(const CHAR *pStr)
+{
+ const CHAR *tmp = NULL;
+
+ zOss_AssertEx(pStr != NULL, (SINT32)ZOSS_ERROR);
+ tmp = pStr;
+ if (0 == strnicmp((char *)tmp, "0x", 2))
+ {
+ tmp = pStr + 2;
+ while ('\0' != *tmp)
+ {
+ if (!SHELL_ISHEXNUMBER(*tmp))
+ {
+ return -1;
+ }
+ tmp++;
+ }
+ }
+ else
+ {
+ while ('\0' != *tmp)
+ {
+ if (!SHELL_ISNUMBER(*tmp))
+ {
+ return -1;
+ }
+ tmp++;
+ }
+ }
+ return 0;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShell_isIdentifier
+* ¹¦ÄÜÃèÊö£º×Ö·û´®ÊÇ·ñÈ«²¿ÊÇÊý×Ö,×Öĸ»òÏ»®ÏßµÄ×éºÏ
+* ²ÎÊý˵Ã÷£º(IN)
+ Str:×Ö·û´®Ö¸Õë
+ (OUT)
+* ·µ »Ø Öµ£º0±íʾȫ²¿ÊÇÊý×Ö,×Öĸ»òÏ»®Ïß×éºÏ£¬-1±íʾ°üº¬·Ç·¨×Ö·û
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+SINT32 Shell_isIdentifier(const CHAR *pStr)
+{
+ const CHAR *tmp = NULL;
+
+ zOss_AssertEx(pStr != NULL, (SINT32)ZOSS_ERROR);
+ tmp = pStr;
+
+ while ('\0' != *tmp)
+ {
+ if (!SHELL_ISIDENTIFIER(*tmp))
+ {
+ return -1;
+ }
+ tmp++;
+ }
+ return 0;
+}
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShell_CommCallBack
+* ¹¦ÄÜÃèÊö£ºShell´úÀí»Øµ÷º¯Êý
+* ²ÎÊý˵Ã÷£º(IN)
+ msgID: ÏûÏ¢ID
+ msg: ÊÕµ½µÄÏûÏ¢
+ msgLen: ÊÕµ½µÄÏûÏ¢³¤¶È
+ (OUT)
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£ºÎÞ
+**************************************************************************/
+static VOID Shell_CommCallBack(UINT32 msgID, const UINT8 *msg, UINT16 msgLen)
+{
+ UINT32 RetCode = 0;
+ UINT8 *pCmdMsgBuff = NULL;
+
+ if (msgLen == 0 || msg == NULL)
+ {
+ return;
+ }
+
+ pCmdMsgBuff = (UINT8 *)zOss_GetUB(msgLen); /* È¥µôÏûϢͷ */
+ if (NULL == pCmdMsgBuff)
+ {
+ return;
+ }
+ zOss_Memcpy((VOID *)pCmdMsgBuff, msg, msgLen);
+ RetCode = zOss_TaskSend(EV_ZOSS_SHELL_COMM_CMD, pCmdMsgBuff, msgLen, gShellTaskID);
+ zOss_ASSERT(RetCode == ZOSS_SUCCESS);
+
+ RetCode = zOss_RetUB(pCmdMsgBuff);
+ zOss_ASSERT(RetCode == ZOSS_SUCCESS);
+}
+
+/***************************************************************************
+* º¯ÊýÃû³Æ£ºShell_ParseMessageFromCommData
+* ¹¦ÄÜÃèÊö£º´ÓÊÕµ½µÄÊý¾ÝBUFFERÖнâÎö³öÃüÁî
+* ²ÎÊý˵Ã÷£º(IN)
+ uf:Êý¾Ý»º³åÇø
+ ufLen:Êý¾Ý»º³åÇøµÄ³¤¶È
+ (OUT)
+* ·µ »Ø Öµ£ºÃüÁîµÄ½á¹¹
+* ÆäËü˵Ã÷£ºÄÚ²¿½Ó¿Ú
+*****************************************************************************/
+static UINT32 Shell_ParseMessageFromCommData(T_Shell_CommandMessage *CmdMsg, const UINT8 *buf, UINT32 bufLen)
+{
+ UINT32 i = 0;
+ UINT16 offset = 0;
+ UINT32 strLen = 0;
+ const CHAR *pStr = NULL;
+
+ zOss_AssertEx(NULL != CmdMsg && NULL != buf, ZOSS_ERROR);
+
+ /* ÃüÁî³õʼ»¯ */
+ zOss_Memset(CmdMsg, 0, sizeof(T_Shell_CommandMessage));
+ CmdMsg->paraCount = (UINT32)buf[0];
+ offset = 1;
+ pStr = (CHAR *)&buf[offset];
+ strLen = strlen((char *)pStr);
+ strncpy((char *)CmdMsg->cmd, (char *)pStr, strLen > SHELL_CMD_LENGTH ? SHELL_CMD_LENGTH : strLen); /* »ñÈ¡ÃüÁî */
+
+ /* ·ÖÎö²ÎÊý */
+ offset += (UINT16)strLen + 1; /* Ìø¹ýÃüÁ¶È£¬+1ÊÇÔÙÌø¹ý'\0' */
+ while ((offset < bufLen) && (i < SHELL_CMD_PARAM_NUM))
+ {
+ pStr = (CHAR *)&buf[offset];
+ strLen = strlen((char *)pStr);
+ strncpy((char *)CmdMsg->para[i], (char *)pStr, strLen > SHELL_CMD_PARAM_LENGTH ? SHELL_CMD_PARAM_LENGTH : strLen); /* »ñÈ¡²ÎÊý */
+ offset += (UINT16)strLen + 1; /* +1ÊÇÔÙÌø¹ý'\0' */
+ i++;
+ }
+ return ZOSS_SUCCESS;
+}
+
+/***************************************************************************
+* º¯ÊýÃû³Æ£ºShell_MessageDivide
+* ¹¦ÄÜÃèÊö£ºÃüÁî·Ö·¢µ½:TESTÄ£¿é»òSHELLÄ£¿é
+* ²ÎÊý˵Ã÷£º(IN)
+ msg£º½âÎö³öµÄÏûÏ¢½á¹¹Ìå
+ (OUT)
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£ºÄÚ²¿½Ó¿Ú
+*****************************************************************************/
+static VOID Shell_MessageDivide(T_Shell_CommandMessage *msg)
+{
+ zOss_AssertExN(NULL != msg);
+
+ if (ZOSS_ERROR == Shell_Process(msg))
+ {
+ ShellHelpProcess(msg);
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShell_Process
+* ¹¦ÄÜÃèÊö£ºShellÃüÁî´¦Àí
+* ²ÎÊý˵Ã÷£º(IN)
+ CmdMsg:ÃüÁî½á¹¹Ö¸Õë
+ (OUT)
+* ·µ »Ø Öµ£ºÕÒµ½ÃüÁî²¢Ö´Ðзµ»ØZOSS_SUCCESS£¬ÕÒ²»µ½ÃüÁî·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 Shell_Process(T_Shell_CommandMessage *CmdMsg)
+{
+ SINT32 cmd_count = 0;
+ SINT32 i = 0;
+
+ zOss_AssertEx(CmdMsg != NULL, ZOSS_ERROR);
+
+ cmd_count = sizeof(gShell_Cmds) / sizeof(gShell_Cmds[0]);
+ i = Shell_findCmd(CmdMsg->cmd); /* ²éÕÒÆ¥ÅäÃüÁî */
+
+ if (i >= 0 && i < cmd_count)
+ {
+ gShell_Cmds[i].func(CmdMsg); /* Ö´ÐÐÃüÁî */
+ return ZOSS_SUCCESS;
+ }
+
+ i = (SINT32)Shell_FindDynamicCmd(CmdMsg->cmd);
+ if (i < SHELL_MAX_DYNAMIC_CMD)
+ {
+ if (NULL != gShell_DynamicCmds[i].cmd)
+ {
+ gShell_DynamicCmds[i].func(CmdMsg);
+ return ZOSS_SUCCESS;
+ }
+ }
+
+ return ZOSS_ERROR;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShell_findCmd
+* ¹¦ÄÜÃèÊö£º²éÕÒÃüÁî
+* ²ÎÊý˵Ã÷£º(IN)
+ cmd:ÃüÁî×Ö·û´®
+ (OUT)
+* ·µ »Ø Öµ£ºÕÒµ½ÁË·µ»ØÔÚÃüÁî±íµÄλÖã¬ÕÒ²»µ½·µ»Ø-1
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static SINT32 Shell_findCmd(CHAR *cmd)
+{
+ SINT32 cmd_count = 0;
+ SINT32 i = 0;
+
+ zOss_AssertEx(cmd != NULL, -1);
+ cmd_count = sizeof(gShell_Cmds) / sizeof(gShell_Cmds[0]);
+ for (i = 0; i < cmd_count; i++)
+ {
+ if (0 == stricmp((char *)cmd, (char *)gShell_Cmds[i].cmd))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-60s ", "***********************************************************************");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-20s %s", "* ÃüÁÄÜ:", gShell_Cmds[i].desc);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-20s ", "*ƽ̨֧³ÅÌṩ¸Ã¹¦ÄÜ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-60s ", "***********************************************************************");
+ return i;
+ }
+ }
+ return -1;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShell_FindDynamicCmd
+* ¹¦ÄÜÃèÊö£º²éÕÒ¶¯Ì¬ÃüÁî
+* ²ÎÊý˵Ã÷£º(IN)
+ cmd:ÃüÁî×Ö·û´®
+ (OUT)
+* ·µ »Ø Öµ£ºÕÒµ½ÁË·µ»ØÔÚÃüÁî±íµÄλÖã¬ÕÒ²»µ½·µ»ØÒ»¸ö¿ÕµÄλÖÃ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 Shell_FindDynamicCmd(const CHAR *cmd)
+{
+ UINT32 i = 0;
+
+ zOss_AssertEx(NULL != cmd, 0);
+ for (i = 0; i < SHELL_MAX_DYNAMIC_CMD; i++)
+ {
+ if (NULL != gShell_DynamicCmds[i].cmd)
+ {
+ if (0 == stricmp((char *)cmd, (char *)gShell_DynamicCmds[i].cmd))
+ {
+ return i;
+ }
+ }
+ else
+ {
+ return i;
+ }
+ }
+ return i;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShellFindStaticCmd
+* ¹¦ÄÜÃèÊö£º²éÕÒ¾²Ì¬µÄshellÃüÁî²¢Ìṩ°ïÖúÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN)
+ cmd:shellÃüÁî
+ cmdLen:shellÃüÁîµÄ³¤¶È
+ (OUT)
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 ShellHelpFindStaticCmd(CHAR *cmd, UINT32 cmdLen)
+{
+ UINT32 cmd_count = sizeof(gShell_Cmds) / sizeof(gShell_Cmds[0]);
+ UINT32 i = 0;
+ BOOL cmdIsDisplay = TRUE;
+
+ zOss_AssertEx(cmd != NULL && cmdLen != 0, ZOSS_ERROR);
+ for (i = 0; i < cmd_count; i++)
+ {
+ if (0 == strnicmp((char *)cmd, (char *)gShell_Cmds[i].cmd, (unsigned int)cmdLen))
+ {
+ if (cmdIsDisplay)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tÃüÁî: %s ûÓÐÕÒµ½!", cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s¿ªÍ·µÄÃüÁîÈçÏÂ:", cmd);
+ cmdIsDisplay = FALSE;
+ }
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-20s \t%s", gShell_Cmds[i].cmd, gShell_Cmds[i].desc);
+ }
+ }
+ if (cmdIsDisplay)
+ {
+ return ZOSS_ERROR;
+ }
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShellHelpFindDynamicCmd
+* ¹¦ÄÜÃèÊö£º²éÕÒ¶¯Ì¬shellÃüÁî
+* ²ÎÊý˵Ã÷£º(IN)
+ cmd:shellÃüÁî
+ cmdLen:shellÃüÁîµÄ³¤¶È
+ (OUT)
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 ShellHelpFindDynamicCmd(CHAR *cmd, UINT32 cmdLen)
+{
+ UINT32 i = 0;
+ BOOL cmdIsDisplay = TRUE;
+
+ zOss_AssertEx(cmd != NULL && cmdLen != 0, ZOSS_ERROR);
+ for (i = 0; i < SHELL_MAX_DYNAMIC_CMD && NULL != gShell_DynamicCmds[i].cmd; i++)
+ {
+ if (0 == strnicmp((char *)cmd, (char *)gShell_DynamicCmds[i].cmd, (unsigned int)cmdLen))
+ {
+ if (cmdIsDisplay)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tÃüÁî: %s ûÓÐÕÒµ½!", cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s¿ªÍ·µÄÃüÁîÈçÏÂ:", cmd);
+ cmdIsDisplay = FALSE;
+ }
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-20s \t%s", gShell_DynamicCmds[i].cmd, gShell_DynamicCmds[i].desc);
+ }
+ }
+ if (cmdIsDisplay)
+ {
+ return ZOSS_ERROR;
+ }
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShellHelpProcess
+* ¹¦ÄÜÃèÊö£ºµ±Ã»ÓÐÕÒµ½ÏàÓ¦µÄshellÃüÁîÌṩһЩ°ïÖúÐÅÏ¢
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:ÃüÁî½á¹¹Ö¸Õë
+ (OUT)
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID ShellHelpProcess(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT32 ret1 = ZOSS_ERROR;
+ UINT32 ret2 = ZOSS_ERROR;
+ CHAR *cmd = NULL;
+ UINT32 cmp_len = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+ cmd = CmdMsg->cmd;
+ cmp_len = strlen((char *)cmd);
+ ret1 = ShellHelpFindStaticCmd(cmd, cmp_len);
+ ret2 = ShellHelpFindDynamicCmd(cmd, cmp_len);
+ if ((ZOSS_ERROR == ret1) && (ZOSS_ERROR == ret2))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t%sÃüÁî²»ÊÇshellÃüÁî!", cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tÊäÈëhelpÁгöËùÓÐÃüÁî");
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºshell_help
+* ¹¦ÄÜÃèÊö£ºShell helpÃüÁî´¦Àí
+* ²ÎÊý˵Ã÷£º(IN)
+ pCmdMsg:ÃüÁî½á¹¹Ö¸Õë
+ (OUT)
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID Shell_help(T_Shell_CommandMessage *pCmdMsg)
+{
+ SINT32 cmdCount = sizeof(gShell_Cmds) / sizeof(gShell_Cmds[0]);
+ SINT32 i = 0;
+ CHAR *cmd = NULL;
+ SINT32 cmpLen = 0;
+ UINT32 ret = 0;
+
+ zOss_AssertExN(pCmdMsg != NULL);
+ if (1 != pCmdMsg->paraCount)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓйØÃüÁîµÄÏêϸÐÅÏ¢£¬Çë¼üÈëhelp º¯ÊýÃû");
+
+ for (i = 0; i < cmdCount; i++)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-20s \t%s", gShell_Cmds[i].cmd, gShell_Cmds[i].desc);
+ }
+ for (i = 0; i < SHELL_MAX_DYNAMIC_CMD; i++)
+ {
+ if (NULL != gShell_DynamicCmds[i].cmd)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-20s \t%s", gShell_DynamicCmds[i].cmd, gShell_DynamicCmds[i].desc);
+ }
+ else
+ {
+ break;
+ }
+ }
+ }
+ else
+ {
+ cmd = pCmdMsg->para[0];
+ if (0 == strcmp((char *)cmd, "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\thelp:°ïÖú\n\t help [command]\n\t hÓëhelpͬÒå");
+ return;
+ }
+
+ i = Shell_findCmd(cmd);
+ if (i >= 0 && i < cmdCount)
+ {
+ cmpLen = strlen(pCmdMsg->para[0]);
+ zOss_Memcpy((char *)pCmdMsg->cmd, pCmdMsg->para[0],cmpLen);
+ pCmdMsg->cmd[cmpLen] = '\0';
+ strncpy((char *)pCmdMsg->para[0], "help", SHELL_CMD_PARAM_LENGTH);
+ pCmdMsg->para[0][SHELL_CMD_PARAM_LENGTH] = '\0';
+ gShell_Cmds[i].func(pCmdMsg);
+ return;
+ }
+ i = (long)Shell_FindDynamicCmd(cmd);
+ if (i >= SHELL_MAX_DYNAMIC_CMD)
+ return;
+
+ if (NULL != gShell_DynamicCmds[i].cmd)
+ {
+ cmpLen = strlen(pCmdMsg->para[0]);
+ zOss_Memcpy((char *)pCmdMsg->cmd, pCmdMsg->para[0],cmpLen);
+ pCmdMsg->cmd[cmpLen] = '\0';
+ strncpy((char *)pCmdMsg->para[0], "help", SHELL_CMD_PARAM_LENGTH);
+ pCmdMsg->para[0][SHELL_CMD_PARAM_LENGTH] = '\0';
+ gShell_DynamicCmds[i].func(pCmdMsg);
+ return;
+ }
+
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tÃüÁî: %s ûÓÐÕÒµ½!", cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s¿ªÍ·µÄÃüÁîÈçÏÂ:", cmd);
+ cmpLen = (long)strlen((char *)cmd);
+ ret = ZOSS_ERROR;
+ for (i = 0; i < cmdCount; i++)
+ {
+ if (0 == strnicmp((char *)cmd, (char *)gShell_Cmds[i].cmd, ( unsigned int )cmpLen))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-20s \t%s", gShell_Cmds[i].cmd, gShell_Cmds[i].desc);
+ ret = ZOSS_SUCCESS;
+ }
+ }
+ for (i = 0; i < SHELL_MAX_DYNAMIC_CMD; i++)
+ {
+ if (NULL != gShell_DynamicCmds[i].cmd)
+ {
+ if (0 == strnicmp((char *)cmd, (char *)gShell_DynamicCmds[i].cmd, ( unsigned int )cmpLen))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-20s \t%s", gShell_DynamicCmds[i].cmd, gShell_DynamicCmds[i].desc);
+ ret = ZOSS_SUCCESS;
+ }
+ }
+ else
+ {
+ break; /* ÃüÁîΪNULL,½áÊø²éÕÒ */
+ }
+ }
+ if (ZOSS_ERROR == ret)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tûÓÐ%s¿ªÍ·µÄÃüÁî!", cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tÊäÈëhelpÁгöËùÓÐÃüÁî");
+ }
+ }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_shell_mem.c b/cp/ps/plat/src/oss/sup/src/sup_shell_mem.c
new file mode 100755
index 0000000..57e448a
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_shell_mem.c
@@ -0,0 +1,885 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : sup_shell_mem.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : ÄÚ´æÏà¹ØµÄshellÃüÁî
+* ×÷ Õß : ´ú¿µ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2019-01-10
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_shell.h"
+#include "sup_shell_cmd.h"
+#include "sup_except.h"
+#include "osa.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#ifdef _DEBUG
+#define UBLEAKNUM 10000
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+typedef struct
+{
+ BOOL isUsed; /* ʹÓñê¼Ç */
+ UINT32 usingSize; /* ʵ¼ÊÕ¼ÓôóС */
+ CHAR name[ZOSS_UBHEAD_FILENAME_LEN + 1]; /* ÉêÇëλÖÃÎļþÃû */
+ UINT32 line; /* ÉêÇëλÖÃÐкŠ*/
+ ZOSS_THREAD_ID threadId; /* ÉêÇëÏß³ÌID */
+ ZOSS_TASK_ID taskId; /* ÉêÇëÈÎÎñºÅ */
+ UINT32 applyTimeTick; /* ÉêÇëʱ¼ä(TICK) */
+ UINT32 use_num; /* ʹÓôÎÊý */
+ UINT32 block_size; /* ub¿éµÄ´óС */
+}T_DbgMem_UBHead; /* ÄÚ´æÍ· */
+#endif
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+#ifdef _DEBUG
+extern UINT32 gMem_UBStart;
+extern T_ZOss_UBPOOL *gMem_UBPoolCfg;
+extern UINT32 gMem_UBPoolNum;
+extern UINT32 gUBSuperviseSitch;
+#endif
+
+#ifdef _OS_TOS
+extern cyg_bool zTos_MmuGetReadableRegion(cyg_uint32 start, cyg_uint32 end, cyg_uint32 *p_start, cyg_uint32 *p_end);
+extern cyg_bool zTos_MmuIsPageCanWrite(cyg_uint32 addr);
+#endif
+#ifdef _OS_OSE
+extern void list_pools(void);
+extern void list_all_sig_info(void);
+extern void list_proc_sig_info(PROCESS pid, OSBOOLEAN listDetail);
+extern BOOL mmu_get_readable_region( UINT32 begin, UINT32 end , UINT32 *p_begin, UINT32 *p_end );
+extern BOOL mmu_is_writeable(UINT32 v_addr);
+extern VOID mmu_generate_info(VOID);
+#endif
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+#ifdef _USE_HEAP_DEBUG
+static VOID shellSetMemTimeLeak(CHAR *cmd);
+#endif
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: shellSetUBDebugFlag
+* ¹¦ÄÜÃèÊö: Êä³ö°ïÖúÐÅÏ¢
+* ²ÎÊý˵Ã÷: (IN)
+ cmd:shellÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+#ifndef _OS_TOS
+static VOID shellSetUBDebugFlag(CHAR *cmd)
+{
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s n", cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t nÈ¡ÖµÕûÐÍ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t0±íʾ¹Ø±ÕUB µ÷ÊÔ¿ª¹Ø");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t·ÇÁãÖµ±íʾ´ò¿ªUB µ÷ÊÔ¿ª¹Ø");
+}
+#endif
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: shellSetMemTimeLeak
+* ¹¦ÄÜÃèÊö: Êä³ö°ïÖúÐÅÏ¢
+* ²ÎÊý˵Ã÷: (IN)
+ cmd:shellÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+#ifdef _USE_HEAP_DEBUG
+static VOID shellSetMemTimeLeak(CHAR *cmd)
+{
+ zOss_AssertExN(cmd != NULL);
+
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s \n", cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t¿ªÊ¼Ê±ÊäÈë %s leakstart й¶µÄ·§Öµ", cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t½áÊøʱÊäÈë %s leakend ", cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tй¶µÄ·§ÖµÖ¸¾¹ý¶à³¤Ê±¼ämemÈç¹ûûÓÐÊͷž͵±×öй¶");
+}
+#endif
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/* ÄÚ´æ¹Û²ì */
+VOID OSS_DbgShowMemInfo(T_Shell_CommandMessage *CmdMsg)
+{
+ T_Mem_MemInfo meminfo = {0};
+ UINT32 status = ZOSS_ERROR;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:ÏÔʾÄÚ´æ»ù±¾ÐÅÏ¢", CmdMsg->cmd);
+ return;
+ }
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t=====================================");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%10s %10s\t %10s","TotalMem","UsedMem","MaxFreeMem");
+
+ zOss_Memset(&meminfo, 0, sizeof(meminfo));
+ status = zOss_GetSysMemInfo(&meminfo);
+ if (ZOSS_SUCCESS == status)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%10d %10d\t %10d", meminfo.nMemTotal, meminfo.nMemUsed, meminfo.nMemMaxFree);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tGet mem info error!");
+ }
+
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t=====================================");
+ return;
+}
+
+VOID OSS_DbgShowUbInfo(T_Shell_CommandMessage *CmdMsg)
+{
+#ifdef _DEBUG
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:ÏÔʾÄÚ´æ³Ø»ù±¾ÐÅÏ¢,¸ÃÃüÁîÔÚtosƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s leak:ÏÔʾÄÚ´æ³Øй¶ÐÅÏ¢,¸ÃÃüÁîÔÚoseƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s stat:ÏÔʾÄÚ´æ³Øͳ¼ÆÐÅÏ¢,¸ÃÃüÁîÔÚoseƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+ return;
+ }
+# if defined (_OS_TOS) || defined (_OS_LINUX)
+ if (0 == CmdMsg->paraCount)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:¸ÃÃüÁîÔÚtosƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+ }
+ else if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "leak"))
+ {
+#ifdef _UB_USE_POOL
+ pool_print_leak(0);
+#endif
+ }
+ else if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "stat"))
+ {
+#ifdef _UB_USE_POOL
+ pool_print_alloc_fail();
+ pool_print_free();
+ pool_print_alloc_statistic();
+#endif
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈë%s help²éѯÓ÷¨", CmdMsg->cmd);
+ }
+
+ return;
+# else
+
+ if(0 == gUBSuperviseSitch)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tubµ÷ÊÔ¿ª¹Øδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+ }
+
+ if(0 == CmdMsg->paraCount)
+ {
+ T_Mem_UBPoolGrpInfo ub_pool_grp_info = {0};
+ UINT32 i = 0;
+
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ´óС ×ÜÊý ʹÓÃÊýÄ¿ ʹÓ÷åÖµ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t===============================================");
+ if (ZOSS_SUCCESS == Mem_GetUBUseInfo(&ub_pool_grp_info, 1))
+ {
+ for (i = 0; i < ub_pool_grp_info.pool_num; i++)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%10d %10d %10d %10d",
+ ub_pool_grp_info.pool_info[i].pool_size, ub_pool_grp_info.pool_info[i].total_block_num,
+ ub_pool_grp_info.pool_info[i].total_block_num - ub_pool_grp_info.pool_info[i].free_block_num,
+ ub_pool_grp_info.pool_info[i].peak_value);
+ }
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_SEVERE,"\tGet UB info error!");
+ }
+
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t===============================================");
+ }
+ else if (1 == CmdMsg->paraCount && (0 == strcmp((char *)CmdMsg->para[0], "leak") || 0 == strcmp((char *)CmdMsg->para[0], "stat")))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:¸ÃÃüÁîÔÚoseƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈë%s help²éѯÓ÷¨", CmdMsg->cmd);
+ }
+# endif
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tµ±Ç°Îªrelease°æ±¾£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+#endif
+}
+
+VOID OSS_DbgShowThreadUbInfo(T_Shell_CommandMessage *CmdMsg)
+{
+#ifdef _DEBUG
+ zOss_AssertExN(CmdMsg != NULL);
+
+# if defined (_OS_TOS) || defined (_OS_LINUX)
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:¸ÃÃüÁîÔÚtosƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+ return;
+# else
+
+ if (0 != gUBSuperviseSitch)
+ {
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:ÏÔʾָ¶¨Ïß³ÌÉêÇëµÄUB¿éÇé¿ö", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s [thread_id][ubNum][poolNum]", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t²ÎÊýthread_idΪָ¶¨Ïß³Ìid£¬²»ÄÜΪ¿Õ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t²ÎÊýubNum²éѯ¸ÃÏß³Ìub¿éµÄ×î´óÊýÄ¿");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t²ÎÊýpoolNumΪҪ²éѯµÄÄÚ´æ³ØºÅ£¬ÔÝÎÞЧ¹û£¬Æ½Ì¨Ä¬ÈÏΪ1");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t½á¹ûÏÔʾÁÐ˵Ã÷:");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tNum:UB¿éÐòºÅ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tUbSize:Õ¼ÓÃUB¿éµÄ´óС");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tUbUsingSize:ʵ¼ÊÕ¼ÓôóС");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tName:UB¿éÉêÇëÎļþ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tLine:UB¿éÉêÇëÐкÅ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tUbBlockAdd:UB¿éµØÖ·");
+ return;
+ }
+ else if (3 == CmdMsg->paraCount)
+ {
+ T_Mem_UBBlockInfo *threadUbInfo = NULL;
+ T_Mem_UBBlockInfo *pUbInfoStart = NULL;
+ ZOSS_THREAD_ID threadId = NULL;
+ UINT32 threadUbRealNum = 0;
+ UINT32 i = 0;
+ UINT32 maxNum = 0;
+ UINT8 poolNum = 1;
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t===========================================================================");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-10s%-10s%10s%10s%10s%20s","Num","UbSize", "UbUsingSize","Name","Line","UbBlockAdd");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t===========================================================================");
+
+ if (-1 == Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tthread_id²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ return;
+ }
+ threadId = (ZOSS_THREAD_ID)strtoul((char *)CmdMsg->para[0], NULL, 0);
+ if (NULL == threadId)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tthread_id²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ return;
+ }
+
+ maxNum = (UINT32)atoi((const char *)CmdMsg->para[1]);
+ if(0 == maxNum)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tmaxNum²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ return;
+ }
+
+ threadUbInfo = (T_Mem_UBBlockInfo *)zOss_Malloc(maxNum * sizeof(T_Mem_UBBlockInfo));
+ zOss_AssertExN(threadUbInfo != NULL);
+ pUbInfoStart = threadUbInfo;
+
+ threadUbRealNum = Mem_ThreadUBInfo(threadId, threadUbInfo, maxNum, poolNum);
+ if (0 == threadUbRealNum)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t¸ÃÏß³Ì0x%XÔÚ%dºÅÄÚ´æ³ØµÄUBÊýÁ¿Îª0", threadId, poolNum);
+ }
+ else
+ {
+ for (i = 0; i < threadUbRealNum; i++)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-10d%-10d%10d%10s%10d%10X", i + 1,
+ threadUbInfo->ubBlockSize, threadUbInfo->usingSize,
+ threadUbInfo->name, threadUbInfo->line, threadUbInfo->ubBlock);
+ threadUbInfo++;
+ }
+ }
+ zOss_Free(pUbInfoStart);
+ pUbInfoStart = NULL;
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ }
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tubµ÷ÊÔ¿ª¹Øδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+ }
+# endif
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tµ±Ç°Îªrelease°æ±¾£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+#endif
+}
+
+VOID OSS_DbgShowTaskUbInfo(T_Shell_CommandMessage *CmdMsg)
+{
+#ifdef _DEBUG
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+# if defined (_OS_TOS) || defined (_OS_LINUX)
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:¸ÃÃüÁîÔÚtosƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+ return;
+# else
+
+ if (0 != gUBSuperviseSitch)
+ {
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:ÏÔʾָ¶¨ÈÎÎñÉêÇëµÄUB¿éÇé¿ö", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s [task_id][ubNum][poolNum]", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t²ÎÊýtask_idΪָ¶¨ÈÎÎñid£¬²»ÄÜΪ¿Õ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t²ÎÊýubNum²éѯ¸ÃÈÎÎñub¿éµÄ×î´óÊýÄ¿");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t²ÎÊýpoolNumΪҪ²éѯµÄÄÚ´æ³ØºÅ£¬ÔÝÎÞЧ¹û£¬Æ½Ì¨Ä¬ÈÏΪ1");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t½á¹ûÏÔʾÁÐ˵Ã÷:");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tUBNumber:UB¿éÐòºÅ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tUBsize:Õ¼ÓÃUB¿éµÄ´óС");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tUBsize:ʵ¼ÊÕ¼ÓôóС");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tUBsize:UB¿éÉêÇëÎļþ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tUBsize:UB¿éÉêÇëÐкÅ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\tUBsize:UB¿éµØÖ·");
+ return;
+ }
+ else if (3 == CmdMsg->paraCount)
+ {
+ T_Mem_UBBlockInfo *taskUbInfo = NULL;
+ T_Mem_UBBlockInfo *pTaskUbInfoStart = NULL;
+ ZOSS_TASK_ID taskId = NULL;
+ UINT32 taskUbRealNum = 0;
+ UINT32 i = 0;
+ UINT32 maxNum = 0;
+ UINT8 poolNum = 1;
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t===========================================================================");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-10s%-10s%10s%10s%10s%20s", "Num", "UbSize", "UbUsingSize", "Name", "Line", "UbBlockAdd");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t===========================================================================");
+
+ if (-1 == Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\ttaskId²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ return;
+ }
+ taskId = (ZOSS_TASK_ID)strtoul((char *)CmdMsg->para[0], NULL, 0);
+ if (NULL == taskId)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\ttaskId²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ return;
+ }
+
+ maxNum = (UINT32)atoi((const char *)CmdMsg->para[1]);
+ if(0 == maxNum)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tmaxNum²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ return;
+ }
+
+ taskUbInfo = (T_Mem_UBBlockInfo *)zOss_Malloc(maxNum * sizeof(T_Mem_UBBlockInfo));
+ zOss_AssertExN(taskUbInfo != NULL);
+ pTaskUbInfoStart = taskUbInfo;
+
+ taskUbRealNum = Mem_TaskUBInfo(taskId, taskUbInfo ,maxNum, poolNum);
+ if (taskUbRealNum == 0)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t¸ÃÈÎÎñ0x%XÔÚ%dºÅÄÚ´æ³ØµÄUBÊýÁ¿Îª0", taskId, poolNum);
+ }
+ else
+ {
+ for (i = 0; i < taskUbRealNum; i++)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-10d%-10d%10d%10s%10d%10X", i + 1, taskUbInfo->ubBlockSize, taskUbInfo->usingSize,
+ taskUbInfo->name, taskUbInfo->line, taskUbInfo->ubBlock);
+
+ taskUbInfo++;
+ }
+ }
+ zOss_Free(pTaskUbInfoStart);
+ pTaskUbInfoStart = NULL;
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ }
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tubµ÷ÊÔ¿ª¹Øδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ\n");
+ return;
+ }
+# endif
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tµ±Ç°Îªrelease°æ±¾£¬´Ë¹¦ÄܽûÓÃ\n");
+ return;
+#endif
+}
+
+/* µ×²ãµ÷ÊÔÖ¸Áî */
+VOID OSS_DbgGetMem(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT8 *pData = NULL;
+ UINT32 len = 0;
+ UINT32 i = 0;
+ CHAR *pbuf = NULL;
+#if (defined _OS_TOS && defined CYGOPT_HAL_ARM_MMU) || defined _OS_OSE
+ UINT32 end = 0;
+ UINT32 regionStart = 0;
+ UINT32 regionEnd = 0;
+#endif
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tshowMem µØÖ·(Äܹ»±»4Õû³ý) ³¤¶È[1-256], ·ÃÎÊδ֪ÇøÓò¿ÉÄܵ¼ÖÂÒì³£, ½÷É÷ʹÓÃ!");
+ return;
+ }
+ else
+ {
+ if (2 == CmdMsg->paraCount)
+ {
+ if (0 != Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý%sÈ¡ÖµÖ»ÄÜÊÇÊý×Ö(10½øÖÆ»ò16½øÖÆ)", CmdMsg->para[0]);
+ return;
+ }
+ pData = (UINT8 *)(strtoul((char *)CmdMsg->para[0], (char **)NULL, 0));
+ if (0 != ((UINT32)pData) % 4)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tµØÖ·0x%x(%u)²»Äܱ»4Õû³ý!", pData, pData);
+ return;
+ }
+ if (0 != Shell_StrisNumber(CmdMsg->para[1]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý%sÈ¡ÖµÖ»ÄÜÊÇÊý×Ö(10½øÖÆ»ò16½øÖÆ)", CmdMsg->para[1]);
+ return;
+ }
+
+ len = strtoul((char *)CmdMsg->para[1], (char **)NULL, 0);
+ if (!(len > 0 && len <= 256))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tÊý¾Ý0x%x(%u)·¶Î§²»¶Ô[1-256]!", len, len);
+ return;
+ }
+#if defined _OS_TOS && defined CYGOPT_HAL_ARM_MMU
+ end = (UINT32)pData + ((len - 1) / 16 + 1) * 16 - 1;
+ zTos_MmuGetReadableRegion((UINT32)pData, end, (cyg_uint32 *)®ionStart, (cyg_uint32 *)®ionEnd);
+ if((UINT32)pData != regionStart || end > regionEnd)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tµØÖ·0x%x(%u)~0x%x(%u)´íÎó!", pData, pData, end, end);
+ return;
+ }
+#endif
+#ifdef _OS_OSE
+ end = (UINT32)pData + ((len - 1) / 16 + 1) * 16 - 1;
+ mmu_generate_info();
+ mmu_get_readable_region((UINT32)pData, end, ®ionStart, ®ionEnd);
+ if((UINT32)pData != regionStart || end != regionEnd)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tµØÖ·0x%x(%u)~0x%x(%u)´íÎó!", pData, pData, end, end);
+ return;
+ }
+#endif
+ pbuf = (CHAR *)zOss_Malloc(256);
+ if (NULL == pbuf)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tzOss_Mallocʧ°Ü");
+ return;
+ }
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t==============================");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tµØÖ· Êý¾Ý");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t 0 1 2 3 4 5 6 7 8 9 A B C D E F");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t==============================");
+ for (i = 0; i < len; i += 16)
+ {
+ sprintf((char *)pbuf, "\t0x%08x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x : %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",
+ (int)pData, pData[0], pData[1], pData[2], pData[3], pData[4], pData[5], pData[6], pData[7], pData[8], pData[9], pData[10], pData[11], pData[12], pData[13], pData[14], pData[15],
+ CHAR_PRT(pData[0]), CHAR_PRT(pData[1]), CHAR_PRT(pData[2]), CHAR_PRT(pData[3]), CHAR_PRT(pData[4]), CHAR_PRT(pData[5]), CHAR_PRT(pData[6]), CHAR_PRT(pData[7]),
+ CHAR_PRT(pData[8]), CHAR_PRT(pData[9]), CHAR_PRT(pData[10]), CHAR_PRT(pData[11]), CHAR_PRT(pData[12]), CHAR_PRT(pData[13]), CHAR_PRT(pData[14]), CHAR_PRT(pData[15]));
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "%s", pbuf);
+ pData += 16;
+ }
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t==============================");
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý²»¶Ô!ÊäÈëshowMem help²é¿´°ïÖú");
+ }
+ }
+
+ if (NULL != pbuf)
+ {
+ zOss_Free(pbuf);
+ }
+}
+
+VOID OSS_DbgSetMem(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT32 *pData = NULL;
+ UINT32 data = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tsetMem µØÖ·(Äܹ»±»4Õû³ý) ÊýÖµ(ÎÞ·ûºÅÕûÐÍ·¶Î§ÄÚ), ·ÃÎÊδ֪ÇøÓò¿ÉÄܵ¼ÖÂÒì³£, ½÷É÷ʹÓÃ!");
+ return;
+ }
+ else
+ {
+ if (2 == CmdMsg->paraCount)
+ {
+ if (0 != Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý%sÈ¡ÖµÖ»ÄÜÊÇÊý×Ö(10½øÖÆ»ò16½øÖÆ)", CmdMsg->para[0]);
+ return;
+ }
+ pData = (UINT32 *)(strtoul((char *)CmdMsg->para[0], (char **)NULL, 0));
+ if (0 != ((UINT32)pData) % 4)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tµØÖ·0x%x(%u)²»Äܱ»4Õû³ý!", pData, pData);
+ return;
+ }
+#if defined (_OS_TOS) && defined (CYGOPT_HAL_ARM_MMU)
+ if(!zTos_MmuIsPageCanWrite((UINT32)pData))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tµØÖ·0x%x(%u)²»ÔÊÐíд!", pData, pData);
+ return;
+ }
+#endif
+#ifdef _OS_OSE
+ if(!mmu_is_writeable((UINT32)pData))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tµØÖ·0x%x(%u)²»ÔÊÐíд!", pData, pData);
+ return;
+ }
+#endif
+ if (0 != Shell_StrisNumber(CmdMsg->para[1]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý%sÈ¡ÖµÖ»ÄÜÊÇÊý×Ö(10½øÖÆ»ò16½øÖÆ)", CmdMsg->para[1]);
+ return;
+ }
+ data = strtoul((char *)CmdMsg->para[1], (char **)NULL, 0);
+ *pData = data;
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÐ޸ĵØÖ·0x%x(%u)µÄÊý¾ÝΪ0x%x(%u)³É¹¦", pData, pData, data, data);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý²»¶Ô!ÊäÈësetMem help²é¿´°ïÖú");
+ }
+ }
+}
+
+VOID Shell_ShowPoolInfo(T_Shell_CommandMessage *CmdMsg)
+{
+ zOss_AssertExN(CmdMsg != NULL);
+
+#ifdef _OS_TOS
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:¸ÃÃüÁîÔÚtosƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+#endif
+
+#ifdef _OS_OSE
+ switch (CmdMsg->paraCount)
+ {
+ case 0:
+ {
+ zOss_Printf(SUBMDL_TEST,PRINT_LEVEL_NORMAL, "\t===============================================================================");
+ list_pools();
+ zOss_Printf(SUBMDL_TEST,PRINT_LEVEL_NORMAL, "===============================================================================");
+ break;
+ }
+ default:
+ {
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s", CmdMsg->cmd);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²ÎÊý´íÎó£¬Çë¼üÈë%s help²é¿´ÃüÁî˵Ã÷", CmdMsg->cmd);
+ }
+ break;
+ }
+ }
+#endif
+
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSS_SetMenDbgFlag
+* ¹¦ÄÜÃèÊö: ´ò¿ªubµ÷ÊÔ¿ª¹Ø
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:shell ÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+VOID OSA_SetUBDbgSwitch(T_Shell_CommandMessage *CmdMsg)
+{
+#ifdef _OS_TOS
+ zOss_AssertExN(CmdMsg != NULL);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:¸ÃÃüÁîÔÚtosƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+ return;
+#elif defined (_OS_LINUX)
+
+#else
+ UINT32 tmp = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 != CmdMsg->paraCount)
+ {
+ shellSetUBDebugFlag(CmdMsg->cmd);
+ return;
+ }
+ if (-1 == Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ shellSetUBDebugFlag(CmdMsg->cmd);
+ return;
+ }
+
+ tmp = strtoul((char*)CmdMsg->para[0], NULL, 0);
+ zOss_SetUbDbgSwitch(tmp);
+ if (tmp)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t³É¹¦´ò¿ªubµÄµ÷ÊÔ¿ª¹Ø");
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t³É¹¦¹Ø±ÕubµÄµ÷ÊÔ¿ª¹Ø");
+ }
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSA_DbgMemInfo
+* ¹¦ÄÜÃèÊö: ¼ì²émemµÄʹÓÃÐÅÏ¢(й¶ºÍÔ½½ç)
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:shellÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+VOID OSA_DbgMemInfo(T_Shell_CommandMessage *CmdMsg)
+{
+#ifdef _USE_HEAP_DEBUG
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if(CmdMsg->paraCount == 0)
+ {
+ zOss_CheckMem();
+ }
+ else if (CmdMsg->paraCount == 1 && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s", CmdMsg->cmd);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÊäÈë%s help ²é¿´ÃüÁîÓ÷¨", CmdMsg->cmd);
+ }
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t_USE_HEAP_DEBUGδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSA_DbgMemTimeLeakInfo
+* ¹¦ÄÜÃèÊö: ¼ì²éµÄij¸öʱ¼ä¶ÎMemµÄй¶ÐÅÏ¢
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:shellÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+VOID OSA_DbgMemTimeLeakInfo(T_Shell_CommandMessage *CmdMsg)
+{
+#ifdef _USE_HEAP_DEBUG
+ UINT32 tmp = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if ((CmdMsg->paraCount == 2) && (0 == strcmp((const char *)CmdMsg->para[0], "leakstart")))
+ {
+ if (-1 == Shell_StrisNumber(CmdMsg->para[1]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²ÎÊý´íÎó");
+ return;
+ }
+ tmp = strtoul((char*)CmdMsg->para[1], NULL, 0);
+ zOss_MemLeakStart(tmp);
+ }
+ else if ((CmdMsg->paraCount == 1) && (0 == strcmp((const char *)CmdMsg->para[0], "leakend")))
+ {
+ zOss_MemLeakEnd();
+ }
+ else
+ {
+ shellSetMemTimeLeak(CmdMsg->cmd);
+ }
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t_USE_HEAP_DEBUGδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSA_UBLeakInfo
+* ¹¦ÄÜÃèÊö: ¸ù¾ÝÄÚ´æºÅͳ¼ÆÄÚ´æ³ØµÄʹÓÃÇé¿ö
+* ²ÎÊý˵Ã÷: (IN)
+ poolNum:ÄÚ´æ³ØºÅ
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+VOID OSA_UBLeakInfo(UINT32 poolNum)
+{
+#if defined (_OS_OSE) || defined (_OS_WIN)
+#if defined (_DEBUG)
+ T_Mem_UBPoolCtl *pUbControlStart = NULL;
+ T_Mem_UBListNode *pUbListNodeStart = NULL;
+ UINT32 i = 0;
+ UINT32 j = 0;
+ UINT32 k = 0;
+ UINT32 tmpPoolNum = 0;
+ T_Mem_UBListNode *pUbListNodeTemp = NULL;
+ T_DbgMem_UBHead *pUBDbgLeakInfo = NULL;
+ T_DbgMem_UBHead *pTmpUBDbgLeakInfo = NULL;
+ UINT32 UBLeakNum = 0;
+ UINT32 tmpSize = 0;
+
+ tmpPoolNum = poolNum;
+ pUbControlStart = (T_Mem_UBPoolCtl *)gMem_UBStart;
+ pUbListNodeStart = (T_Mem_UBListNode *)(pUbControlStart + gMem_UBPoolNum);
+ pUbListNodeTemp = pUbListNodeStart;
+ tmpSize = sizeof(T_DbgMem_UBHead) * gMem_UBPoolCfg[tmpPoolNum].total_block_num;
+
+ pUBDbgLeakInfo = (T_DbgMem_UBHead *)zOss_Malloc(tmpSize);
+
+ zOss_AssertExN(NULL != pUBDbgLeakInfo);
+
+ zOss_Memset(pUBDbgLeakInfo, 0, tmpSize);
+ pTmpUBDbgLeakInfo = pUBDbgLeakInfo;
+ for (i = 0; i < tmpPoolNum; i++)
+ {
+ pUbListNodeTemp = pUbListNodeTemp + gMem_UBPoolCfg[i].total_block_num;
+ }
+
+ for (j = 0; j < gMem_UBPoolCfg[tmpPoolNum].total_block_num; j++)
+ {
+ if (pUbListNodeTemp->ubBlockHeader.isUsed == TRUE)
+ {
+ for (k = 0; k < UBLeakNum; k++)
+ {
+ pTmpUBDbgLeakInfo = pUBDbgLeakInfo + k;
+ if ((0 == strcmp((char *)pTmpUBDbgLeakInfo->name, (char *)pUbListNodeTemp->ubBlockHeader.name)) &&
+ (pTmpUBDbgLeakInfo->line == pUbListNodeTemp->ubBlockHeader.line) &&
+ (pTmpUBDbgLeakInfo->usingSize == pUbListNodeTemp->ubBlockHeader.usingSize) &&
+ (pTmpUBDbgLeakInfo->taskId == pUbListNodeTemp->ubBlockHeader.taskId) &&
+ (pTmpUBDbgLeakInfo->threadId == pUbListNodeTemp->ubBlockHeader.threadId))
+ {
+ ++pTmpUBDbgLeakInfo->use_num;
+ break;
+ }
+
+ }
+ if (k >= UBLeakNum)
+ {
+ pTmpUBDbgLeakInfo = pUBDbgLeakInfo + UBLeakNum;
+ zOss_Memcpy(pTmpUBDbgLeakInfo, (char *)pUbListNodeTemp, sizeof(T_Mem_UBListNode) - 4); /* ¿½±´ÄÚ´æÍ· */
+ pTmpUBDbgLeakInfo->use_num = 1;
+ ++UBLeakNum;
+ }
+ }
+ pUbListNodeTemp++;
+ }
+
+ for (i = 0; i < UBLeakNum; i++)
+ {
+ pTmpUBDbgLeakInfo = pUBDbgLeakInfo + i;
+ zOss_Printf(SUBMDL_OSA, PRINT_LEVEL_SEVERE, "\tÄÚ´æ¿éÒÑʹÓôóС:%-8d й©ÎļþÃû×Ö:%-30s ÐкÅ:%-8d Ïß³ÌID :0x%08x ÈÎÎñID :0x%08x ʹÓôÎÊý:%-8d",
+ pTmpUBDbgLeakInfo->usingSize, pTmpUBDbgLeakInfo->name, pTmpUBDbgLeakInfo->line, pTmpUBDbgLeakInfo->threadId,
+ pTmpUBDbgLeakInfo->taskId, pTmpUBDbgLeakInfo->use_num);
+ }
+
+ zOss_Sleep(1000);
+ zOss_Free(pUBDbgLeakInfo);
+#endif // #if defined (_DEBUG)
+#endif // #if defined (_OS_OSE) || defined (_OS_WIN)
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSA_DbgUbInfo
+* ¹¦ÄÜÃèÊö: ubµ÷ÊÔÐÅÏ¢
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:shellÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+VOID OSA_DbgUbInfo(T_Shell_CommandMessage *CmdMsg)
+{
+#ifdef _DEBUG
+ zOss_AssertExN(CmdMsg != NULL);
+# if defined (_OS_TOS) || defined (_OS_LINUX)
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:¸ÃÃüÁîÔÚtosƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+ return;
+# else
+
+ if(0 == gUBSuperviseSitch)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tubµ÷ÊÔ¿ª¹Øδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+ }
+
+ if(CmdMsg->paraCount == 0)
+ {
+ UINT32 pool_num = 0;
+ for (pool_num = 0; pool_num < gMem_UBPoolNum; pool_num++)
+ {
+ OSA_UBLeakInfo(pool_num);
+ }
+ }
+ else if (CmdMsg->paraCount == 1 && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s", CmdMsg->cmd);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÊäÈë%s help ²é¿´ÃüÁîÓ÷¨", CmdMsg->cmd);
+ }
+# endif
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_shell_misc.c b/cp/ps/plat/src/oss/sup/src/sup_shell_misc.c
new file mode 100755
index 0000000..139f7a8
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_shell_misc.c
@@ -0,0 +1,943 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : sup_shell_misc.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : misc shellÃüÁî
+* ×÷ Õß : ´ú¿µ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2019-01-10
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_shell.h"
+#include "sup_shell_cmd.h"
+#include "sup_except.h"
+#include "osa.h"
+
+#ifdef _USE_MULTI_CORE_RAMDUMP
+#include "sup_ramdump.h"
+#else
+#include "osa_ramdump.h"
+#endif
+
+#ifdef _OS_LINUX
+#include <linux/kernel.h>
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* Íⲿº¯ÊýÉùÃ÷Çø
+**************************************************************************/
+#ifdef _OS_LINUX
+extern UINT32 zOss_SetProcessPri(VOID *thread_id, UINT32 priority);
+extern UINT32 zOss_GetProcessPri(VOID *thread_id, UINT32 priority);
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#ifdef _OS_TOS
+# define GMON_OUT_FILE "/c/gmon.out"
+#endif
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShell_SetIrqLogFlag
+* ¹¦ÄÜÃèÊö£ºÉèÖÃÖжϵ÷ÊÔÐÅÏ¢µÄflag
+* ²ÎÊý˵Ã÷£º(IN)
+ flag:´ò¿ª»ò¹Ø±ÕµÄ±êÖ¾;
+ (OUT)
+ ÎÞ;
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID Shell_SetIrqLogFlag(UINT32 flag)
+{
+#ifdef TOS_STATISTIC_IRQ
+ if (flag == 0)
+ {
+ tos_statistic_irq_close();
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ³É¹¦¹Ø±ÕÖжÏͳ¼Æ¹¦ÄÜ;");
+ }
+ else
+ {
+ tos_statistic_irq_open();
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ³É¹¦´ò¿ªÖжÏͳ¼Æ¹¦ÄÜ;");
+ }
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ºêTOS_STATISTIC_IRQûÓдò¿ª;");
+#endif
+
+#ifdef TOS_TRACE_IRQ
+ if (flag == 0)
+ {
+ tos_trace_irq_close();
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ³É¹¦¹Ø±ÕÖжϸú×Ù¹¦ÄÜ;");
+ }
+ else
+ {
+ tos_trace_irq_open();
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ³É¹¦´ò¿ªÖжϸú×Ù¹¦ÄÜ;");
+ }
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ºêTOS_TRACE_IRQûÓдò¿ª;");
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºShell_SetThreadLogFlag
+* ¹¦ÄÜÃèÊö£ºÉèÖÃÏ̵߳÷ÊÔÐÅÏ¢µÄflag
+* ²ÎÊý˵Ã÷£º(IN)
+ flag:´ò¿ª»ò¹Ø±ÕµÄ±êÖ¾;
+ (OUT)
+ ÎÞ;
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID Shell_SetThreadLogFlag(UINT32 flag)
+{
+#ifdef OSS_TRACE_THREAD
+ if (flag == 0)
+ {
+ oss_trace_thread_close();
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ³É¹¦¹Ø±ÕÏ̸߳ú×Ù¹¦ÄÜ;");
+ }
+ else
+ {
+ oss_trace_thread_open();
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ³É¹¦´ò¿ªÏ̸߳ú×Ù¹¦ÄÜ;");
+ }
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ºêOSS_TRACE_THREADûÓдò¿ª;");
+#endif
+}
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/* »ù±¾ÃüÁî */
+VOID OSS_DbgShowBootInfo(T_Shell_CommandMessage *CmdMsg)
+{
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:´òÓ¡Æô¶¯ÐÅÏ¢", CmdMsg->cmd);
+ return;
+ }
+
+ zOss_RamPrintf();
+}
+
+VOID OSS_DbgSetWintracePrintFlag(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT32 type = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s type", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\ttype:È¡Öµ0»ò1¡£1±íʾ´ò¿ª£¬0±íʾ¹Ø±Õ");
+ return;
+ }
+ else
+ {
+ if (1 == CmdMsg->paraCount)
+ {
+ if (0 != Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\ttypeÖ»ÄÜÈ¡ÖµÊÇÊý×Ö");
+ return;
+ }
+ type = strtoul((char *)CmdMsg->para[0], (char **)NULL, 0);
+ if (type < 2)
+ {
+ Shell_SetPrintFlag(type);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\ttype:È¡Öµ0»ò1¡£1±íʾ´ò¿ª£¬0±íʾ¹Ø±Õ");
+ }
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó£¬ÊäÈë%s help»ñµÃ°ïÖú", CmdMsg->cmd);
+ }
+ }
+}
+
+VOID OSS_DbgRamdumpConfigRegionInfo (T_Shell_CommandMessage *CmdMsg)
+{
+#ifdef _USE_MULTI_CORE_RAMDUMP
+ T_zOss_RamdumpRegion regionInfo = {0};
+#else
+ UINT32 base = 0;
+ UINT32 size = 0;
+ UINT32 map_base = 0;
+ UINT32 copy_base = 0;
+#endif
+ zOss_AssertExN(CmdMsg != NULL);
+
+ switch (CmdMsg->paraCount)
+ {
+ case 1:
+ {
+ if (0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL,
+ "\tÅäÖõ¼³öÄÚ´æÇøÓò£¬ÒÔ16½øÖÆÐÎʽÊäÈëÄÚ´æÆðʼµØÖ·ºÍÄÚ´æ¶Î´óС£¬ÖмäÓÿոñ¸ô¿ª");
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈëramdumpConfigRegion help²éѯÓ÷¨");
+ }
+ break;
+ }
+ case 2:
+ {
+ if (-1 == Shell_StrisNumber(CmdMsg->para[0]) || -1 == Shell_StrisNumber(CmdMsg->para[1]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈëramdumpConfigRegion help²éѯÓ÷¨");
+ break;
+ }
+#ifdef _USE_MULTI_CORE_RAMDUMP
+ regionInfo.baseForServer = strtoul((char *)CmdMsg->para[0], NULL, 16);
+ regionInfo.size = strtoul((char *)CmdMsg->para[1], NULL, 16);
+ regionInfo.baseForSelf = regionInfo.baseForServer;
+ regionInfo.baseForCopy = 0;
+
+ zOss_RamdumpConfigureMem(®ionInfo);
+#else
+ base = strtoul((char *)CmdMsg->para[0], NULL, 16);
+ size = strtoul((char *)CmdMsg->para[1], NULL, 16);
+ map_base = base;
+ copy_base = 0;
+
+ zOss_RamdumpConfigureMem(base, size, map_base, copy_base);
+#endif
+ break;
+ }
+ default:
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈëramdumpConfigRegion help²éѯÓ÷¨");
+ break;
+ }
+ }
+}
+
+VOID OSS_DbgShowMsg(T_Shell_CommandMessage *CmdMsg)
+{
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t¸ÃÃüÁîδʵÏÖ");
+}
+
+#if defined(__ARMCC_VERSION) && __ARMCC_VERSION > 220000
+__asm shell_GetR11(VOID)
+{
+ mov r0, r11
+ bx lr
+}
+#endif
+
+VOID OSS_DbgShowRegInfo(T_Shell_CommandMessage *CmdMsg)
+{
+#if defined(__ARMCC_VERSION) && __ARMCC_VERSION > 220000
+ UINT32 Reg11 = 0;
+ UINT32 spReg = 0;
+ UINT32 pcReg = 0;
+ UINT32 lrReg = 0;
+ UINT32 cReg = 0;
+ UINT32 sReg = 0;
+#endif
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s", CmdMsg->cmd);
+ return;
+ }
+
+#if defined(__ARMCC_VERSION) && __ARMCC_VERSION > 220000
+ Reg11 = shell_GetR11();
+ __asm
+ {
+ MOV spReg, __current_sp()
+ MOV pcReg, __current_pc()
+ MOV lrReg, __return_address()
+ MRS cReg, CPSR
+ MRS sReg, SPSR
+ }
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tfp:0x%08x", Reg11);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tsp:0x%08x", spReg);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tpc:0x%08x", pcReg);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tlr:0x%08x", lrReg);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tcpsr:0x%08x", cReg);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tspsr:0x%08x", sReg);
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t¸Ã¹¦ÄÜδʵÏÖ");
+#endif
+}
+
+VOID OSS_DbgReboot(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT32 type = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\treboot type");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\ttype:È¡Öµ1»ò2¡£1±íʾÈí¼þÖØÆô£¬2±íʾӲ¼þÖØÆô");
+ return;
+ }
+ else
+ {
+ if (1 == CmdMsg->paraCount)
+ {
+ if (0 != Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\ttypeÖ»ÄÜÈ¡ÖµÊÇÊý×Ö");
+ return;
+ }
+ type = strtoul((char *)CmdMsg->para[0], (char **)NULL, 0);
+ switch (type)
+ {
+ case 1:
+ {
+ zOss_SysSoftReset(SYS_RESET_TO_NORMAL);
+ break;
+ }
+ case 2:
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tº¯Êý½Ó¿Ú»¹Î´ÊµÏÖ");
+ break;
+ }
+ default:
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\ttype:0x%x(%u)È¡Öµ´íÎó£¬ÊäÈëreboot help»ñµÃ°ïÖú", type, type);
+ break;
+ }
+ }
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó£¬ÊäÈëreboot help»ñµÃ°ïÖú");
+ }
+ }
+}
+
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: ÌáÈ¡³öprofileÊý¾Ý
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) void
+* (´«³ö²ÎÊý) void
+* void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: void
+**************************************************************************/
+VOID Shell_ProfileRecords(VOID)
+{
+#if defined (_OS_TOS) && defined (CYGPKG_PROFILE_GPROF)
+ FILE *file = NULL;
+ UINT32 bucket = 0;
+ UINT32 size = 0;
+ CHAR* buf = NULL;
+ CHAR* hist_data_start = NULL;
+ profile_records_t *profile_records_ptr = NULL;
+
+ profile_records_ptr = cyg_profile_get_records();
+ size = sizeof(struct gmon_hdr)+
+ sizeof(profile_records_ptr->profile_tags[0])+
+ sizeof(struct gmon_hist_hdr)+
+ profile_records_ptr->profile_hist_hdr.hist_size*sizeof(profile_time_t);
+
+ buf = (CHAR *)zOss_Malloc(size);
+ if (!buf)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t·ÖÅä¿Õ¼äʧ°Ü!");
+ return;
+ }
+
+ hist_data_start = buf + sizeof(struct gmon_hdr)
+ + sizeof(profile_records_ptr->profile_tags[0])
+ + sizeof(struct gmon_hist_hdr);
+
+ zOss_Memset(buf, 0, size);
+ zOss_Memcpy(buf, &profile_records_ptr->profile_gmon_hdr, sizeof(struct gmon_hdr));
+ zOss_Memcpy(buf+sizeof(struct gmon_hdr),
+ &profile_records_ptr->profile_tags[0],
+ sizeof(profile_records_ptr->profile_tags[0]));
+ zOss_Memcpy(buf+sizeof(struct gmon_hdr) + sizeof(profile_records_ptr->profile_tags[0]),
+ &profile_records_ptr->profile_hist_hdr,
+ sizeof(struct gmon_hist_hdr));
+#ifdef CYGPKG_PROFILE_HIST_HOOK
+ for (bucket = 0; bucket < profile_records_ptr->profile_hist_hdr.hist_size; bucket++)
+ {
+ if (profile_records_ptr->profile_hist_data_ptr[bucket].sum_time)
+ zOss_Memcpy((hist_data_start + sizeof(profile_time_t)*bucket),
+ &(profile_records_ptr->profile_hist_data_ptr[bucket].sum_time),
+ sizeof(profile_time_t));
+ }
+#else
+ zOss_Memcpy(hist_data_start, profile_records_ptr->profile_hist_data_ptr,
+ profile_records_ptr->profile_hist_hdr.hist_size*sizeof(profile_time_t));
+#endif
+
+ if ((file = zOss_FOpen(GMON_OUT_FILE, "wb")) == NULL)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t´ò¿ªgmon.outÎļþʧ°Ü!");
+ zOss_Free((VOID *)buf);
+ return;
+ }
+
+ size = zOss_FWrite(buf, size, 1, file);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, size ? "\t\t ³É¹¦Íê³Éдgmon.outÎļþ!" : "\t\tдgmon.outÎļþʧ°Ü!");
+ zOss_FClose(file);
+ zOss_Free((VOID *)buf);
+#endif // #if defined (_OS_TOS) && defined (CYGPKG_PROFILE_GPROF)
+}
+
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: ½«ÏµÍ³ÔËÐÐʱµÄprofileÐÅÏ¢µ¼³ö
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) CmdMsg: shellÃüÁîÏûÏ¢Ö¸Õë
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: void
+* ÆäËü˵Ã÷: void
+**************************************************************************/
+VOID OSS_DbgProfile(T_Shell_CommandMessage *CmdMsg)
+{
+#if defined (_OS_TOS) && defined (CYGPKG_PROFILE_GPROF)
+ zOss_AssertExN(CmdMsg != NULL);
+
+ Shell_ProfileRecords();
+#endif // #if defined (_OS_TOS) && defined (CYGPKG_PROFILE_GPROF)
+}
+
+VOID Shell_ShowProcSig(T_Shell_CommandMessage *CmdMsg)
+{
+ zOss_AssertExN(CmdMsg != NULL);
+
+#ifdef _OS_TOS
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:¸ÃÃüÁîÔÚtosƽ̨ÎÞʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+#endif
+
+#ifdef _OS_OSE
+ switch (CmdMsg->paraCount)
+ {
+ case 0:
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "===============================================================================");
+ list_all_sig_info();
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "===============================================================================");
+ break;
+ }
+ default:
+ {
+ if (CmdMsg->paraCount == 1)
+ {
+ if (0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s : ÏÔʾÏß³ÌsignalÐÅÏ¢", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t %s [thread_id]", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t ²ÎÊýthread_idΪָ¶¨Ïß³Ìid,Èç¹û²»Ö¸¶¨,ÏÔʾËùÓÐÏß³ÌsignalÐÅÏ¢");
+ }
+ else
+ {
+ ZOSS_THREAD_ID pid = NULL;
+ if (-1 == Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tthread_id²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ return;
+ }
+ pid = (ZOSS_THREAD_ID)strtoul((char *)CmdMsg->para[0], NULL, 0);
+ if (NULL == pid)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tthread_id²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ return;
+ }
+
+ if (OSA_IdentifyThread(pid) != ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²ÎÊý´íÎó:Ïß³Ì%#lx²»´æÔÚ", pid);
+ }
+ else
+ {
+ list_proc_sig_info((PROCESS)pid, 1);
+ }
+ }
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²ÎÊý´íÎó£¬Çë¼üÈë%s help²é¿´ÃüÁî˵Ã÷", CmdMsg->cmd);
+ }
+ break;
+ }
+ }
+#endif
+
+}
+
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: OSS_OpenTraceSwitch
+* ²ÎÊý˵Ã÷:
+* (IN) CmdMsg: shellÃüÁîÏûÏ¢Ö¸Õë
+* (OUT) ÎÞ
+* ·µ »Ø Öµ: ÎÞ
+* ÆäËü˵Ã÷: ÎÞ
+**************************************************************************/
+VOID OSS_OpenTraceSwitch(T_Shell_CommandMessage *CmdMsg)
+{
+#ifdef _OS_TOS
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if(0 == strcmp(CmdMsg->para[0], "help") && CmdMsg->paraCount == 1)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t irq:´ò¿ª»òÕ߹رÕÖжÏͳ¼ÆºÍ¸ú×Ù¹¦ÄÜ; thread: ´ò¿ª»ò¹Ø±ÕÏ̸߳ú×Ù¹¦ÄÜ;");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t 0:¹Ø±ÕÏàÓ¦µÄ¹¦ÄÜ, 1:´ò¿ªÏàÓ¦µÄ¹¦ÄÜ;");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÀýÈç:openTraceSwitch irq 1»òÕßopenTraceSwitch irq 0£¬´ò¿ª»òÕ߹رÕÖжÏͳ¼ÆºÍ¸ú×Ù¹¦ÄÜ;");
+ return;
+ }
+
+ if(CmdMsg->paraCount == 2 && -1 != Shell_StrisNumber(CmdMsg->para[1]))
+ {
+ UINT32 type = strtoul((char *)CmdMsg->para[1], NULL, 0);
+ if(type == 0 || type == 1)
+ {
+ if(0 == strcmp(CmdMsg->para[0], "irq"))
+ {
+ Shell_SetIrqLogFlag(type);
+ return;
+ }
+ if(0 == strcmp(CmdMsg->para[0], "thread"))
+ {
+ Shell_SetThreadLogFlag(type);
+ return;
+ }
+ }
+ }
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÃüÁîÊäÈë´íÎó;");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÇëÊäÈë%s help²é¿´¸ÃÃüÁîµÄ¹¦ÄÜ;", CmdMsg->cmd);
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:¸ÃÃüÁîÖ»ÔÚTOSƽ̨ÓÐʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+#endif
+}
+
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: OSS_SetAssertLevel
+* ²ÎÊý˵Ã÷:
+* (IN) CmdMsg: shellÃüÁîÏûÏ¢Ö¸Õë
+* (OUT) ÎÞ
+* ·µ »Ø Öµ: ÎÞ
+* ÆäËü˵Ã÷: ÎÞ
+**************************************************************************/
+VOID OSS_SetAssertLevel(T_Shell_CommandMessage *CmdMsg)
+{
+#ifdef _OS_TOS
+ UINT32 level = 0;
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if(0 == strcmp(CmdMsg->para[0], "help") && CmdMsg->paraCount == 1)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÉèÖÃÄں˶ÏÑԵȼ¶1:ÑÏÖØ 2: Ò»°ã 3: Çá;");
+ return;
+ }
+ if ((CmdMsg->paraCount != 1) || (-1 == Shell_StrisNumber(CmdMsg->para[0])))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÃüÁîÊäÈë´íÎó;");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÇëÊäÈë%s help²é¿´¸ÃÃüÁîµÄ¹¦ÄÜ;", CmdMsg->cmd);
+ return;
+ }
+ level = strtoul((char *)CmdMsg->para[0], NULL, 0);
+ if(level >= 1 && level <= 3)
+ {
+ cyg_set_dbg_level(level);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:ÉèÖóɹ¦", CmdMsg->cmd);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÃüÁîÊäÈë´íÎó;");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÇëÊäÈë%s help²é¿´¸ÃÃüÁîµÄ¹¦ÄÜ;", CmdMsg->cmd);
+ }
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:¸ÃÃüÁîÖ»ÔÚTOSƽ̨ÓÐʵ¼Ê¹¦ÄÜ", CmdMsg->cmd);
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSS_DbgSuspendThread
+* ¹¦ÄÜÃèÊö:
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:shellÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+VOID OSS_DbgSuspendThread(T_Shell_CommandMessage *CmdMsg)
+{
+ ZOSS_THREAD_ID thread_id = NULL;
+ UINT32 result = 0;
+ UINT8 i = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ switch (CmdMsg->paraCount)
+ {
+ case 0:
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tsuspend_thread:no followed by thread_id!");
+ break;
+ }
+ default:
+ {
+ if (CmdMsg->paraCount == 1 && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tsuspend_thread:followed by the specified thread ID to suspend the thread!");
+ }
+ else
+ {
+ for (i = 0; i < CmdMsg->paraCount; i++)
+ {
+ thread_id = (ZOSS_THREAD_ID)strtoul((char *)CmdMsg->para[i], NULL, 0);
+
+ if (thread_id == NULL)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\twrong thread_id!");
+ break;
+ }
+ if (OSA_IdentifyThread(thread_id) == ZOSS_ERROR)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\twrong thread_id!");
+ break;
+ }
+
+ result = zOss_SuspendThread(thread_id);
+
+ if (result != ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tSuspend Thread Fail!");
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tSuspend Thread OK!");
+ }
+ }
+ }
+ break;
+ }
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSS_DbgResumeThread
+* ¹¦ÄÜÃèÊö:
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:shellÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+VOID OSS_DbgResumeThread(T_Shell_CommandMessage *CmdMsg)
+{
+ ZOSS_THREAD_ID thread_id = NULL;
+ UINT32 result = 0;
+ UINT8 i = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ switch (CmdMsg->paraCount)
+ {
+ case 0:
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tresum_thread:no followed by thread_id!");
+ break;
+ }
+ default:
+ {
+ if (CmdMsg->paraCount == 1 && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tresum_thread:followed by the specified thread ID to resume the thread!");
+ }
+ else
+ {
+ for (i = 0; i < CmdMsg->paraCount; i++)
+ {
+ thread_id = (ZOSS_THREAD_ID)strtoul((char *)CmdMsg->para[i], NULL, 0);
+
+ if (thread_id == NULL)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\twrong thread_id!");
+ break;
+ }
+ if (OSA_IdentifyThread(thread_id) == ZOSS_ERROR)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\twrong thread_id!");
+ break;
+ }
+
+ result = zOss_ResumeThread(thread_id);
+
+ if (result != ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tResume Thread Fail!");
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tResume Thread OK!");
+ }
+ }
+ }
+ break;
+ }
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSS_DbgSetThreadPri
+* ¹¦ÄÜÃèÊö:
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:shellÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+VOID OSS_DbgSetThreadPri(T_Shell_CommandMessage *CmdMsg)
+{
+ ZOSS_THREAD_ID thread_id = NULL;
+ UINT32 result = 0;
+ UINT32 pre_prio = 0;
+ UINT32 priority = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ switch (CmdMsg->paraCount)
+ {
+ case 0:
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tset_thread_pri:no followed by thread_id and priority!");
+ }
+ break;
+ case 1:
+ {
+ if (CmdMsg->paraCount == 1 && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tset_thread_pri:followed by the specified thread ID and priority to set priority of the thread!");
+ }
+ }
+ break;
+ default:
+ {
+ thread_id = (ZOSS_THREAD_ID)strtoul((char *)CmdMsg->para[0], NULL, 0);
+
+ if (thread_id == NULL)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\twrong thread_id!");
+ break;
+ }
+#ifdef _OS_LINUX
+ priority = strtoul((char *)CmdMsg->para[1], NULL, 0);
+ if (priority > 99 || priority <= 0)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\twrong priority! now can only set RT prio 1~99");
+ break;
+ }
+ result = zOss_GetProcessPri((VOID *)thread_id, &pre_prio);
+ if (result != ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\twrong thread_id!");
+ }
+ result = zOss_SetProcessPri(thread_id, priority);
+#else
+ if (OSA_IdentifyThread(thread_id) != ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, " The thread 0x%08x is not exist!",thread_id);
+ break;
+ }
+
+ priority = strtoul((char *)CmdMsg->para[1], NULL, 0);
+ if (priority > 31)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\twrong priority!");
+ break;
+ }
+
+ result = zOss_GetThreadPri(thread_id, &pre_prio);
+ if (result != ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\twrong thread_id!");
+ }
+ result = zOss_SetThreadPri(thread_id, priority);
+#endif
+
+ if (result == ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tPrior Set From %u to %u OK!", pre_prio, priority);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tPrior Set From %u to %u Fail!", pre_prio, priority);
+ }
+ }
+ break;
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSA_ForceRamdump
+* ¹¦ÄÜÃèÊö: Ç¿ÖƲúÉúÒì³£,ÒÔ±ãramdump
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:shellÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+VOID OSA_ForceRamdump(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT32 ret = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 == CmdMsg->paraCount)
+ {
+ if (0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+#ifdef _USE_MULTI_CORE_RAMDUMP
+#ifdef _USE_ARM1_RAMDUMP
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t0:serverÇ¿ÖÆËÀ»ú, ·ÇÁãÖµ:clientÇ¿ÖÆËÀ»ú(N¸öclient¶ÔÓ¦Êý×Ö1:N),Arm1¶ÔÓ¦255");
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t0:serverÇ¿ÖÆËÀ»ú, ·ÇÁãÖµ:clientÇ¿ÖÆËÀ»ú(N¸öclient¶ÔÓ¦Êý×Ö1:N)");
+#endif
+#else
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t0:ARMÒì³£ 1: ¶ÏÑÔÒì³£ 2: ²Ù×÷ϵͳ¶ÏÑÔÒì³£");
+#endif
+ return;
+ }
+
+ if (-1 == Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈëhelp²éѯÓ÷¨");
+ return;
+ }
+
+ ret = strtoul((char *)CmdMsg->para[0], NULL, 0);
+#ifdef _USE_MULTI_CORE_RAMDUMP
+ if(ret == 0)
+ {
+ zOss_AssertExN(FALSE);
+ }
+ else
+ {
+ ret = zOss_RamdumpForceClientException(ret);
+ if(ret != ZOSS_SUCCESS)
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈëhelp²éѯÓ÷¨");
+ }
+#else
+ if(ret <= 2)
+ {
+ zOss_RamdumpForceException(ret);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈëhelp²éѯÓ÷¨");
+ }
+#endif
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈëhelp²éѯÓ÷¨");
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSA_DbgTrace
+* ¹¦ÄÜÃèÊö: ²é¿´¸ú×ÙÄ£¿éÐÅÏ¢
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:shellÃüÁî²ÎÊý
+ (OUT)
+* ·µ »Ø Öµ: VOID
+* ÆäËü˵Ã÷: VOID
+**************************************************************************/
+VOID OSA_DbgTrace(T_Shell_CommandMessage *CmdMsg)
+{
+ zOss_AssertExN(CmdMsg != NULL);
+
+ switch (CmdMsg->paraCount)
+ {
+ case 1:
+ {
+ if (strcmp((const char *)CmdMsg->para[0], "init") == 0)
+ {
+ zOss_TraceFuncInit();
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\ttrace¸ú×Ù¹¦Äܳõʼ»¯³É¹¦");
+ }
+ else if (strcmp((const char *)CmdMsg->para[0], "info") == 0)
+ {
+ zOss_TraceFuncInfo(NULL);
+ }
+ else if (strcmp((const char *)CmdMsg->para[0], "help") == 0)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\ttrace¹¦ÄÜ:²é¿´¸ú×ÙÄ£¿éÐÅÏ¢");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t³õʼ»¯¸ú×Ù±ê־λ trace init");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²é¿´¸ú×Ùº¯ÊýÐÅÏ¢ trace info [funcname]");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tfuncnameΪº¯ÊýÃû");
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈëhelp²éѯÓ÷¨");
+ }
+ break;
+ }
+ case 2:
+ {
+ if (strcmp((const char *)CmdMsg->para[0], "info") == 0)
+ {
+ zOss_TraceFuncInfo(CmdMsg->para[1]);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈëhelp²éѯÓ÷¨");
+ }
+ break;
+ }
+ default:
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÊäÈëhelp²éѯÓ÷¨");
+ break;
+ }
+ }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_shell_psm.c b/cp/ps/plat/src/oss/sup/src/sup_shell_psm.c
new file mode 100755
index 0000000..fb51e7d
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_shell_psm.c
@@ -0,0 +1,222 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : sup_shell_psm.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : Ê¡µçÏà¹ØµÄshellÃüÁî
+* ×÷ Õß : ´ú¿µ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2019-01-10
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_shell.h"
+#include "sup_shell_cmd.h"
+#include "sup_except.h"
+#include "osa.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+#ifdef _USE_PSM
+ZOSS_SEMAPHORE_ID g_zTos_PsmInfoSema = NULL;
+ZOSS_TIMER_ID g_zTos_PsmInfoTimer = NULL;
+ZOSS_THREAD_ID g_zTos_PsmInfoThread = NULL;
+#ifdef _USE_CPU_DFM
+ZOSS_SEMAPHORE_ID g_zTos_DfmInfoSema = NULL;
+ZOSS_TIMER_ID g_zTos_DfmInfoTimer = NULL;
+ZOSS_THREAD_ID g_zTos_DfmInfoThread = NULL;
+#endif
+#endif
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+#ifdef _USE_PSM
+#ifdef _USE_CPU_DFM
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: OSS_DfmInfoTimerFunc
+* ²ÎÊý˵Ã÷:
+* (IN) args: ²ÎÊý
+* (OUT) ÎÞ
+* ·µ »Ø Öµ: ÎÞ
+* ÆäËü˵Ã÷: ÎÞ
+**************************************************************************/
+VOID OSS_DfmInfoTimerFunc(SINT32 args)
+{
+ UINT32 status = zOss_PutSemaphore(g_zTos_DfmInfoSema);
+ zOss_AssertExN(status == ZOSS_SUCCESS);
+}
+
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: OSS_DfmInfoThreadEntry
+* ²ÎÊý˵Ã÷:
+* (IN) args:²ÎÊý
+* (OUT) ÎÞ
+* ·µ »Ø Öµ: ÎÞ
+* ÆäËü˵Ã÷: ÎÞ
+**************************************************************************/
+VOID OSS_DfmInfoThreadEntry(SINT32 args)
+{
+ while(1)
+ {
+ zOss_GetSemaphore(g_zTos_DfmInfoSema, ZOSS_WAIT_FOREVER);
+ zOss_DfmTraceInfo();
+ }
+}
+
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: OSS_DfmTraceInfo
+* ²ÎÊý˵Ã÷:
+* (IN) CmdMsg: shellÃüÁîÏûÏ¢Ö¸Õë
+* (OUT) ÎÞ
+* ·µ »Ø Öµ: ÎÞ
+* ÆäËü˵Ã÷: ÎÞ
+**************************************************************************/
+VOID OSS_DfmTraceInfo(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT32 tmp = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+ if ((1 != CmdMsg->paraCount) || (-1 == Shell_StrisNumber(CmdMsg->para[0])))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÃüÁîµÄ¸ñʽ: dfminfo 0»ò1 \n");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t 0:¹Ø±Õ, 1:´ò¿ª\n");
+ return;
+ }
+
+ tmp = strtoul((char*)CmdMsg->para[0], NULL, 0);
+ if (tmp >1)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÃüÁîµÄ¸ñʽ: dfminfo 0»ò1 \n");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t 0:¹Ø±Õ, 1:´ò¿ª\n");
+ return;
+ }
+
+ if (tmp)
+ {
+ g_zTos_DfmInfoSema = zOss_CreateSemaphore("dfminfosema", 0);
+ g_zTos_DfmInfoTimer = zOss_CreateTimer("dfminfotimer", OSS_DfmInfoTimerFunc, 10, TRUE);
+ g_zTos_DfmInfoThread = zOss_CreateThread("dfminfothread", OSS_DfmInfoThreadEntry, 0, 4096, 25, 1, 1);
+ zOss_StartTimer(g_zTos_DfmInfoTimer, 10, OSS_DfmInfoTimerFunc, 0);
+ }
+ else
+ {
+ zOss_DeleteThread(g_zTos_DfmInfoThread);
+ zOss_KillTimer(g_zTos_DfmInfoTimer);
+ zOss_DeleteSemaphore(g_zTos_DfmInfoSema);
+ }
+
+ return;
+}
+#endif //_USE_CPU_DFM
+
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: OSS_PsmInfoTimerFunc
+* ²ÎÊý˵Ã÷:
+* (IN) args: ²ÎÊý
+* (OUT) ÎÞ
+* ·µ »Ø Öµ: ÎÞ
+* ÆäËü˵Ã÷: ÎÞ
+**************************************************************************/
+VOID OSS_PsmInfoTimerFunc(SINT32 args)
+{
+ UINT32 status = zOss_PutSemaphore(g_zTos_PsmInfoSema);
+ zOss_AssertExN(status == ZOSS_SUCCESS);
+}
+
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: OSS_PsmInfoThreadEntry
+* ²ÎÊý˵Ã÷:
+* (IN) args: ²ÎÊý
+* (OUT) ÎÞ
+* ·µ »Ø Öµ: ÎÞ
+* ÆäËü˵Ã÷: ÎÞ
+**************************************************************************/
+VOID OSS_PsmInfoThreadEntry(SINT32 args)
+{
+ while(1)
+ {
+ zOss_GetSemaphore(g_zTos_PsmInfoSema, ZOSS_WAIT_FOREVER);
+ zOss_PsmTraceInfo();
+ }
+}
+
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: OSS_PsmTraceInfo
+* ²ÎÊý˵Ã÷:
+* (IN) CmdMsg: shellÃüÁîÏûÏ¢Ö¸Õë
+* (OUT) ÎÞ
+* ·µ »Ø Öµ: ÎÞ
+* ÆäËü˵Ã÷: ÎÞ
+**************************************************************************/
+VOID OSS_PsmTraceInfo(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT32 tmp = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+ if ((1 != CmdMsg->paraCount)||(-1 == Shell_StrisNumber(CmdMsg->para[0])))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÃüÁîµÄ¸ñʽ: psminfo 0»ò1 \n");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t 0:¹Ø±Õ, 1:´ò¿ª\n");
+ return;
+ }
+
+ tmp = strtoul((char*)CmdMsg->para[0], NULL, 0);
+ if (tmp > 1)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÃüÁîµÄ¸ñʽ: psminfo 0»ò1 \n");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t 0:¹Ø±Õ, 1:´ò¿ª\n");
+ return;
+ }
+
+ if (tmp)
+ {
+ g_zTos_PsmInfoSema = zOss_CreateSemaphore("psminfosema", 0);
+ g_zTos_PsmInfoTimer = zOss_CreateTimer("psminfotimer", OSS_PsmInfoTimerFunc, 10, TRUE);
+ g_zTos_PsmInfoThread = zOss_CreateThread("psminfothread", OSS_PsmInfoThreadEntry, 0, 4096, 25, 1, 1);
+ zOss_StartTimer(g_zTos_PsmInfoTimer, 30, OSS_PsmInfoTimerFunc, 0);
+ }
+ else
+ {
+ zOss_DeleteThread(g_zTos_PsmInfoThread);
+ zOss_KillTimer(g_zTos_PsmInfoTimer);
+ zOss_DeleteSemaphore(g_zTos_PsmInfoSema);
+ }
+
+ return;
+}
+#endif // _USE_PSM
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_shell_thread.c b/cp/ps/plat/src/oss/sup/src/sup_shell_thread.c
new file mode 100755
index 0000000..de1ef8b
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_shell_thread.c
@@ -0,0 +1,883 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : sup_shell_thread.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : Ï̡߳¢ÈÎÎñ¡¢CPUÕ¼ÓÃÂÊͳ¼ÆÏà¹ØµÄshellÃüÁî
+* ×÷ Õß : ´ú¿µ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2019-01-10
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "sup_shell.h"
+#include "sup_shell_cmd.h"
+#include "sup_except.h"
+#include "osa.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#ifdef _OS_WIN
+#ifndef PROCESS
+#define PROCESS ZOSS_THREAD_ID
+#endif
+#endif
+
+#define SHELL_SIGN "\t================================================================================================================="
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+static VOID Shell_ShowThread(T_ZOsa_ThreadUserArea *pThreadInfo);
+static VOID Shell_ShowThreadTitle(VOID);
+
+#ifdef _OS_LINUX
+void linux_thread_sched_stat(int type);
+#endif
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+ZOSS_TIMER_ID gShell_UpdataCpuTimerId = NULL; /* ¼ÆËãcpuÕ¼ÓÃÂʶ¨Ê±Æ÷ */
+ZOSS_TIMER_ID gShell_FreshCpuTimerId = NULL; /* ÏÔʾcpuÕ¼ÓÃÂʶ¨Ê±Æ÷ */
+
+#ifdef _OS_LINUX
+extern void *linux_get_threadID_by_name(const char *name);
+extern void linux_reset_cpupinfo(void);
+#endif
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+static VOID Shell_ThreadCPU(SINT32 para)
+{
+ if(OSA_IdentifyThread((ZOSS_THREAD_ID)para) == ZOSS_SUCCESS)
+ {
+ Osa_DisplayThreadExecInfo((PROCESS)para);
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t¸ÃÏ̲߳»´æÔÚ");
+ }
+}
+
+static VOID Shell_ThreadsCPU(SINT32 para)
+{
+ Osa_DisplayThreadsExecInfo((UINT32)para);
+}
+
+static VOID Shell_ThreadSetFlagUse(const CHAR *cmd)
+{
+ zOss_AssertExN(cmd != NULL);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s m", cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tmȡֵ[0-1]");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t m = 0±íʾ¹Ø±Õ¼Ç¼Ïß³Ìcpuʱ¼ä¿ª¹Ø");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t m = 1±íʾ´ò¿ª¼Ç¼Ïß³Ìcpuʱ¼ä¿ª¹Ø");
+}
+
+static VOID Shell_PrintSysCPU(VOID)
+{
+#ifdef _OS_LINUX
+ UINT32 rate = 0;
+ rate = 100 - Osa_GetProcessCPU(linux_get_threadID_by_name(EXCEP_IDLETHREADNAME));
+ zOss_AssertExN(rate <= 100);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tϵͳCPUÕ¼ÓÃÂÊΪ[%u%%]", rate);
+ rate = 100 - rate;
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tϵͳCPU¿ÕÏÐÂÊΪ[%u%%]", rate);
+#else
+ FLOAT rate = 0;
+ rate = 100 - Osa_GetProcessCPU(zOss_GetThreadIDByName(EXCEP_IDLETHREADNAME));
+ zOss_AssertExN(rate <= 100);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tϵͳCPUÕ¼ÓÃÂÊΪ[%.2f%%]", rate);
+ rate = 100 - rate;
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tϵͳCPU¿ÕÏÐÂÊΪ[%.2f%%]", rate);
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Shell_UpdateCpuTimerCallBack
+* ¹¦ÄÜÃèÊö£º ¶¨Ê±¼ÆËãCPU¶¨Ê±Æ÷º¯Êý»Øµ÷
+* ²ÎÊý˵Ã÷£º
+ (IN)
+ arg:¶¨Ê±Æ÷»Øµ÷²ÎÊý
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID Shell_UpdateCpuTimerCallBack(SINT32 arg)
+{
+ Osa_UpdateCpu();
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º Shell_SetCpuUpdateTime
+* ¹¦ÄÜÃèÊö£º Ð޸ļÆËãCPU¸üÐÂʱ¼ä
+* ²ÎÊý˵Ã÷£º
+ (IN)
+ time_in_second:¶à³¤Ê±¼ä¼ÆËãÒ»´ÎÏß³ÌCPU(µ¥Î»£ºÃë),·¶Î§2-10
+* ·µ »Ø Öµ£º
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static VOID Shell_SetCpuUpdateTime(UINT32 time_in_second)
+{
+ UINT32 ret = ZOSS_ERROR;
+ UINT32 freshTime = 0;
+
+ if(NULL == gShell_UpdataCpuTimerId)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t¼Ç¼Ïß³ÌCPUʱ¼ä¿ª¹Øδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+ }
+
+ ret = zOss_StopTimer(gShell_UpdataCpuTimerId); /* ÏÈÍ£Ö¹¶¨Ê±Æ÷ */
+ if(ZOSS_ERROR == ret)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tË¢ÐÂʱ¼äÉèÖÃʧ°Ü");
+ return;
+ }
+
+ freshTime = time_in_second * 1000;
+
+ ret = zOss_StartTimer(gShell_UpdataCpuTimerId, freshTime, Shell_UpdateCpuTimerCallBack, 0); /* Æô¶¯¶¨Ê±Æ÷ */
+ if(ZOSS_ERROR == ret)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tË¢ÐÂʱ¼äÉèÖÃʧ°Ü");
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tË¢ÐÂʱ¼äÉèÖóɹ¦");
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: Shell_ShowThread
+* ¹¦ÄÜÃèÊö:
+* ²ÎÊý˵Ã÷: (IN)
+ pThreadInfo:Ïß³ÌÏêϸÐÅÏ¢½á¹¹ÌåÖ¸Õë
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+static VOID Shell_ShowThread(T_ZOsa_ThreadUserArea *pThreadInfo)
+{
+ UINT8 index;
+ CHAR status[][10] = {"RUN","READY","BLOCK","UNKNOW"};
+
+ zOss_AssertExN(pThreadInfo != NULL);
+
+ index = (pThreadInfo->runstatus)/2;
+ if (index >= (sizeof(status) / sizeof(status[0])))
+ index = (sizeof(status) / sizeof(status[0])) - 1;
+
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-40s%p%11s%8u%10.2f%10u%10u%12u%8u%10u",
+ pThreadInfo->threadname, pThreadInfo->threadid, status[index],
+ pThreadInfo->priority, pThreadInfo->cpupercent, pThreadInfo->stacksize,
+ pThreadInfo->maxstack, pThreadInfo->RunTimeInMs, pThreadInfo->msgnum, pThreadInfo->runcount);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: Shell_ShowThreadTitle
+* ¹¦ÄÜÃèÊö:
+* ²ÎÊý˵Ã÷: (IN)
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+static VOID Shell_ShowThreadTitle(VOID)
+{
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-40s%-10s%11s%10s%12s%10s%10s%12s%8s%10s",
+ "ThreadName", "ThreadID", "Status", "Priority", "CpuPercent", "StackSize", "MaxStack",
+ "RunTimeInMs", "MsgNum", "RunCount");
+}
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: OSS_DbgShowThreadInfo
+* ¹¦ÄÜÃèÊö:
+* ²ÎÊý˵Ã÷: (IN)
+ CmdMsg:shellÃüÁî
+ (OUT)
+* ·µ »Ø Öµ:
+* ÆäËü˵Ã÷:
+**************************************************************************/
+VOID OSS_DbgShowThreadInfo(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT32 thread_num = 0; /* Ïß³ÌÊý */
+ ZOSS_THREAD_ID *AllThreadIdArray = NULL; /* ËùÓÐÏß³ÌIDÊý×éÖ¸Õë */
+ T_ZOsa_ThreadUserArea *pThreadInfo = NULL; /* Ïß³ÌUAÖ¸Õë */
+ ZOSS_THREAD_ID thread_id = NULL;
+ UINT32 i = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tThread Info");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, SHELL_SIGN);
+
+ switch (CmdMsg->paraCount)
+ {
+ case 0: /* ÏÔʾËùÓÐÏß³ÌÐÅÏ¢ */
+ {
+#ifdef _OS_LINUX
+ linux_thread_sched_stat(0);
+#else
+ Shell_ShowThreadTitle();
+ thread_num = Osa_GetAllThreadId(&AllThreadIdArray); /* º¯ÊýÄÚÉêÇë¿Õ¼ä */
+
+ if (0 == thread_num)
+ {
+ break;
+ }
+
+ for (i = 0; i < thread_num; i++)
+ {
+ pThreadInfo = Osa_GetThreadUserArea(AllThreadIdArray[i], TRUE);
+ if (pThreadInfo)
+ {
+ Shell_ShowThread(pThreadInfo);
+ }
+ }
+ zOss_Free(AllThreadIdArray);
+#endif
+ break;
+ }
+ default:
+ {
+ if (CmdMsg->paraCount == 1 && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s : ÏÔʾÏß³ÌÐÅÏ¢", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t %s [thread_id]", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t\t ²ÎÊýthread_idΪָ¶¨Ïß³Ìid,Èç¹û²»Ö¸¶¨,ÏÔʾËùÓÐÏß³ÌÐÅÏ¢");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t½á¹ûÏÔʾÁÐ˵Ã÷:");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ThreadName:ΪÏß³ÌÃû");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ThreadID:Ïß³ÌID");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t Status:ÔËÐÐ״̬");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t Priority:Ïß³ÌÓÅÏȼ¶");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t CpuPercent:Ïß³ÌʹÓÃÂÊ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t StackSize:Õ»´óС");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t MaxStack:×î´óջʹÓÃÂÊ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t RunTimeInMs:Ïß³ÌÕ»ÔËÐÐʱ¼ä");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t MsgNum:ÏûÏ¢¶ÓÁ㤶È");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t RunCount:ÔËÐдÎÊý");
+ }
+ else
+ {
+#ifdef _OS_LINUX
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tLinuxÉϲ»Ö§³Ö²ÎÊý");
+ return;
+#else
+ Shell_ShowThreadTitle();
+
+ for (i = 0; i < CmdMsg->paraCount; i++)
+ {
+ if (-1 == Shell_StrisNumber(CmdMsg->para[i]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tthread_id²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ return;
+ }
+ thread_id = (ZOSS_THREAD_ID)strtoul((char *)CmdMsg->para[i], NULL, 0);
+ if (NULL == thread_id)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tthread_id²ÎÊý´íÎó£¬Çë²Î¼û%s help\n", CmdMsg->cmd);
+ return;
+ }
+
+ if (OSA_IdentifyThread(thread_id) != ZOSS_SUCCESS)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, " The thread 0x%08x is not exist!",thread_id);
+ break;
+ }
+
+ pThreadInfo = Osa_GetThreadUserArea(thread_id, TRUE);
+ if (pThreadInfo)
+ {
+ Shell_ShowThread(pThreadInfo);
+ }
+ }
+#endif
+ }
+ break;
+ }
+ }
+
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, SHELL_SIGN);
+}
+
+VOID OSS_DbgShowTaskInfo(T_Shell_CommandMessage *CmdMsg)
+{
+ ZOSS_TASK_ID *task_id_arr = NULL;
+ T_OSS_PARAM *pPlatCfg = NULL;
+ ZOSS_TASK_ID task_id = NULL;
+ T_ZOss_TCB pCurTCB = {0};
+ UINT32 task_num = 0;
+ UINT32 i = 0;
+ UINT32 nRet = 0;
+ UINT32 current_ticks = 0;
+ CHAR run_stat_str[][6] = {"ÔÝÍ£","¿ÕÏÐ","¾ÍÐ÷","ÔËÐÐ"};
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:ÏÔʾÈÎÎñÐÅÏ¢\n\t %s [taskname]:ÏÔʾÈÎÎñÐÅÏ¢", CmdMsg->cmd, CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t Èç¹û²»Ö¸¶¨ÈÎÎñÃû£¬ÏÔʾËùÓÐÈÎÎñÐÅÏ¢£¨²»°üÀ¨SDLÈÎÎñ£©");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ½á¹ûÏÔʾÁÐ˵Ã÷:");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t TaskName:ΪÈÎÎñÃû");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t TaskID:ÈÎÎñID");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t Prior:ÈÎÎñÓÅÏȼ¶");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ThreadID:ÈÎÎñËùÔÚµ÷¶ÈÏß³ÌID");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t RunState:ÈÎÎñÔËÐÐ״̬£¬¿ÉÄÜΪÔÝÍ££¬¿ÕÏУ¬¾ÍÐ÷£¬ÔËÐÐËÄÖÖÖ®Ò»");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t LifeTime:ÈÎÎñ×Ô´´½¨µ½ÏÖÔÚµÄtickÊý");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t RunTimeInMs:ÈÎÎñÔËÐÐʱ¼ä");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t CpuPencent:ÈÎÎñcpuÕ¼ÓÃÂÊ");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t MsgCounts:ÈÎÎñÏûÏ¢¶ÓÁÐÖл¹Î´´¦ÀíµÄÏûÏ¢¸öÊý");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t RunCounts:ÈÎÎñ±»´´½¨Ò»À´Ö´ÐеĴÎÊý");
+ return;
+ }
+
+ current_ticks = zOss_GetTickCount();
+ if (1 == CmdMsg->paraCount)
+ {
+ task_id = zOss_GetTaskID(CmdMsg->para[0]);
+
+ if (task_id == ZOSS_INVALID_TASK_ID)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t[ʧ°Ü]ÈÎÎñÃûΪ%s²»´æÔÚ !", CmdMsg->para[0]);
+ return;
+ }
+
+ nRet = zOss_GetTaskInfo(task_id, &pCurTCB);
+ if (nRet == ZOSS_ERROR)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t[ʧ°Ü]»ñÈ¡%sÈÎÎñÐÅϢʧ°Ü !", CmdMsg->para[0]);
+ return;
+ }
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tTask Info");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t===============================================================================================");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-30s %-10s %8s %-10s %10s %10s %10s %10s %10s %10s","TaskName","TaskID","Prior","ThreadID","RunState","LifeTime","RunTimeInMs","CpuPencent","MsgCounts","RunCounts");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-30s %p%8u %-10p%8s%10u%10u%10f%10u%10u", pCurTCB.task_name, pCurTCB.task_id, pCurTCB.priority,
+ pCurTCB.thread_id, run_stat_str[pCurTCB.run_status - 1], current_ticks - pCurTCB.time, pCurTCB.runtime / 1000, pCurTCB.cpupercent, zOss_ListCount(&pCurTCB.msg_queue), pCurTCB.count);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t===============================================================================================");
+ }
+
+ if (0 == CmdMsg->paraCount)
+ {
+ pPlatCfg = zOss_GetOssCfg();
+ task_id_arr = (ZOSS_TASK_ID *)zOss_Malloc(pPlatCfg->TaskCfg.max_task_num * sizeof(ZOSS_TASK_ID));
+ if (NULL == task_id_arr)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tzOss_Malloc for task_id_arr failed!");
+ return;
+ }
+ task_num = zOss_GetAllTaskID(task_id_arr);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tTask Info");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t===============================================================================================");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-30s %-10s %8s %-10s %10s %10s %10s %10s %10s %10s","TaskName","TaskID","Prior","ThreadID","RunState","LifeTime","RunTimeInMs","CpuPencent","MsgCounts","RunCounts");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t===============================================================================================");
+
+ for (i = 0; i < task_num; i++)
+ {
+ nRet = zOss_GetTaskInfo(task_id_arr[i], &pCurTCB);
+ if (nRet == ZOSS_ERROR)
+ {
+ continue; /* Èç¹ûÊÇSDLÈÎÎñÒ²¿ÉÄÜÊÇ·µ»Ø´íÎó */
+ }
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%-30s %p%8u %-10p%8s%10u%10u%10f%10u%10u", pCurTCB.task_name, pCurTCB.task_id, pCurTCB.priority,
+ pCurTCB.thread_id, run_stat_str[pCurTCB.run_status - 1], current_ticks-pCurTCB.time, pCurTCB.runtime, pCurTCB.cpupercent, zOss_ListCount(&pCurTCB.msg_queue), pCurTCB.count);
+ }
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t=============================================================================================");
+ zOss_Free(task_id_arr);
+ }
+ return;
+}
+
+VOID OSS_DbgDisplayThreadExecInfo(T_Shell_CommandMessage *CmdMsg)
+{
+ ZOSS_THREAD_ID tid = ZOSS_INVALID_THREAD_ID;
+ static ZOSS_TIMER_ID freshTimer = NULL;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if(FALSE == gOsa_SwapTimeFlag)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t¼Ç¼Ïß³ÌCPUʱ¼ä¿ª¹Øδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+ }
+
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s Ïß³ÌID [time]", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÏß³ÌID¿ÉÒÔ10½øÖÆÊýºÍ16½øÖÆÊý(ǰ׺0x»ò0X)");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t timeΪ¿ÉÑ¡ÏÉèÖÃÏÔʾµÄË¢ÐÂʱ¼ä(µ¥Î»:Ãë)£¬·¶Î§[2~10]£¬Èô²»´øtimeÔòֹͣˢÐÂ");
+ return;
+ }
+ else if(1 == CmdMsg->paraCount || 2 == CmdMsg->paraCount)
+ {
+ if (-1 == Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²ÎÊý´íÎó");
+ return;
+ }
+ tid = (ZOSS_THREAD_ID)strtoul((char *)CmdMsg->para[0], NULL, 0);
+ if (ZOSS_INVALID_THREAD_ID == tid)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²ÎÊý´íÎó");
+ return;
+ }
+
+ if (1 == CmdMsg->paraCount)
+ {
+ Shell_ThreadCPU((SINT32)tid);
+ if (NULL != freshTimer)
+ {
+ zOss_KillTimer(freshTimer);
+ freshTimer = NULL;
+ }
+ return;
+ }
+
+ if (2 == CmdMsg->paraCount)
+ {
+ UINT32 freshTime = 0;
+
+ if (-1 == Shell_StrisNumber(CmdMsg->para[1]))
+ {
+ return;
+ }
+
+ freshTime = strtoul((char *)CmdMsg->para[1], (char **)NULL, 0);
+ if (freshTime < 2 || freshTime > 10)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó");
+ return;
+ }
+ if (NULL != freshTimer)
+ {
+ zOss_KillTimer(freshTimer);
+ freshTimer = NULL;
+ }
+ freshTimer = zOss_CreateTimer("Timer_ThreadCPUPrint", (ZOSS_TIMER_FUN)Shell_ThreadCPU, (SINT32)tid, TRUE);
+ if (NULL == freshTimer)
+ {
+ return;
+ }
+ if (ZOSS_ERROR == zOss_StartTimer(freshTimer, (freshTime * 1000), (ZOSS_TIMER_FUN)Shell_ThreadCPU, (SINT32)tid))
+ {
+ zOss_KillTimer(freshTimer);
+ freshTimer = NULL;
+ }
+ }
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó");
+ }
+}
+
+
+VOID OSS_DbgDisplayThreadsExecInfo(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT32 type = 0;
+ UINT32 timeLen = 0;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (FALSE == gOsa_SwapTimeFlag)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t¼Ç¼Ïß³ÌCPUʱ¼ä¿ª¹Øδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+ }
+
+ if (1 == CmdMsg->paraCount && 0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s live/lazy/all time1 [time2]", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t live:Ö»ÏÔʾ»î¶¯µÄỊ̈߳¬lazy:Ö»ÏÔʾ²»»î¶¯µÄỊ̈߳¬all:ÏÔʾËùÓÐÏß³Ì");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t time1ÉèÖÃij¶Îʱ¼äÄÚÏß³ÌÖ´ÐÐÇé¿ö(µ¥Î»:Ãë)£¬·¶Î§[0~10](oseƽ̨Î޸ù¦ÄÜ,ÉèÖÃΪ0), 0±íʾȫ²¿Ê±¼äÄÚµÄÏß³ÌÖ´ÐÐÇé¿ö");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t time2Ϊ¿ÉÑ¡ÏÉèÖÃÏÔʾµÄË¢ÐÂʱ¼ä(µ¥Î»:Ãë,µ±time1Ϊ0ʱÓÐЧ)£¬·¶Î§[2~10]£¬Èô²»´øtime2ÔòֹͣˢÐÂ");
+ return;
+ }
+ else if (2 == CmdMsg->paraCount || 3 == CmdMsg->paraCount)
+ {
+ if (0 == strcmp((char *)CmdMsg->para[0], "live"))
+ {
+ type |= SUP_THREAD_LIVE_BIT; /* Ö»ÏÔʾ»î¶¯µÄÏß³Ì */
+ }
+ else if (0 == strcmp((char *)CmdMsg->para[0], "lazy"))
+ {
+ type |= SUP_THREAD_LAZY_BIT; /* Ö»ÏÔʾ²»»î¶¯µÄÏß³Ì */
+ }
+ else if (0 == strcmp((char *)CmdMsg->para[0], "all"))
+ {
+ type = 0; /* ÏÔʾËùÓÐÏß³Ì */
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó");
+ return;
+ }
+
+ if (-1 == Shell_StrisNumber(CmdMsg->para[1]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²ÎÊý´íÎó");
+ return;
+ }
+ timeLen = strtoul((char *)CmdMsg->para[1], (char **)NULL, 0);
+
+ if (1 <= timeLen && 10 >= timeLen)
+ {
+ type |= SUP_THREAD_STATISTIC_INFO_BIT;
+ }
+ else if (0 != timeLen)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó");
+ return;
+ }
+
+ if (2 == CmdMsg->paraCount)
+ {
+ if (0 != timeLen)
+ {
+#ifdef TOS_STATISTIC_TIMESLICE
+ zOss_StatisticTimesliceStart(timeLen * 1000, type);
+#endif
+ }
+ else
+ {
+ Shell_ThreadsCPU((SINT32)type);
+ }
+
+ if (NULL != gShell_FreshCpuTimerId)
+ {
+ zOss_KillTimer(gShell_FreshCpuTimerId);
+ gShell_FreshCpuTimerId = NULL;
+ }
+ return;
+ }
+
+ if (3 == CmdMsg->paraCount)
+ {
+ UINT32 freshTime = 0;
+
+ if (0 != timeLen || -1 == Shell_StrisNumber(CmdMsg->para[2]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t²ÎÊý´íÎó");
+ return;
+ }
+ freshTime = strtoul((char *)CmdMsg->para[2], (char **)NULL, 0);
+ if (freshTime < 2 || freshTime > 10)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó");
+ return;
+ }
+ if (NULL != gShell_FreshCpuTimerId)
+ {
+ zOss_KillTimer(gShell_FreshCpuTimerId);
+ gShell_FreshCpuTimerId = NULL;
+ }
+ gShell_FreshCpuTimerId = zOss_CreateTimer("Timer_ThreadsCPUPrint", (ZOSS_TIMER_FUN)Shell_ThreadsCPU, (long)type, TRUE);
+ if (NULL == gShell_FreshCpuTimerId)
+ {
+ return;
+ }
+ if (ZOSS_ERROR == zOss_StartTimer(gShell_FreshCpuTimerId, (freshTime * 1000), (ZOSS_TIMER_FUN)Shell_ThreadsCPU, (long)type))
+ {
+ zOss_KillTimer(gShell_FreshCpuTimerId);
+ gShell_FreshCpuTimerId = NULL;
+ }
+ }
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó");
+ }
+}
+
+VOID OSS_DbgSetUpdateCPUTime(T_Shell_CommandMessage *CmdMsg)
+{
+ UINT32 new_time = 0;
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if(FALSE == gOsa_SwapTimeFlag)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t¼Ç¼Ïß³ÌCPUʱ¼ä¿ª¹Øδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+ }
+
+ if (1 == CmdMsg->paraCount)
+ {
+ if (0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s time", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t time:Ë¢ÐÂʱ¼äÒªÇóÔÚ[2-10]ÃëÖ®¼ä");
+ return;
+ }
+ else if (0 == Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ new_time = strtoul((char *)CmdMsg->para[0], NULL, 0);
+ if (new_time >= 2 && new_time <= 10)
+ {
+ Shell_SetCpuUpdateTime(new_time);
+ return;
+ }
+ }
+ }
+
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\tÊäÈëhelp²éѯÓ÷¨");
+
+}
+
+VOID OSS_DbgThreadSetFlag(T_Shell_CommandMessage *CmdMsg)
+{
+ BOOL enableRunTime = FALSE;
+ T_OSS_PARAM *pPlatCfg = NULL;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if (1 != CmdMsg->paraCount)
+ {
+ Shell_ThreadSetFlagUse(CmdMsg->cmd);
+ return;
+ }
+ if (-1 == Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ Shell_ThreadSetFlagUse(CmdMsg->cmd);
+ return;
+ }
+
+ enableRunTime = (BOOL)strtoul((char *)CmdMsg->para[0], NULL, 0);
+
+ Osa_SwapCtl(enableRunTime);
+
+ if (enableRunTime)
+ {
+ UINT32 freshTime = 0;
+
+ pPlatCfg = zOss_GetOssCfg();
+ freshTime = pPlatCfg->ExcepCfg.UpdateCPUTime;
+
+#ifdef _OS_TOS
+# ifdef CYGOPT_KERNEL_EXTEND_CLOCK_STATISTIC_TIMESLICE
+ cyg_set_statistic_counter_flag(TRUE);
+# endif
+# ifdef CYGOPT_KERNEL_EXTEND_THREAD_STATISTIC_TIMESLICE
+ cyg_thread_set_statistic_timeslice_flag(TRUE);
+# endif
+#endif
+ if (NULL != gShell_UpdataCpuTimerId)
+ {
+ zOss_KillTimer(gShell_UpdataCpuTimerId);
+ gShell_UpdataCpuTimerId = NULL;
+ }
+ gShell_UpdataCpuTimerId = zOss_CreateTimer("Shell_UpdateCpuTimer", Shell_UpdateCpuTimerCallBack, 0, TRUE);
+ if (NULL == gShell_UpdataCpuTimerId)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t´ò¿ª¼Ç¼Ïß³Ìcpuʱ¼ä¿ª¹Øʧ°Ü");
+ return;
+ }
+ if (ZOSS_ERROR == zOss_StartTimer(gShell_UpdataCpuTimerId, freshTime, Shell_UpdateCpuTimerCallBack, 0))
+ {
+ zOss_KillTimer(gShell_UpdataCpuTimerId);
+ gShell_UpdataCpuTimerId = NULL;
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t´ò¿ª¼Ç¼Ïß³Ìcpuʱ¼ä¿ª¹Øʧ°Ü");
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t³É¹¦´ò¿ª¼Ç¼Ïß³Ìcpuʱ¼ä¿ª¹Ø");
+ }
+
+ }
+ else
+ {
+ UINT32 i = 0;
+ UINT32 totalNum = 0;
+ T_ZOss_TCB *pTCB = NULL;
+ ZOSS_TASK_ID *taskIdArray = NULL;
+ ZOSS_THREAD_ID *allThreadIdArray = NULL;
+ T_ZOsa_ThreadUserArea *pThreadInfo = NULL;
+
+ if (NULL != gShell_UpdataCpuTimerId)
+ {
+ zOss_KillTimer(gShell_UpdataCpuTimerId);
+ gShell_UpdataCpuTimerId = NULL;
+ }
+ if(NULL != gShell_FreshCpuTimerId)
+ {
+ zOss_KillTimer(gShell_FreshCpuTimerId);
+ gShell_FreshCpuTimerId = NULL;
+ }
+#ifdef _OS_TOS
+# ifdef CYGOPT_KERNEL_EXTEND_CLOCK_STATISTIC_TIMESLICE
+ cyg_set_statistic_counter_flag(FALSE);
+ cyg_zero_statistic_counter_value();
+# endif
+# ifdef CYGOPT_KERNEL_EXTEND_THREAD_STATISTIC_TIMESLICE
+ cyg_thread_set_statistic_timeslice_flag(FALSE);
+ cyg_thread_zero_all_statistic_timeslice();
+# endif
+#endif
+
+#ifdef _OS_LINUX
+ linux_reset_cpupinfo();
+#else
+ totalNum = Osa_GetAllThreadId(&allThreadIdArray);
+ for (i = 0; i < totalNum; i++)
+ {
+ pThreadInfo = Osa_GetThreadUserArea(allThreadIdArray[i], TRUE);
+ if (pThreadInfo)
+ {
+ pThreadInfo->cputime = 0;
+ pThreadInfo->runtime = 0;
+ pThreadInfo->RunTimeInMs = 0;
+ pThreadInfo->runcount = 0;
+ pThreadInfo->cpupercent = 0;
+ }
+ }
+ zOss_Free(allThreadIdArray);
+
+ pPlatCfg = zOss_GetOssCfg();
+ taskIdArray = (ZOSS_TASK_ID *)zOss_Malloc(pPlatCfg->TaskCfg.max_task_num * sizeof(ZOSS_TASK_ID));
+ totalNum = zOss_GetAllTaskID(taskIdArray);
+ for (i = 0; i < totalNum; i++)
+ {
+ pTCB = (T_ZOss_TCB *)taskIdArray[i];
+ if (pTCB != pTCB->task_id)
+ {
+ continue;
+ }
+ pTCB->cputime = 0;
+ pTCB->cpupercent = 0;
+ pTCB->runtime = 0;
+ }
+ zOss_Free(taskIdArray);
+#endif
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t³É¹¦¹Ø±Õ¼Ç¼Ïß³Ìcpuʱ¼ä¿ª¹Ø");
+ }
+}
+
+VOID OSS_DbgGetSysCPU(T_Shell_CommandMessage *CmdMsg)
+{
+ static ZOSS_TIMER_ID sys_timer = NULL;
+
+ zOss_AssertExN(CmdMsg != NULL);
+
+ if(FALSE == gOsa_SwapTimeFlag)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t¼Ç¼Ïß³ÌCPUʱ¼ä¿ª¹Øδ´ò¿ª£¬´Ë¹¦ÄܽûÓÃ");
+ return;
+ }
+
+ switch (CmdMsg->paraCount)
+ {
+ case 0:
+ {
+ Shell_PrintSysCPU();
+ if (NULL != sys_timer)
+ {
+ zOss_KillTimer(sys_timer);
+ sys_timer = NULL;
+ }
+ break;
+ }
+ case 1:
+ {
+ UINT32 freshTime = 0;
+ if (0 == strcmp((char *)CmdMsg->para[0], "help"))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\tÓ÷¨:%s [time]", CmdMsg->cmd);
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t timeΪ¿ÉÑ¡ÏÉèÖÃÏÔʾµÄË¢ÐÂʱ¼ä(µ¥Î»:Ãë)£¬·¶Î§[2~10]£¬Èô²»´øtimeÔòֹͣˢÐÂ");
+ break;
+ }
+
+ if (-1 == Shell_StrisNumber(CmdMsg->para[0]))
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó");
+ break;
+ }
+ freshTime = strtoul((char *)CmdMsg->para[0], (char **)NULL, 0);
+ if (freshTime < 2 || freshTime > 10)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó");
+ break;
+ }
+ if (NULL != sys_timer)
+ {
+ zOss_KillTimer(sys_timer);
+ sys_timer = NULL;
+ }
+ sys_timer = zOss_CreateTimer("Timer_SysCPUPrint", (ZOSS_TIMER_FUN)Shell_PrintSysCPU, 0, TRUE);
+ if (NULL == sys_timer)
+ {
+ break;
+ }
+ if (ZOSS_ERROR == zOss_StartTimer(sys_timer, (freshTime * 1000), (ZOSS_TIMER_FUN)Shell_PrintSysCPU, 0))
+ {
+ zOss_KillTimer(sys_timer);
+ sys_timer = NULL;
+ }
+ break;
+ }
+ default:
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_ABNORMAL, "\t²ÎÊý´íÎó");
+ break;
+ }
+ }
+}
+
+/**************************************************************************
+* ¹¦ÄÜÃèÊö: OSS_StartDaemonTask
+* ²ÎÊý˵Ã÷:
+* (IN) CmdMsg: shellÃüÁîÏûÏ¢Ö¸Õë
+* (OUT) ÎÞ
+* ·µ »Ø Öµ: ÎÞ
+* ÆäËü˵Ã÷: ÎÞ
+**************************************************************************/
+VOID OSS_StartDaemonTask(T_Shell_CommandMessage *CmdMsg)
+{
+ if(0 == strcmp(CmdMsg->para[0], "help") && CmdMsg->paraCount == 1)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t Æô¶¯ÈÎÎñµÄËÀÑ»·¼à²â£¬¸ÃÃüÁî²»´ø²ÎÊý;");
+ return;
+ }
+
+ if (CmdMsg->paraCount != 0)
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÃüÁîÊäÈë´íÎó;");
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t ÇëÊäÈë%s help²é¿´¸ÃÃüÁîµÄ¹¦ÄÜ;", CmdMsg->cmd);
+ return;
+ }
+
+ if(ZOSS_SUCCESS == EXCEP_StartDaemonTask())
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:Æô¶¯³É¹¦", CmdMsg->cmd);
+
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_TEST, PRINT_LEVEL_NORMAL, "\t%s:Æô¶¯Ê§°Ü", CmdMsg->cmd);
+ }
+
+ return;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_sys.c b/cp/ps/plat/src/oss/sup/src/sup_sys.c
new file mode 100644
index 0000000..636a6f3
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_sys.c
@@ -0,0 +1,581 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : sysmgt.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : OSSÖ÷¿ØÈÎÎñ
+* ×÷ Õß : xiaxinguo
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2007-07-16
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001782014
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0002
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-27
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é EC:617001782003
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+#include "sup.h"
+#include "drv_api.h"
+#include "ThreadPriority.h"
+#include "osa_ramdump.h"
+#include "sup_task.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#define SYSM_STATUS_STARTTASK (ZOSS_STATUS_USERBASE + 1)
+#define SYSM_TASK_NAME "zOss_SysmTask"
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+typedef struct
+{
+ T_ZOss_TaskTabItem *curreatpTaskItem;
+}T_P_DATA;
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+static VOID Sysm_MainProc(UINT8 state, UINT32 msgId, UINT8 *pBuf, UINT16 msgLen, UINT8 *private_data);
+static UINT32 Sysm_PoweronTasks(VOID);
+static UINT32 Sysm_InitTasks(T_ZOss_TaskTabItem *pTaskItem, UINT32 task_index);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+ZOSS_TASK_ID gSysm_SysMTaskID = ZOSS_INVALID_TASK_ID;
+static UINT32 gSysm_AckTaskIndex = 0;
+static BOOL bInit = FALSE;
+static T_ZOss_TaskTabItem *gSysm_TaskTab = NULL;
+ZOSS_TASK_ID *gSysm_TaskIDTab = NULL;
+static UINT32 gSche_Max_TaskTab_Num = 0;
+
+/**************************************************************************
+* Íⲿº¯ÊýÉùÃ÷Çø
+**************************************************************************/
+#ifdef _OS_OSE
+extern UINT32 SYSTIME_Init(VOID);
+#endif
+
+#ifdef _OS_LINUX
+extern void zx29_restart(char str, const char *cmd);
+#endif
+
+#ifdef _USE_WBT
+extern VOID zWbt_Entry(VOID);
+#endif
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_Init
+* ¹¦ÄÜÃèÊö£ºOSS×Óϵͳ³õʼ»¯º¯Êý
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS,·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_Init(VOID)
+{
+ T_OSS_PARAM *pPlatCfg = NULL;
+ UINT32 nRet = ZOSS_SUCCESS;
+
+ if (bInit == TRUE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_SUCCESS;
+ }
+
+ /* oss cfg fs mount*/
+#ifdef _OS_TOS
+ nRet = zOss_FsMount();
+ if (nRet != ZOSS_SUCCESS)
+ {
+ zOss_RamLog((CHAR *)"SysEntry: zOss_FsMount Fail, Code=%d!", nRet);
+ return ZOSS_ERROR;
+ }
+#endif
+
+ /* Timer Init */
+#ifdef _OS_WIN
+ nRet = TIMER_Init();
+ if (nRet != ZOSS_SUCCESS)
+ {
+ zOss_RamLog((CHAR *)"SysEntry: TIMER_Init Fail, Code=%d!", nRet);
+ return ZOSS_ERROR;
+ }
+ zOss_RamLog((CHAR *)"SysEntry(%d): TIMER_Init Start OK!", zOss_GetTickCount());
+#endif
+
+#if 0
+ /* NV Init */
+ #ifndef _USE_SMALL_VERSION
+ nRet = NV_Init();
+ if (nRet != ZOSS_SUCCESS)
+ {
+ zOss_RamLog((CHAR *)"SysEntry: NV_Init Fail, Code=%d!", nRet);
+ return ZOSS_ERROR;
+ }
+ zOss_RamLog((CHAR *)"SysEntry(%d): NV_Init Start OK!", zOss_GetTickCount());
+ #endif
+#endif
+ /* ²ÎÊýÅäÖà */
+ pPlatCfg = zOss_GetOssCfg();
+ gSysm_TaskTab = pPlatCfg->SysmCfg.pSysm_TaskItemTab;
+ gSche_Max_TaskTab_Num = pPlatCfg->SysmCfg.task_num;
+ if (gSche_Max_TaskTab_Num > pPlatCfg->TaskCfg.max_task_num)
+ {
+ return ZOSS_ERROR;
+ }
+ if (gSche_Max_TaskTab_Num != 0)
+ {
+ gSysm_TaskIDTab = (ZOSS_TASK_ID *)zOss_Malloc(sizeof(ZOSS_TASK_ID) * gSche_Max_TaskTab_Num);
+ if (gSysm_TaskIDTab == NULL)
+ {
+ return ZOSS_ERROR;
+ }
+ zOss_Memset((UINT8 *)gSysm_TaskIDTab, 0, sizeof(ZOSS_TASK_ID) * gSche_Max_TaskTab_Num);
+ }
+
+ /* ³õʼ»¯OSS¸÷Ä£¿é£¬Æô¶¯ÏȺó´ÎÐò²»µÃ¸ü¸Ä */
+ /* ³õʼ»¯Sche */
+ nRet = SCHE_Init();
+ if (nRet == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ /* ³õʼ»¯Except */
+ nRet = EXCEP_Init();
+ if (nRet == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ /* ³õʼ»¯test */
+#ifdef ZOSS_TEST_MODE
+ nRet = TEST_Init();
+ if (nRet == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+#endif
+#ifdef _USE_PSM
+ /* Ê¡µç¹ÜÀí³õʼ»¯ */
+#ifdef _USE_PSM_NEW_FRAMEWORK
+ nRet = zOss_PsmInit();
+#else
+ nRet = PSM_Init();
+#endif
+ if (nRet == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+#endif
+
+#ifdef _OS_WIN
+ FS_Init();
+#endif
+
+#ifdef _OS_OSE
+ nRet = SYSTIME_Init();
+ if (nRet == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+#endif
+
+#ifdef _USE_WBT
+ zWbt_Entry();
+#endif
+
+ /* Ramdump Init */
+ zOss_RamdumpInit();
+
+ bInit = TRUE;
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_Start
+* ¹¦ÄÜÃèÊö£ºOSSÆô¶¯º¯Êý
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS,·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_Start(VOID)
+{
+ /* ´´½¨ÏµÍ³ÈÎÎñ */
+ ZOSS_TASK_ID taskId = zOss_CreateTask(SYSM_TASK_NAME, Sysm_MainProc, 2 * 1024, THR_SYSM_PRI, 1024, 0);
+ if (ZOSS_INVALID_TASK_ID == taskId)
+ {
+ return ZOSS_ERROR;
+ }
+
+ gSysm_SysMTaskID = taskId;
+ return zOss_TaskSend(EV_POWERON, NULL, 0, taskId); /* ÏòÖ÷ÈÎÎñ·¢ÉϵçÏûÏ¢ */
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_TaskStartOK
+* ¹¦ÄÜÃèÊö£ºÓÉÏàÓ¦ÈÎÎñµ÷ÓÃ, ÈÎÎñÔÚ´¦ÀíÍêEVENT_INITºó, µ÷Óñ¾º¯Êý£¬
+ ֪ͨÖ÷¿ØÈÎÎñÆô¶¯µÇ¼Ç±íÖÐÏÂÃæµÄÈÎÎñ.
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£º
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID zOss_TaskStartOK(VOID)
+{
+ UINT32 nRet = ZOSS_SUCCESS;
+
+ if (ZOSS_INVALID_TASK_ID == gSysm_SysMTaskID)
+ {
+ gSysm_SysMTaskID = zOss_GetTaskID(SYSM_TASK_NAME); /* »ñÈ¡Ö÷¿ØÈÎÎñID */
+
+ zOss_AssertExN(ZOSS_INVALID_TASK_ID != gSysm_SysMTaskID);
+ }
+ nRet = zOss_TaskSend(EV_POWERON_OK, NULL, 0, gSysm_SysMTaskID);
+
+ zOss_ASSERT(nRet != ZOSS_ERROR);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_SysPowerdown
+* ¹¦ÄÜÃèÊö£º¹Ø»ú
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS,ʧ°Ü·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_SysPowerdown(VOID)
+{
+ zOss_NvramFlush();
+#ifdef _USE_OSS_FS
+ zOss_SyncFS();
+#endif
+ zDrv_ShutDown();
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_SysSoftReset
+* ¹¦ÄÜÃèÊö£ºÈí¼þÖØÆô
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+VOID zOss_SysSoftReset(T_ZOssSys_RESET_TYPE type)
+{
+ if (SYS_RESET_TO_EXCEPTRESET != type)
+ {
+ zOss_NvramFlush();
+#ifdef _USE_OSS_FS
+ zOss_SyncFS();
+#endif
+ }
+
+#ifdef _OS_LINUX
+ switch(type)
+ {
+ case SYS_RESET_TO_CHARGER:
+ zx29_restart(0, "drv_key reboot");
+ break;
+ case SYS_RESET_TO_ALRAM:
+ zx29_restart(0, "mmi_rtc reboot");
+ break;
+ case SYS_RESET_TO_EXCEPTRESET:
+ zx29_restart(0, "drv_except reboot");
+ break;
+ case SYS_RESET_TO_NORMAL:
+ default:
+ zx29_restart(0, NULL);
+ }
+#else
+ switch(type)
+ {
+ case SYS_RESET_TO_NORMAL:
+ zDrv_Soft_Reset(RESET_TO_NORMAL);
+ break;
+ case SYS_RESET_TO_CHARGER:
+ zDrv_Soft_Reset(RESET_TO_CHARGER);
+ break;
+ case SYS_RESET_TO_ALRAM:
+ zDrv_Soft_Reset(RESET_TO_ALRAM);
+ break;
+ case SYS_RESET_TO_EXCEPTRESET:
+ zDrv_Soft_Reset(RESET_TO_EXCEPTRESET);
+ break;
+ default:
+ zDrv_Soft_Reset(RESET_TO_NORMAL);
+ break;
+ }
+#endif
+}
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSysm_MainProc
+* ¹¦ÄÜÃèÊö£ºÆ½Ì¨ÈÎÎñÆô¶¯£¬ÐÒéÕ»ÈÎÎñ¹ÜÀí
+* ²ÎÊý˵Ã÷£º(IN)
+ state:ÈÎÎñ״̬
+ msgId:ÏûÏ¢ID
+ pBuf:ÏûÏ¢Ìå
+ msgLen:ÏûÏ¢³¤¶È
+ pPrivateData:˽ÓÐÊý¾Ý
+ (OUT)
+* ·µ »Ø Öµ£º
+* ÆäËü˵Ã÷£º¿ÉÑ¡
+**************************************************************************/
+static VOID Sysm_MainProc(UINT8 state, UINT32 msgId, UINT8 *pBuf, UINT16 msgLen, UINT8 *pPrivateData)
+{
+ UINT32 task_index = 0;
+ UINT32 nRet = 0;
+ T_P_DATA *ptPData = NULL;
+
+ ptPData = (T_P_DATA *)pPrivateData;
+ switch (state)
+ {
+ case ZOSS_STATUS_INIT:
+ {
+ switch (msgId)
+ {
+ case EV_INIT:
+ {
+ break;
+ }
+ case EV_POWERON:
+ {
+ /* Æô¶¯ÈÎÎñ */
+ ptPData->curreatpTaskItem = gSysm_TaskTab;
+ task_index = 0;
+ task_index = Sysm_InitTasks(ptPData->curreatpTaskItem, task_index);
+ if (gSche_Max_TaskTab_Num == task_index)
+ {
+ /* È«²¿Æô¶¯Íê³É */
+ nRet = Sysm_PoweronTasks();
+ zOss_AssertExN(ZOSS_ERROR != nRet);
+
+ zOss_SetState(ZOSS_STATUS_WORK);
+ }
+ else if (gSche_Max_TaskTab_Num < task_index)
+ {
+ zOss_ASSERT(0);/* ´íÎó */
+ }
+ else
+ {
+ zOss_SetState(SYSM_STATUS_STARTTASK);
+ }
+ break;
+ }
+ default:
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "Sysm_MainProc > Recv unknown msgid=%d\n", msgId);
+ break;
+ }
+ }
+ break;
+ }
+
+ case SYSM_STATUS_STARTTASK:
+ {
+ switch (msgId)
+ {
+ case EV_POWERON_OK:
+ {
+ task_index = Sysm_InitTasks(ptPData->curreatpTaskItem, gSysm_AckTaskIndex + 1);
+ if (gSche_Max_TaskTab_Num == task_index)
+ {
+ /* È«²¿Æô¶¯Íê³É */
+ nRet = Sysm_PoweronTasks();
+ if (ZOSS_SUCCESS == nRet)
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "Poweron All Task OK!!!\n");
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "Poweron Task Fail!!!\n");
+ }
+ zOss_SetState(ZOSS_STATUS_WORK);
+ }
+ else if (gSche_Max_TaskTab_Num < task_index)
+ {
+ /* ´íÎó */
+ }
+
+ break;
+ }
+ case EV_SYSM_DOWN:
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "System Down!!!\n");
+ Nvram_Finish();
+ zOss_Sleep(500);
+ zDrv_ShutDown();
+ break;
+ }
+ default:
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "Sysm_MainProc > Recv unknown msgid=%d\n", msgId);
+ break;
+ }
+ }
+ break;
+ }
+
+ case ZOSS_STATUS_WORK:
+ {
+ switch (msgId)
+ {
+ case EV_SYSM_DOWN:
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "System Down!!!\n");
+ Nvram_Finish();
+ zOss_Sleep(500);
+ zDrv_ShutDown();
+ break;
+ }
+ default:
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "Sysm_MainProc > Recv unknown msgid=%d\n", msgId);
+ break;
+ }
+ }
+ break;
+ }
+
+ default:
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "Sysm_MainProc: recv unknown msgid=%d\n", msgId);
+ break;
+ }
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSysm_PoweronTasks
+* ¹¦ÄÜÃèÊö£ºÆô¶¯ÈÎÎñ×¢²á±íÖеÄÈÎÎñ
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS,·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º¿ÉÑ¡
+**************************************************************************/
+static UINT32 Sysm_PoweronTasks(VOID)
+{
+ UINT32 task_index = 0;
+ UINT32 nRet = ZOSS_SUCCESS;
+
+ for ( ; task_index < gTask_TaskNum; task_index++)
+ {
+ nRet = zOss_GetSemaphore(gSche_SaticTaskInitSema, ZOSS_WAIT_FOREVER);
+ if (nRet != ZOSS_SUCCESS)
+ {
+ return ZOSS_ERROR;
+ }
+ }
+
+ nRet = zOss_DeleteSemaphore(gSche_SaticTaskInitSema);
+
+ if (nRet != ZOSS_SUCCESS)
+ {
+ return ZOSS_ERROR;
+ }
+
+ for ( task_index = 0; task_index < gSche_Max_TaskTab_Num; task_index++)
+ {
+ if (NULL != gSysm_TaskIDTab[task_index])
+ {
+ nRet = zOss_TaskSend(EV_POWERON, NULL, 0, gSysm_TaskIDTab[task_index]);
+ if (ZOSS_ERROR == nRet)
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "Fail!\n");
+ return nRet;
+ }
+ }
+ }
+
+ return nRet;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSysm_InitTasks
+* ¹¦ÄÜÃèÊö£ºÆô¶¯ÈÎÎñ×¢²á±íÖеÄÈÎÎñ
+* ²ÎÊý˵Ã÷£º(IN)
+ pTaskItem:ÈÎÎñ×¢²á±í
+ task_index:ÈÎÎñ×¢²á±íÀïµÄÐòºÅ
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»Ø×îºóÆô¶¯µÄÄǸöÈÎÎñµÄϸöÈÎÎñµÄÐòÁкÅ,·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º¿ÉÑ¡
+**************************************************************************/
+static UINT32 Sysm_InitTasks(T_ZOss_TaskTabItem *pTaskItem, UINT32 task_index)
+{
+ UINT32 nRet = ZOSS_ERROR;
+
+ zOss_AssertEx(pTaskItem != NULL && task_index <= gSche_Max_TaskTab_Num, ZOSS_ERROR);
+
+ pTaskItem = pTaskItem + task_index;
+
+ for ( ; task_index < gSche_Max_TaskTab_Num; task_index++)
+ {
+ if (1 == pTaskItem->is_use)
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "[%d]Start Task %s ", task_index, pTaskItem->task_name);
+
+ /* ·¢Ëͳõʼ»¯ÏûÏ¢ */
+ nRet = zOss_TaskSend(EV_INIT, NULL, 0, gSysm_TaskIDTab[task_index]);
+
+ if (nRet == ZOSS_ERROR)
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "Fail!\n");
+ return ZOSS_ERROR;
+ }
+ else
+ {
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "OK!\n");
+ }
+
+ if (1 == pTaskItem->ack_flag)
+ {
+ gSysm_AckTaskIndex = task_index;
+ zOss_Printf(SUBMDL_SYSM, PRINT_LEVEL_DEBUG, "Wait Ack!!!\n");
+ return task_index;
+ }
+ }
+
+ pTaskItem++;
+ }
+
+ return task_index;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_task.c b/cp/ps/plat/src/oss/sup/src/sup_task.c
new file mode 100755
index 0000000..0be13eb
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_task.c
@@ -0,0 +1,2427 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98C_OSS
+* ÎÄ ¼þ Ãû : taskmgt.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : ÈÎÎñ¹ÜÀíÄ£¿é
+* ×÷ Õß : xiaxinguo
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2007-07-16
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* Ð޸ļǼ
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0001
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-17
+* ÐÞ¸ÄÄÚÈÝ : ¸ñʽ¹æ·¶ºÍPC-LINT×ß²é EC:617001782014
+**************************************************************************/
+/**************************************************************************
+* Ð޸ıàºÅ : 0002
+* ÐÞ ¸Ä ÈË : chenxingfang
+* ÐÞ¸ÄÈÕÆÚ : 2012-09-27
+* ÐÞ¸ÄÄÚÈÝ : ´úÂë×ß²é EC:617001782003
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+#include "sup_task.h"
+#include "osa.h"
+#include "sup.h"
+#include "ThreadPriority.h"
+#include "osa.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+/* ÈÎÎñ¹ÜÀíÄ£¿éÏûÏ¢¶¨Òå */
+#define EV_TASK_END (UINT32)(EV_ZOSS_SCHE_BASE + 0) /* ÈÎÎñÍ˳öÏûÏ¢ */
+#define EV_TASK_CRE (UINT32)(EV_ZOSS_SCHE_BASE + 1) /* ÈÎÎñ´´½¨ÏûÏ¢ */
+
+/**************************************************************************
+* Êý¾Ý½á¹¹¶¨ÒåÇø
+**************************************************************************/
+static struct
+{
+ Task_SEND_HOOK send_to;
+ Task_SEND_DATA_HOOK send_data_to;
+ Task_GET_ALL_ID_HOOK get_all_id;
+ Task_GET_ID_HOOK get_id;
+ Task_GET_THAKNAME_HOOK get_name;
+}gSche_Task_Hook;
+
+typedef struct
+{
+ ZOSS_TASK_ID task_id;
+ UINT32 msg_id;
+ UINT32 arg;
+ T_TIMER_NODE *pTimerNode;
+}T_Task_Arg;
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+static VOID Sche_DefTaskEntry(SINT32 arg); /* µ÷¶ÈÏß³ÌÈë¿Úº¯Êý */
+static UINT32 Sche_AddTCB(T_ZOss_TCB *ptTcb); /* TCB±í¿ØÖƺ¯ÊýÉêÃ÷ */
+static UINT32 Sche_RemoveTCB(T_ZOss_TCB *pDelTcb);
+static T_ZOss_TCB *Sche_GetTCB(const ZOSS_TASK_ID taskId);
+static VOID TaskTimer_CallBack(T_Task_Arg *task_arg);
+static BOOL Timer_IgnoreTaskMsg(ZOSS_TIMER_ID timerId);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+ZOSS_SEMAPHORE_ID gSche_SaticTaskInitSema = NULL;
+__tcm_data UINT32 gTask_TaskNum = 0;
+__tcm_data static T_ZOss_TCB *gSche_TCBHeadPtr = NULL;
+__tcm_data static T_ZOss_TCB *gSche_TCBTailPtr = NULL;
+__tcm_data static UINT32 gSche_MaxTCBLen = 0;
+__tcm_data static ZOSS_MUTEX_ID gSche_TCBMutex = NULL;
+__tcm_data static ZOSS_MUTEX_ID gSche_TRFMutex = NULL;
+__tcm_data static ZOSS_MUTEX_ID gSche_CreMutex = NULL;
+__tcm_data static T_ZOss_List gSche_TRF_List;
+__tcm_data static BOOL gSche_IsTaskInit = FALSE;
+__tcm_data static UINT32 gSche_pDataRegion_Test = 0x5a5a5a5a;
+__tcm_data static T_ZOss_TRF *gSche_ThreadItemTab = NULL;
+__tcm_data static UINT32 gSche_Max_TaskTab_Num = 0;
+__tcm_data static UINT32 gSche_Max_Thread_Num = 0;
+__tcm_data static UINT32 gSche_Max_MsgQueue_Len = 0;
+__tcm_data static UINT32 gSche_DeadLoop_Time = 0;
+__tcm_data static UINT32 gSche_TaskNum = 0;
+__tcm_data static T_ZOss_TaskTabItem *gSche_TaskItemTab = NULL;
+extern BOOL gOsa_SwapTimeFlag;
+extern ZOSS_TASK_ID gExcep_DaemonTask;
+extern ZOSS_TASK_ID *gSysm_TaskIDTab;
+
+#ifdef _USE_SDL
+__tcm_data tasksdl_desc *tasksdl_table = NULL;
+extern const UINT32 nof_signalcode;
+extern struct signalcode_desc signalcode_table[];
+#endif
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSCHE_Init
+* ¹¦ÄÜÃèÊö£º³õʼ»¯ÈÎÎñ¹ÜÀíÄ£¿é
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 SCHE_Init(VOID)
+{
+ T_ZOss_TRF *pTRF = NULL;
+ T_OSS_PARAM *pPlatCfg = NULL;
+ ZOSS_THREAD_ID threadId = NULL;
+ UINT32 i = 0;
+ UINT32 nRet = ZOSS_ERROR;
+ UINT32 priority[8] = {THR1_PRI, THR2_PRI, THR3_PRI, THR4_PRI, THR5_PRI, THR6_PRI, THR7_PRI, THR8_PRI};
+ UINT32 *stSize = NULL;
+
+ if (gSche_IsTaskInit)
+ {
+ return ZOSS_SUCCESS;
+ }
+
+ /* ²ÎÊýÅäÖà */
+ pPlatCfg = zOss_GetOssCfg();
+ gSche_Max_TaskTab_Num = pPlatCfg->TaskCfg.max_task_num;
+ if (gSche_Max_TaskTab_Num < 1)
+ {
+ return ZOSS_ERROR;
+ }
+ gSche_Max_Thread_Num = pPlatCfg->TaskCfg.max_schthread_num;
+ if (!gSche_Max_Thread_Num || gSche_Max_Thread_Num > sizeof(priority)/sizeof(priority[0]))
+ {
+ return ZOSS_ERROR;
+ }
+ gSche_TaskItemTab = pPlatCfg->SysmCfg.pSysm_TaskItemTab;
+ gSche_TaskNum = pPlatCfg->SysmCfg.task_num;
+
+ gSche_Max_MsgQueue_Len = pPlatCfg->TaskCfg.max_msg_queue_len;
+ if (gSche_Max_MsgQueue_Len < 1)
+ {
+ return ZOSS_ERROR;
+ }
+ gSche_DeadLoop_Time = pPlatCfg->TaskCfg.deadloop_time;
+
+ /* ¶¯Ì¬¿Õ¼äÉêÇë */
+ if (gSche_ThreadItemTab == 0)
+ {
+ gSche_ThreadItemTab = (T_ZOss_TRF *)zOss_Malloc(sizeof(T_ZOss_TRF) * gSche_Max_Thread_Num);
+ if (gSche_ThreadItemTab == NULL)
+ {
+ return ZOSS_ERROR;
+ }
+ zOss_Memset((UINT8 *)gSche_ThreadItemTab, 0, sizeof(T_ZOss_TRF) * gSche_Max_Thread_Num);
+ }
+
+ /* ´´½¨»¥³â */
+ gSche_TCBMutex = zOss_CreateMutex("gSche_TCBMutex", ZOSS_INHERIT); /* ´´½¨TCB±í»¥³âÌå */
+ if (NULL == gSche_TCBMutex)
+ {
+ return ZOSS_ERROR;
+ }
+ gSche_TRFMutex = zOss_CreateMutex("gSche_TRFMutex", ZOSS_INHERIT); /* ´´½¨TRF±í»¥³âÌå */
+ if (NULL == gSche_TRFMutex)
+ {
+ return ZOSS_ERROR;
+ }
+ gSche_CreMutex = zOss_CreateMutex("gSche_CreMutex", ZOSS_INHERIT); /* ´´½¨Create»¥³âÌå */
+ if (NULL == gSche_CreMutex)
+ {
+ return ZOSS_ERROR;
+ }
+
+ zOss_ListInit(&gSche_TRF_List); /* ³õʼ»¯TRFÁ´±í */
+
+ stSize = (UINT32 *)zOss_Malloc(gSche_Max_Thread_Num * sizeof(UINT32));
+ if (!stSize)
+ return ZOSS_ERROR;
+
+ for (i = 0; i < gSche_Max_Thread_Num; i++)
+ {
+ stSize[i] = 4096;
+ }
+
+ for (i = 0; i < gSche_TaskNum; i++)
+ {
+ if ((gSche_TaskItemTab + i)->process_no > 0 && (gSche_TaskItemTab + i)->process_no <= gSche_Max_Thread_Num)
+ {
+ if ((gSche_TaskItemTab + i)->stack_size > stSize[(gSche_TaskItemTab + i)->process_no - 1])
+ {
+ stSize[(gSche_TaskItemTab + i)->process_no - 1] = (gSche_TaskItemTab + i)->stack_size;
+ }
+ }
+ }
+
+ for (i = 0; i < gSche_Max_Thread_Num; i++) /* ´´½¨µ÷¶ÈÏß³Ì */
+ {
+ pTRF = &gSche_ThreadItemTab[i];
+ sprintf((char *)pTRF->thread_name, "thread%lu", i + 1);
+ pTRF->priority = priority[i];
+ pTRF->pno = 1;
+
+ /* ´´½¨Ïß³Ì */
+ threadId = zOss_CreateThread(pTRF->thread_name, Sche_DefTaskEntry, (SINT32)pTRF, stSize[i], pTRF->priority, 1, 0);
+ if (threadId == ZOSS_INVALID_THREAD_ID)
+ {
+ zOss_Free((VOID *)stSize);
+ return ZOSS_ERROR;
+ }
+
+ zOss_ListInit(&pTRF->TCBReady); /* ³õʼ»¯¾ÍÐ÷ÈÎÎñÁ´±í */
+ zOss_ListInit(&pTRF->TCBStopped); /* ³õʼ»¯ÔÝÍ£ÈÎÎñÁ´±í */
+ zOss_ListInit(&pTRF->TCBIdle); /* ³õʼ»¯¿ÕÏÐÈÎÎñÁ´±í */
+ pTRF->thread_id = threadId;
+ zOss_ListAdd(&gSche_TRF_List, &(pTRF->node));
+ nRet = Sche_SetTaskID(threadId, pTRF);
+ if (nRet == ZOSS_ERROR)
+ {
+ zOss_Free((VOID *)stSize);
+ return ZOSS_ERROR;
+ }
+ }
+
+ zOss_Free((VOID *)stSize);
+
+
+ /* Æô¶¯µ÷¶ÈÏß³Ì */
+ for (i = 0; i < gSche_Max_Thread_Num; i++)
+ {
+ pTRF = &gSche_ThreadItemTab[i];
+ nRet = zOss_ResumeThread(pTRF->thread_id);
+ if (nRet == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ }
+
+ gSche_MaxTCBLen = 0;
+ gSche_IsTaskInit = TRUE;
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_Task_HookSet
+* ¹¦ÄÜÃèÊö£ºÉèÖÃSDLÏà¹Ø»Øµ÷º¯Êý
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_Task_HookSet(UINT8 type, VOID *HookFunc)
+{
+ switch (type)
+ {
+ case ZOSS_SETHOOK_SEND:
+ {
+ gSche_Task_Hook.send_to = (Task_SEND_HOOK)HookFunc;
+ break;
+ }
+ case ZOSS_SETHOOK_SEND_DATA:
+ {
+ gSche_Task_Hook.send_data_to = (Task_SEND_DATA_HOOK)HookFunc;
+ break;
+ }
+ case ZOSS_SETHOOK_GET_ALL_ID:
+ {
+ gSche_Task_Hook.get_all_id = (Task_GET_ALL_ID_HOOK)HookFunc;
+ break;
+ }
+ case ZOSS_SETHOOK_GET_ID:
+ {
+ gSche_Task_Hook.get_id = (Task_GET_ID_HOOK)HookFunc;
+ break;
+ }
+ case ZOSS_SETHOOK_GET_NAME:
+ {
+ gSche_Task_Hook.get_name = (Task_GET_THAKNAME_HOOK)HookFunc;
+ break;
+ }
+ default:
+ {
+ return ZOSS_ERROR;
+ }
+ }
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_CreateTask
+* ¹¦ÄÜÃèÊö£º¸Ãº¯ÊýÓÃÓÚ´´½¨Ò»¸öÐÂÈÎÎñ
+* ²ÎÊý˵Ã÷£º(IN)
+ thread_name: ÈÎÎñÃû³Æ
+ entry: ÈÎÎñÖ´ÐеÄÈë¿Úº¯Êý
+ stack_size: ¶ÑÕ»´óС£¨µ¥Î»£º×Ö½Ú£©,ĬÈÏֵΪ0
+ priority: Ïß³ÌÓÅÏȼ¶£¨0-31£©, pnoΪ0ʱÓÐÓã¬ÖµÔ½µÍÓÅÏȼ¶Ô½¸ß
+ private_data_len: ÈÎÎñ˽ÓÐÊý¾ÝµÄ´óС
+ pno:µ÷¶ÈÏ̱߳àºÅ(1-8)
+ is_static:ÊÇ·ñ¾²Ì¬ÈÎÎñ
+ (OUT)
+* ·µ »Ø Öµ£º·µ»ØÈÎÎñID,ʧ°Ü·µ»ØZOSS_INVALID_TASK_ID
+* ÆäËû˵Ã÷£º
+**************************************************************************/
+ZOSS_TASK_ID zOss_CreateTask_EX(const CHAR *task_name,
+ FUNC_TASKENTRY task_entry,
+ UINT32 stack_size,
+ UINT32 priority,
+ UINT32 private_data_len,
+ UINT8 pno,
+ UINT8 is_static)
+{
+ ZOSS_THREAD_ID threadId = NULL;
+ ZOSS_TASK_ID testtaskId = NULL;
+ UINT8 *pDataRegion = NULL;
+ T_ZOss_TCB *pTCB = NULL;
+ T_ZOss_TRF *pTRF = NULL;
+ UINT32 nRet = ZOSS_ERROR;
+ UINT32 status = ZOSS_ERROR;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ zOss_AssertEx(NULL != task_name && NULL != task_entry, ZOSS_INVALID_TASK_ID);
+ zOss_AssertEx(0 < stack_size && pno <= gSche_Max_Thread_Num, ZOSS_INVALID_TASK_ID);
+
+ if (strlen((char *)task_name) > ZOSS_MAX_TASKNAME_LEN)
+ {
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ if (ZOSS_SUCCESS != zOss_GetMutex(gSche_CreMutex, ZOSS_WAIT_FOREVER))
+ {
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ testtaskId = zOss_GetTaskID(task_name);
+ zOss_ASSERT(ZOSS_INVALID_TASK_ID == testtaskId);
+ if (ZOSS_INVALID_TASK_ID != testtaskId)
+ {
+ zOss_PutMutex(gSche_CreMutex);
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ /* ²úÉúÈÎÎñ¿ØÖÆ¿éTCB */
+ pTCB = (T_ZOss_TCB *)zOss_Malloc(sizeof(T_ZOss_TCB));
+ if (NULL == pTCB)
+ {
+ zOss_PutMutex(gSche_CreMutex);
+ return ZOSS_INVALID_TASK_ID;
+ }
+ zOss_Memset((UINT8 *)pTCB, 0, sizeof(T_ZOss_TCB));
+
+ /* ·ÖÅäÓû§Ë½ÓÐÊý¾Ý¿Õ¼ä */
+ if (0 == private_data_len)
+ {
+ pDataRegion = NULL;
+ }
+ else
+ {
+ private_data_len = ALIGN_TO(private_data_len, sizeof(UINT32));
+ pDataRegion = (UINT8 *)zOss_Malloc(private_data_len + 4); /* Óû§Êý¾ÝÇø */
+ if (NULL == pDataRegion)
+ {
+ zOss_PutMutex(gSche_CreMutex);
+ zOss_Free(pTCB);
+ return ZOSS_INVALID_TASK_ID;
+ }
+ zOss_Memset(pDataRegion, 0, private_data_len);
+ *(UINT32 *)((UINT32)pDataRegion + private_data_len) = gSche_pDataRegion_Test;
+ }
+
+ /* ÏòTCB±íÌí¼ÓÈÎÎñÐÅÏ¢ */
+ zOss_ListInit(&pTCB->msg_queue);
+ pTCB->taskData = pDataRegion;
+ strncpy((char *)pTCB->task_name,(const char *)task_name,ZOSS_MAX_TASKNAME_LEN);
+ pTCB->task_name[ZOSS_MAX_TASKNAME_LEN] = '\0';
+ pTCB->taskEntry = task_entry;
+ pTCB->HookEntry[0] = NULL;
+ pTCB->HookEntry[1] = NULL;
+ pTCB->HookEntry[2] = NULL;
+ pTCB->state = ZOSS_STATUS_INIT;
+ pTCB->priority = priority;
+ pTCB->stack_size = stack_size;
+ pTCB->private_data_len = private_data_len;
+ pTCB->task_time = 0;
+ pTCB->sender_task_id = NULL;
+ pTCB->thread_no = pno;
+ pTCB->type = SCHE_OSS_TASK;
+ pTCB->reserved[0] = is_static;
+ pTCB->malloc_size = 0xFFFFFFFF; /* mallocδʵÏÖ */
+
+ if (pno == 0) /* Èç¹ûÊǶÀÕ¼Ị̈߳¬ÔòÐèÒªµ¥¶À´´½¨Ò»¸öµ÷¶ÈÏß³Ì */
+ {
+ /* ²úÉúÏ̵߳ǼDZí */
+ pTRF = (T_ZOss_TRF *)zOss_Malloc(sizeof(T_ZOss_TRF));
+ if (NULL == pTRF)
+ {
+ zOss_PutMutex(gSche_CreMutex);
+ if (0 != private_data_len)
+ {
+ zOss_Free(pDataRegion);
+ }
+ zOss_Free((UINT8 *)pTCB);
+ return ZOSS_INVALID_TASK_ID;
+ }
+ zOss_Memset((UINT8 *)pTRF, 0, sizeof(T_ZOss_TRF));
+
+ /* ´´½¨µ÷¶ÈÏß³Ì */
+ threadId = zOss_CreateThread(task_name, Sche_DefTaskEntry, (SINT32)pTRF, stack_size, priority, 1, 0);
+ if (threadId == ZOSS_INVALID_THREAD_ID) /* Èç¹û´´½¨Ê§°ÜÔòÊÍ·Å¿Õ¼ä */
+ {
+ zOss_PutMutex(gSche_CreMutex);
+ SCHE_printf("Fail!\n");
+ if (0 != private_data_len)
+ {
+ zOss_Free(pDataRegion);
+ }
+ zOss_Free((UINT8 *)pTCB);
+ zOss_Free((UINT8 *)pTRF);
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ /* ³õʼ»¯ÈÎÎñÁ´±í */
+ zOss_ListInit(&pTRF->TCBReady);
+ zOss_ListInit(&pTRF->TCBStopped);
+ zOss_ListInit(&pTRF->TCBIdle);
+
+ /* ÏòÏ̵߳ǼDZíÖÐдÈëµ÷¶ÈÏß³ÌÐÅÏ¢ */
+ pTRF->priority = priority;
+ pTRF->thread_id = threadId;
+ pTRF->pno = 0;
+
+ /* ½«ÈÎÎñ¹ÒÈëµ÷¶ÈÏß³Ì */
+ pTCB->thread_id = threadId;
+
+ nRet = Sche_SetTaskID(threadId, pTRF);
+ if (nRet == ZOSS_ERROR)
+ {
+ zOss_PutMutex(gSche_CreMutex);
+
+ SCHE_printf("Fail!\n");
+ if (0 != private_data_len)
+ {
+ zOss_Free(pDataRegion);
+ }
+ zOss_Free((UINT8 *)pTCB);
+ zOss_Free((UINT8 *)pTRF);
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ /* ½«Ï̵߳ǼDZí¹ÒÈëTRFÁ´±í */
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TRFMutex, ZOSS_WAIT_FOREVER))
+ {
+ zOss_ListAdd(&gSche_TRF_List, &(pTRF->node));
+
+ /* Æô¶¯µ÷¶ÈÏß³Ì */
+ nRet = zOss_ResumeThread(threadId);
+ if (nRet == ZOSS_ERROR) /* Èç¹ûÆô¶¯Ê§°ÜÔòÊÍ·Å¿Õ¼ä */
+ {
+ zOss_PutMutex(gSche_CreMutex);
+ SCHE_printf("Fail!\n");
+ if (0 != private_data_len)
+ {
+ zOss_Free(pDataRegion);
+ }
+ zOss_Free((UINT8 *)pTCB);
+ status = zOss_DeleteThread(threadId);
+ if (status == ZOSS_SUCCESS)
+ {
+ zOss_ListDelete(&gSche_TRF_List, &(pTRF->node));
+ zOss_Free((UINT8 *)pTRF);
+ }
+ zOss_PutMutex(gSche_TRFMutex);
+ return ZOSS_INVALID_TASK_ID;
+ }
+ zOss_PutMutex(gSche_TRFMutex);
+ }
+ }
+ else /* ·Ç¶Àռʱ¸ù¾Ýµ÷¶ÈÏ̺߳Ž«ÈÎÎñ¹ÒÈëÏàÓ¦µ÷¶ÈÏß³Ì */
+ {
+ pTRF = &gSche_ThreadItemTab[pno - 1];
+ pTCB->thread_id = pTRF->thread_id;
+ }
+
+ /* ½«ÈÎÎñ¿ØÖÆ¿épTaskInfo¹Òµ½ÈÎÎñÁбíÉÏ */
+ nRet = Sche_AddTCB(pTCB);
+ if (nRet == ZOSS_ERROR) /* Èç¹ûʧ°ÜÔò±íʾ³¬¹ý×î´óÈÎÎñÊý */
+ {
+ zOss_PutMutex(gSche_CreMutex);
+ SCHE_printf("Fail!\n");
+ if (0 != private_data_len)
+ {
+ zOss_Free(pDataRegion);
+ }
+ zOss_Free((UINT8 *)pTCB);
+ if (pno == 0) /* Èç¹ûÊǶÀÕ¼µ÷¶ÈÏß³ÌÔòÐèҪɾ³ýÏß³Ì */
+ {
+ status = zOss_DeleteThread(threadId);
+ if (status == ZOSS_SUCCESS )
+ {
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TRFMutex, ZOSS_WAIT_FOREVER))
+ {
+ zOss_ListDelete(&gSche_TRF_List, &(pTRF->node));
+ nRet = zOss_PutMutex(gSche_TRFMutex);
+ if (nRet == ZOSS_ERROR)
+ {
+ return NULL;
+ }
+ }
+ zOss_Free((UINT8 *)pTRF);
+ }
+ }
+
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ pTCB->time = zOss_GetTickCount();
+ pTCB->task_id = (ZOSS_TASK_ID)pTCB;
+
+ zOss_PutMutex(gSche_CreMutex);
+
+ /* Ïòµ÷¶ÈÏ̷߳¢ÈÎÎñ´´½¨ÏûÏ¢ */
+ zOss_TaskSend(EV_TASK_CRE, NULL, 0, (ZOSS_TASK_ID)pTCB);
+ return pTCB;
+}
+
+ZOSS_TASK_ID zOss_CreateTask(const CHAR *task_name,
+ FUNC_TASKENTRY task_entry,
+ UINT32 stack_size,
+ UINT32 priority,
+ UINT32 private_data_len,
+ UINT8 pno)
+{
+ ZOSS_TASK_ID taskID = NULL;
+ UINT32 nRet = 0;
+
+ taskID = zOss_CreateTask_EX(task_name, task_entry, stack_size, priority, private_data_len, pno, 0);
+ if (taskID != ZOSS_INVALID_TASK_ID)
+ {
+ nRet = zOss_TaskSend(EV_INIT, NULL, 0, taskID);
+ zOss_AssertEx(nRet != ZOSS_ERROR, ZOSS_INVALID_TASK_ID);
+ }
+ return taskID;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_DeleteTask
+* ¹¦ÄÜÃèÊö£º¸Ãº¯ÊýÓÃÓÚɾ³ýÒ»¸öÈÎÎñ
+* ²ÎÊý˵Ã÷£º(IN)
+ task_id:ÈÎÎñID,Èç¹ûΪ0£¬Ôòɾ³ýµ±Ç°ÈÎÎñ
+ (OUT)
+* ·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËû˵Ã÷£º²»»áÁ¢¼´É¾³ý£¬ÈÎÎñ»á´¦ÀíÍ굱ǰÏûÏ¢
+**************************************************************************/
+UINT32 zOss_DeleteTask(ZOSS_TASK_ID task_id)
+{
+ T_ZOss_TCB *pTCB = NULL;
+ UINT32 status = ZOSS_ERROR;
+ UINT32 nore = ZOSS_ERROR;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_ERROR;
+ }
+
+ if (NULL == task_id) /* ÈÎÎñIDΪ¿ÕÔòɾ³ýµ±Ç°ÈÎÎñ */
+ {
+ task_id = zOss_GetSelfTaskID(); /* »ñÈ¡µ±Ç°ÈÎÎñID */
+ if (task_id == ZOSS_INVALID_TASK_ID)
+ {
+ return ZOSS_ERROR;
+ }
+ }
+
+ pTCB = (T_ZOss_TCB *)task_id; /* »ñÈ¡ÈÎÎñTCB±í */
+
+ if (pTCB->type != SCHE_OSS_TASK)
+ {
+ return ZOSS_ERROR;
+ }
+
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER)) /* ÐźÅÁ¿±£»¤ */
+ {
+ if (task_id == pTCB->task_id) /* ¼ì²éÈÎÎñÊÇ·ñ´æÔÚ */
+ {
+ status = zOss_TaskSend(EV_TASK_END, NULL, 0, task_id); /* Ïòµ÷¶ÈÏ̷߳¢É¾³ýÏûÏ¢ */
+ pTCB->task_id = NULL;
+ }
+ else
+ {
+ zOss_PutMutex(gSche_TCBMutex);
+ return ZOSS_ERROR;
+ }
+ nore = zOss_PutMutex(gSche_TCBMutex);
+ if (nore == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ }
+
+ return status;
+}
+
+/**************************************************************************
+*º¯ÊýÃû³Æ£ºzOss_PauseTask
+*¹¦ÄÜÃèÊö£ºÔÝÍ£ÈÎÎñÖ´ÐÐ
+*²ÎÊý˵Ã÷£ºtask_id:´ýÔÝÍ£ÈÎÎñµÄID
+*·µ»ØÖµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+*ÆäËû˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_PauseTask(ZOSS_TASK_ID task_id)
+{
+ return ZOSS_ERROR;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_ResumTask
+* ¹¦ÄÜÃèÊö£º»Ö¸´ÈÎÎñ,תµ½¾ÍÐ÷̬
+* ²ÎÊý˵Ã÷£º(IN)
+ task_id:´ý»Ö¸´ÈÎÎñµÄID
+ (OUT)
+* ·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËû˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_ResumeTask(ZOSS_TASK_ID task_id)
+{
+ return ZOSS_ERROR;
+}
+
+/**************************************************************************
+*º¯ÊýÃû³Æ£ºzOss_GetTaskInfo
+*¹¦ÄÜÃèÊö£º»ñÈ¡ÈÎÎñÐÅÏ¢
+*²ÎÊý˵Ã÷£º(IN)
+ task_id:ÈÎÎñID,Èç¹ûΪ0£¬»ñÈ¡µ±Ç°ÈÎÎñÐÅÏ¢
+ task_info:ÈÎÎñ¿ØÖÆ¿é±íÖ¸Õ룬ָÏò´æ·Å¸ÃÈÎÎñÐÅÏ¢µÄ´æ´¢¿é£¬ÔÚµ÷ÓÃ
+ Ç°³õʼ»¯
+ (OUT)
+*·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+*ÆäËû˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_GetTaskInfo(ZOSS_TASK_ID task_id, T_ZOss_TCB *task_info)
+{
+ T_ZOss_TCB *pTCB = NULL;
+ UINT32 nore = ZOSS_ERROR;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_ERROR;
+ }
+
+ zOss_AssertEx(NULL != task_info, ZOSS_ERROR);
+
+ if (ZOSS_INVALID_TASK_ID == task_id) /* ÈÎÎñIDΪ¿ÕÔò»ñÈ¡µ±Ç°ÈÎÎñÐÅÏ¢ */
+ {
+ task_id = zOss_GetSelfTaskID();
+ if (task_id == ZOSS_INVALID_TASK_ID)
+ {
+ return ZOSS_ERROR;
+ }
+ }
+
+ pTCB = (T_ZOss_TCB *)task_id; /* »ñÈ¡ÈÎÎñTCB±í */
+
+ if (pTCB->type != SCHE_OSS_TASK)
+ {
+ return ZOSS_ERROR;
+ }
+
+ /* ÐźÅÁ¿±£»¤ */
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER))
+ {
+ if (task_id == pTCB->task_id) /* ÈÎÎñ´æÔÚ */
+ {
+ *task_info = *pTCB; /* »ñÈ¡ÈÎÎñÐÅÏ¢ */
+ nore = zOss_PutMutex(gSche_TCBMutex);
+ if (nore == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ return ZOSS_SUCCESS;
+ }
+ zOss_PutMutex(gSche_TCBMutex);
+ }
+
+ return ZOSS_ERROR;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_GetAllTaskInfo
+* ¹¦ÄÜÃèÊö£º»ñÈ¡µ±Ç°ËùÓзÇSDLÈÎÎñµÄÏà¹ØÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN)
+* (OUT) pMonTaskInfo: ÈÎÎñÐÅÏ¢´æ·ÅµØÖ·
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËû˵Ã÷£º´Ëº¯ÊýÉêÇëµÄÄÚ´æ¿Õ¼ä£¬±ØÐëÓÉʹÓÃÕßÊÍ·Å£¬·ñÔò»áÔì³ÉÄÚ´æй¶¡£
+**************************************************************************/
+VOID zOss_GetAllTaskInfo(T_ZOss_Mon_Task *pMonTaskInfo)
+{
+#ifdef _USE_MONITOR
+ T_ZOss_Mon_Task taskInfo = {0};
+ T_ZOss_TCB *TCBNode = NULL;
+ UINT32 cnt = 0;
+
+ if (pMonTaskInfo == NULL)
+ {
+ return;
+ }
+
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER))
+ {
+ taskInfo.num = gSche_MaxTCBLen;
+ taskInfo.ele = (T_ZOss_Mon_Task_Ele *)zOss_GetUB(taskInfo.num * sizeof(T_ZOss_Mon_Task_Ele));
+ zOss_AssertExN(taskInfo.ele != NULL);
+ TCBNode = gSche_TCBHeadPtr;
+ for (cnt = 0; cnt < taskInfo.num ; cnt++)
+ {
+ taskInfo.ele[cnt].name = TCBNode->task_name;
+ taskInfo.ele[cnt].handle = (UINT32)TCBNode->task_id;
+ taskInfo.ele[cnt].thread_handle = (UINT32)TCBNode->thread_id;
+ taskInfo.ele[cnt].status = TCBNode->run_status;
+ TCBNode = TCBNode->next;
+ }
+ zOss_PutMutex(gSche_TCBMutex);
+
+ pMonTaskInfo->num = taskInfo.num;
+ pMonTaskInfo->ele = taskInfo.ele;
+ }
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_GetAllTaskID
+* ¹¦ÄÜÃèÊö£º»ñÈ¡ËùÓÐÈÎÎñID£¬°üÀ¨SDLÈÎÎñ
+* ²ÎÊý˵Ã÷£º(IN)
+ task_id_arr:´æ·ÅÈÎÎñIDµÄÖ¸Õ룬ÔÚµ÷ÓÃÇ°³õʼ»¯
+ (OUT)
+* ·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØÈÎÎñÊý£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËû˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_GetAllTaskID(ZOSS_TASK_ID *task_id_arr)
+{
+ T_ZOss_TCB *pCurTCB = NULL;
+ UINT32 tasknum = 0;
+ UINT32 sdltasknum = 0;
+ UINT32 nore = ZOSS_ERROR;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_ERROR;
+ }
+
+ zOss_AssertEx(NULL != task_id_arr, ZOSS_ERROR);
+
+ /* ÐźÅÁ¿±£»¤ */
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER))
+ {
+ /* È¡Ò»°ãÈÎÎñID */
+ if (NULL != gSche_TCBHeadPtr) /* Á´±í²»Îª¿Õ */
+ {
+ pCurTCB = gSche_TCBHeadPtr;
+ while (NULL != pCurTCB)
+ {
+ if (pCurTCB == (T_ZOss_TCB *)pCurTCB->task_id)
+ {
+ *task_id_arr = pCurTCB->task_id;
+ tasknum++;
+ }
+ pCurTCB = pCurTCB->next;
+ task_id_arr++;
+ }
+ }
+
+ /* È¡SDLÈÎÎñID */
+ if (gSche_Task_Hook.get_all_id != NULL)
+ {
+ sdltasknum = gSche_Task_Hook.get_all_id(task_id_arr);
+ }
+
+ nore = zOss_PutMutex(gSche_TCBMutex);
+ if (nore == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ return (tasknum + sdltasknum);
+ }
+ return 0;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_TaskSend
+* ¹¦ÄÜÃèÊö£º¸øÈÎÎñ·¢ËÍÒì²½ÏûÏ¢
+* ²ÎÊý˵Ã÷£º(IN)
+ msg:ÏûÏ¢ID
+ msg_buf:ÏûÏ¢¶ÑÕ»
+ msg_len:ÏûÏ¢³¤¶È
+ task_id:Ä¿±êÈÎÎñID
+ (OUT)
+* ·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËû˵Ã÷£º±¾½Ó¿Ú×èÈû£¬²»ÄÜÔÚÖжÏÖÐʹÓÃ
+**************************************************************************/
+__tcm_func UINT32 zOss_TaskSend(UINT32 msg_id, const VOID *buf, UINT16 msg_len, ZOSS_TASK_ID task_id)
+{
+ UINT32 nRet = ZOSS_ERROR;
+ T_ZOss_TaskMsgHead *pMsg = NULL;
+ T_ZOss_TCB *pTCB = NULL;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_ERROR;
+ }
+
+ zOss_AssertEx(NULL != task_id, ZOSS_ERROR);
+
+ if (gSche_Task_Hook.send_to != NULL)
+ {
+ nRet = gSche_Task_Hook.send_to(msg_id, buf, msg_len, task_id, zOss_GetSelfTaskID());
+ if (nRet == ZOSS_SUCCESS)
+ {
+ return ZOSS_SUCCESS;
+ }
+ }
+
+ /* ¶¨Î»Ä¿±êÈÎÎñ */
+ pTCB = (T_ZOss_TCB *)task_id; /* »ñÈ¡Ä¿±êÈÎÎñTCB±í */
+ if (task_id != pTCB->task_id) /* ÈÎÎñ²»´æÔÚ */
+ {
+ return ZOSS_ERROR;
+ }
+
+ /* ·ÖÅäÏûÏ¢¿Õ¼ä */
+ pMsg = (T_ZOss_TaskMsgHead *)zOss_GetUB(msg_len + SCHE_M_TASKMSGHEAD_LEN);
+ if (NULL == pMsg)
+ {
+ return ZOSS_ERROR;
+ }
+ /* дÏûϢͷ */
+ pMsg->t_task_id = task_id;
+ pMsg->s_task_id = zOss_GetSelfTaskID();
+ pMsg->send_state = ZOSS_MSGSENDTYPE_MSG;
+ pMsg->msgID = msg_id;
+ pMsg->msgLen = msg_len;
+ if (msg_len > 0 && buf != NULL)
+ {
+ zOss_Memcpy((UINT8 *)(pMsg + 1), (UINT8 *)buf, msg_len);
+ }
+ /* ·¢ËÍÏûÏ¢ */
+ nRet = zOss_TaskSendDataEx(pMsg);
+
+ return nRet;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_TaskSendData
+* ¹¦ÄÜÃèÊö£º¸øÆäËûÈÎÎñ·¢ËÍÒì²½ÏûÏ¢
+* ²ÎÊý˵Ã÷£º(IN)
+ msg:ÏûÏ¢ID
+ msg_buf:ÏûÏ¢¶ÑÕ»
+ msg_len:ÏûÏ¢³¤¶È
+ task_id:Ä¿±êÈÎÎñID
+ (OUT)
+* ·µ »Ø Öµ£º Èç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËû˵Ã÷£º±¾½Ó¿Ú×èÈû£¬²»ÄÜÔÚÖжÏÖÐʹÓà £¬Ö»´«µÝ
+ ÏûÏ¢Ö¸Õ룬²»×ö¿½±´£¬Òò´ËÏûÏ¢ÓÉÓû§ÊÍ·Å
+**************************************************************************/
+CODE_BEGIN(.PLAT_TCM_CODE)
+__tcm_func UINT32 zOss_TaskSendData(UINT32 msg_id, VOID *buf, UINT16 msg_len, ZOSS_TASK_ID task_id)
+{
+ UINT32 nRet = ZOSS_ERROR;
+ T_ZOss_TaskMsgHead *pMsg = NULL;
+ T_ZOss_TaskMsg *pBuf = NULL;
+ T_ZOss_TCB *pTCB = NULL;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_ERROR;
+ }
+
+ zOss_AssertEx(NULL != task_id, ZOSS_ERROR);
+
+ if (gSche_Task_Hook.send_to != NULL)
+ {
+ nRet = gSche_Task_Hook.send_to(msg_id, buf, msg_len, task_id, zOss_GetSelfTaskID());
+ if (nRet == ZOSS_SUCCESS)
+ {
+ if (buf != NULL)
+ {
+ if (ZOSS_SUCCESS != zOss_RetUB(buf))
+ {
+ return ZOSS_ERROR;
+ }
+ }
+ return ZOSS_SUCCESS;
+ }
+ }
+
+ /* ¶¨Î»Ä¿±êÈÎÎñ */
+ pTCB = (T_ZOss_TCB *)task_id; /* »ñÈ¡Ä¿±êÈÎÎñTCB±í */
+ if (task_id != pTCB->task_id) /* ÈÎÎñ²»´æÔÚ */
+ {
+ return ZOSS_ERROR;
+ }
+
+ /* ·ÖÅäÏûÏ¢¿Õ¼ä */
+ pMsg = (T_ZOss_TaskMsgHead *)zOss_GetUB(SCHE_M_TASKMSGEX_LEN + SCHE_M_TASKMSGHEAD_LEN);
+ if (NULL == pMsg)
+ {
+ return ZOSS_ERROR;
+ }
+ pBuf = (T_ZOss_TaskMsg *)(pMsg + 1);
+
+ /* дÏûϢͷ */
+ pMsg->t_task_id = task_id;
+ pMsg->s_task_id = zOss_GetSelfTaskID();
+ pMsg->send_state = ZOSS_MSGSENDTYPE_DATA;
+ pMsg->msgID = msg_id;
+ pMsg->msgLen = SCHE_M_TASKMSGEX_LEN;
+ pBuf->msgbuf = buf;
+ pBuf->msgLenEX = msg_len;
+
+ /* ·¢ËÍÏûÏ¢ */
+ nRet = zOss_TaskSendDataEx(pMsg);
+
+ return nRet;
+}
+CODE_END
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_TaskSendDataEx
+* ¹¦ÄÜÃèÊö£º¸øÆäËûÈÎÎñ´«µÝÏûÏ¢Ìå
+* ²ÎÊý˵Ã÷£º(IN)
+ buf:ÏûÏ¢¶ÑÕ»
+ (OUT)
+* ·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËû˵Ã÷£º±¾½Ó¿Ú×èÈû£¬²»ÄÜÔÚÖжÏÖÐʹÓÃ
+**************************************************************************/
+__tcm_func UINT32 zOss_TaskSendDataEx(T_ZOss_TaskMsgHead *buf)
+{
+ UINT32 nRet = ZOSS_ERROR;
+ T_ZOss_TCB *pTCB = NULL;
+ T_ZOss_TRF *pTRF = NULL;
+ ZOSS_THREAD_ID threadId = NULL;
+#if ZOSS_CAPT_MSG
+ UINT32 i = 0;
+ T_ZOss_TCB *pSTCB = NULL;
+ T_ZOss_SDLTCB *pSSTCB = NULL;
+ UINT8 fleg[3] = {0};
+#endif
+
+ zOss_AssertEx(buf != NULL, ZOSS_ERROR);
+
+ if (gSche_IsTaskInit == FALSE || buf->t_task_id == NULL
+ || buf->send_state > ZOSS_MSGSENDTYPE_TIMER || buf->send_state < ZOSS_MSGSENDTYPE_MSG)
+ {
+ zOss_RetUB(buf);
+ return ZOSS_ERROR;
+ }
+
+ if (buf->send_state == ZOSS_MSGSENDTYPE_DATA && gSche_Task_Hook.send_data_to != NULL)
+ {
+ nRet = gSche_Task_Hook.send_data_to(buf->msgID, ((T_ZOss_TaskMsg *)(buf + 1))->msgbuf,
+ ((T_ZOss_TaskMsg *)(buf + 1))->msgLenEX, buf->t_task_id, buf->s_task_id);
+ }
+ else if (buf->send_state == ZOSS_MSGSENDTYPE_MSG && gSche_Task_Hook.send_to != NULL)
+ {
+ nRet = gSche_Task_Hook.send_to(buf->msgID, buf + 1, buf->msgLen, buf->t_task_id, buf->s_task_id);
+ }
+ if (nRet == ZOSS_SUCCESS)
+ {
+ zOss_RetUB(buf);
+ return ZOSS_SUCCESS;
+ }
+
+ /* ¶¨Î»Ä¿±êÈÎÎñ */
+ pTCB = (T_ZOss_TCB *)buf->t_task_id; /* »ñÈ¡Ä¿±êÈÎÎñTCB±í */
+ if (buf->t_task_id == pTCB->task_id) /* ÈÎÎñ´æÔÚ */
+ {
+ threadId = pTCB->thread_id; /* »ñÈ¡Ä¿±êÈÎÎñËùÔÚµ÷¶ÈÏß³ÌID */
+ }
+ else
+ {
+ zOss_RetUB(buf);
+ return ZOSS_ERROR;
+ }
+
+#if ZOSS_CAPT_MSG
+ /* ·¢ËÍÏûÏ¢²¶»ñ */
+ if (buf->s_task_id != NULL) /* Ô´²»ÎªÏß³Ì */
+ {
+ pSTCB = (T_ZOss_TCB *)buf->s_task_id;
+ if (pSTCB->type == SCHE_OSS_TASK) /*ԴΪ·ÇSDLÈÎÎñ */
+ {
+ for (i = 0; i < 3; i++)
+ {
+ if (pSTCB->dire[i] == ZOSS_MSGDIRE_OUT || pSTCB->dire[i] == ZOSS_MSGDIRE_INOUT)
+ {
+ fleg[i] = 1;
+ nRet = pSTCB->HookEntry[i](buf, ZOSS_MSGDIRE_OUT);
+ }
+ }
+ }
+ else if (pSTCB->type == SCHE_SDL_TASK) /* ԴΪSDL ÈÎÎñ */
+ {
+ pSSTCB = (T_ZOss_SDLTCB *)buf->s_task_id;
+ for (i = 0; i < 3; i++)
+ {
+ if (pSSTCB->dire[i] == ZOSS_MSGDIRE_OUT || pSSTCB->dire[i] == ZOSS_MSGDIRE_INOUT)
+ {
+ fleg[i] = 1;
+ nRet = pSSTCB->HookEntry[i](buf, ZOSS_MSGDIRE_OUT);
+ }
+ }
+ }
+ if (fleg[2] == 1)
+ {
+ zOss_RetUB((UINT8 *)buf);
+ return ZOSS_SUCCESS;
+ }
+ }
+
+ /* ½ÓÊÕÏûÏ¢²¶»ñ */
+ for (i = 0; i < 3; i++)
+ {
+ if (fleg[i] == 0 && (pTCB->dire[i] == ZOSS_MSGDIRE_IN || pTCB->dire[i] == ZOSS_MSGDIRE_INOUT))
+ {
+ fleg[i] = 1;
+ nRet = pTCB->HookEntry[i](buf, ZOSS_MSGDIRE_IN);
+ }
+ }
+ if (fleg[2] == 1)
+ {
+ zOss_RetUB((UINT8 *)buf);
+ return ZOSS_SUCCESS;
+ }
+
+#endif
+ /* ÌØÊâÏûÏ¢ */
+ if (buf->msgID == EV_TASK_CRE || buf->msgID == EV_TASK_END || buf->msgID == EV_INIT || buf->msgID == EV_POWERON)
+ {
+ nRet = zOss_SendMsg(threadId, (UINT8 *)buf, buf->msgLen + SCHE_M_TASKMSGHEAD_LEN, ZOSS_WAIT_FOREVER);
+ if (nRet == ZOSS_ERROR)
+ {
+ zOss_RetUB((UINT8 *)buf);
+ }
+ return nRet;
+ }
+
+ /* Ïß³ÌÏòÈÎÎñ·¢ÏûÏ¢ */
+ if (buf->s_task_id == NULL)
+ {
+ nRet = zOss_SendMsg(threadId, (UINT8 *)buf, buf->msgLen + SCHE_M_TASKMSGHEAD_LEN, ZOSS_WAIT_FOREVER);
+ if (nRet == ZOSS_ERROR)
+ {
+ zOss_RetUB((UINT8 *)buf);
+ }
+ return nRet;
+ }
+
+ /* ÆÕͨÏûÏ¢ */
+ if (threadId == zOss_GetCurThreadID())
+ {
+ /* ÔÚͬһµ÷¶ÈÏß³ÌÖÐ */
+ zOss_ListAdd(&pTCB->msg_queue, &(buf->node));
+ if (pTCB->run_status == ZOSS_STATE_IDLE)
+ {
+ pTRF = &gSche_ThreadItemTab[pTCB->thread_no - 1];
+ zOss_ListDelete(&(pTRF->TCBIdle), &(pTCB->node));
+ zOss_ListAdd(&(pTRF->TCBReady), &(pTCB->node));
+ pTCB->run_status = ZOSS_STATE_READY;
+ }
+ return ZOSS_SUCCESS;
+ }
+ else
+ {
+ /* ²»ÔÚͬһµ÷¶ÈÏß³ÌÖÐ */
+ nRet = zOss_SendMsg(threadId, (UINT8 *)buf, buf->msgLen + SCHE_M_TASKMSGHEAD_LEN, ZOSS_WAIT_FOREVER);
+ if (nRet == ZOSS_ERROR)
+ {
+ zOss_RetUB((UINT8 *)buf);
+ }
+ return nRet;
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_TaskSend
+* ¹¦ÄÜÃèÊö£º¸øÆäËûÈÎÎñ·¢ËÍÒì²½ÏûÏ¢,²âÊÔרÓÃ
+* ²ÎÊý˵Ã÷£º(IN)
+ msg_id:ÏûÏ¢ID
+ buf:ÏûÏ¢ÄÚÈÝ
+ msg_len:ÏûÏ¢³¤¶È
+ s_task_id:Ô´ÈÎÎñID
+ t_task_id:Ä¿±êÈÎÎñID
+ (OUT)
+* ·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËû˵Ã÷£º±¾½Ó¿Ú×èÈû£¬²»ÄÜÔÚÖжÏÖÐʹÓÃ
+**************************************************************************/
+__tcm_func UINT32 Sche_TaskSend(UINT32 msg_id, VOID *buf, UINT16 msg_len, ZOSS_TASK_ID s_task_id, ZOSS_TASK_ID t_task_id)
+{
+ UINT32 nRet = ZOSS_ERROR;
+ T_ZOss_TaskMsgHead *pMsg = NULL;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_ERROR;
+ }
+ /* ·ÖÅäÏûÏ¢¿Õ¼ä */
+ pMsg = (T_ZOss_TaskMsgHead *)zOss_GetUB(msg_len + SCHE_M_TASKMSGHEAD_LEN);
+ zOss_AssertEx(NULL != pMsg, ZOSS_ERROR);
+
+ /* дÏûϢͷ */
+ pMsg->send_state = ZOSS_MSGSENDTYPE_MSG;
+ pMsg->msgID = msg_id;
+ pMsg->msgLen = msg_len;
+ pMsg->s_task_id = s_task_id;
+ pMsg->t_task_id = t_task_id;
+
+ if (msg_len > 0 && buf != NULL)
+ {
+ zOss_Memcpy((UINT8 *)(pMsg + 1), (UINT8 *)buf, msg_len);
+ }
+
+ /* ·¢ËÍÏûÏ¢ */
+ nRet = zOss_TaskSendDataEx(pMsg);
+ return nRet;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_TaskSendData
+* ¹¦ÄÜÃèÊö£º¸øÆäËûÈÎÎñ·¢ËÍÒì²½ÏûÏ¢,²âÊÔרÓÃ
+* ²ÎÊý˵Ã÷£º(IN)
+ msg_id:ÏûÏ¢ID
+ buf:ÏûÏ¢ÄÚÈÝ
+ msg_len:ÏûÏ¢³¤¶È
+ s_task_id:Ô´ÈÎÎñID
+ t_task_id:Ä¿±êÈÎÎñID
+ (OUT)
+* ·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËû˵Ã÷£º±¾½Ó¿Ú×èÈû£¬²»ÄÜÔÚÖжÏÖÐʹÓÃ
+**************************************************************************/
+__tcm_func UINT32 Sche_TaskSendData(UINT32 msg_id, VOID *buf, UINT16 msg_len, ZOSS_TASK_ID s_task_id, ZOSS_TASK_ID t_task_id)
+{
+ UINT32 nRet = ZOSS_ERROR;
+ T_ZOss_TaskMsgHead *pMsg = NULL;
+ T_ZOss_TaskMsg *pBuf = NULL;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_ERROR;
+ }
+ /* ·ÖÅäÏûÏ¢¿Õ¼ä */
+ pMsg = (T_ZOss_TaskMsgHead *)zOss_GetUB(SCHE_M_TASKMSGEX_LEN + SCHE_M_TASKMSGHEAD_LEN);
+
+ zOss_AssertEx(NULL != pMsg, ZOSS_ERROR);
+
+ pBuf = (T_ZOss_TaskMsg *)(pMsg + 1);
+
+ /* дÏûϢͷ */
+ pMsg->send_state = ZOSS_MSGSENDTYPE_DATA;
+ pMsg->msgID = msg_id;
+ pMsg->msgLen = SCHE_M_TASKMSGEX_LEN;
+ pMsg->s_task_id = s_task_id;
+ pMsg->t_task_id = t_task_id;
+
+ pBuf->msgbuf = buf;
+ pBuf->msgLenEX = msg_len;
+
+ /* ·¢ËÍÏûÏ¢ */
+ nRet = zOss_TaskSendDataEx(pMsg);
+ return nRet;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_InterruptTaskSend
+* ¹¦ÄÜÃèÊö£ºÔÚÖжÏÖиøÈÎÎñ·¢ËÍÒì²½ÏûÏ¢
+* ²ÎÊý˵Ã÷£º(IN)
+ msg:ÏûÏ¢ID
+ msg_buf:ÏûÏ¢¶ÑÕ»,ÔÚ·¢ËÍʱ²»¿½±´,ÓÉÄ¿±êÈÎÎñÔÚ´¦ÀíÍêÏûÏ¢ºóÊÍ·Å
+ msg_len:ÏûÏ¢³¤¶È
+ task_id:Ä¿±êÈÎÎñID
+ (OUT)
+* ·µ »Ø Öµ£ºÈç¹û³É¹¦£¬·µ»ØZOSS_SUCCESS£¬·ñÔò·µ»ØZOSS_ERROR
+* ÆäËû˵Ã÷£º±¾½Ó¿ÚÔÚÖжÏÖÐʹÓÃ
+**************************************************************************/
+UINT32 Sche_InterruptTaskSend(UINT32 msg_id, T_ZOss_TaskMsgHead *pMsg, UINT16 msg_len, ZOSS_TASK_ID task_id)
+{
+ UINT32 nRet = ZOSS_ERROR;
+ T_ZOss_TCB *pTCB = NULL;
+ ZOSS_THREAD_ID threadId = NULL;
+
+ zOss_AssertEx(NULL != task_id && NULL != pMsg, ZOSS_ERROR);
+
+ /* ¶¨Î»Ä¿±êÈÎÎñ */
+ pTCB = (T_ZOss_TCB *)task_id; /* »ñÈ¡Ä¿±êÈÎÎñTCB±í */
+ if (task_id == pTCB->task_id)
+ {
+ threadId = pTCB->thread_id; /* »ñÈ¡Ä¿±êÈÎÎñËùÔÚµ÷¶ÈÏß³ÌID */
+ }
+ else
+ {
+ return ZOSS_ERROR;
+ }
+
+ /* Ìî³äÏûϢͷºÍÏûÏ¢Ìå */
+ pMsg->t_task_id = task_id;
+ pMsg->s_task_id = (ZOSS_TASK_ID)zOss_GetCurThreadID();
+ pMsg->send_state = ZOSS_MSGSENDTYPE_INTER;
+ pMsg->msgID = msg_id;
+ pMsg->msgLen = msg_len;
+
+ /* ·¢ËÍÏûÏ¢ */
+ nRet = zOss_SendMsg(threadId, (UINT8 *)pMsg, msg_len, ZOSS_NO_WAIT);
+ return nRet;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_getBufPoint
+* ¹¦ÄÜÃèÊö£º¸ù¾ÝÍ·Ö¸Õë»ñÈ¡bufÖ¸Õë
+* ²ÎÊý˵Ã÷£º(IN)
+ phead:Í·Ö¸Õë
+ (OUT)
+* ·µ »Ø Öµ£º·µ»Ø VOID ÀàÐ͵ÄÖ¸Õ룬ָÏòÏûÏ¢ÄÚÈÝ£»Ê§°Ü£¬Ôò·µ»Ø ZOSS_NULL
+* ÆäËü˵Ã÷£ºÖ÷ÒªÓÃÓÚÏûϢͨѶ
+**************************************************************************/
+VOID *Sche_getBufPoint(T_ZOss_TaskMsgHead *phead)
+{
+ T_ZOss_TaskMsg *pBuf = NULL;
+
+ zOss_AssertEx(phead != NULL, NULL);
+
+ if (phead->send_state == ZOSS_MSGSENDTYPE_MSG)
+ {
+ return ((CHAR *)phead + SCHE_M_TASKMSGHEAD_LEN);
+ }
+ else if (phead->send_state == ZOSS_MSGSENDTYPE_DATA)
+ {
+ pBuf = (T_ZOss_TaskMsg *)((CHAR *)phead + SCHE_M_TASKMSGHEAD_LEN);
+ return (pBuf->msgbuf);
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_getBufLength
+* ¹¦ÄÜÃèÊö£º¸ù¾ÝÍ·Ö¸Õë»ñÈ¡buf³¤¶È
+* ²ÎÊý˵Ã÷£º(IN)
+ phead:Í·Ö¸Õë
+ (OUT)
+* ·µ »Ø Öµ£º·µ»Ø buf³¤¶È
+* ÆäËü˵Ã÷£ºÖ÷ÒªÓÃÓÚÏûϢͨѶ
+**************************************************************************/
+UINT32 Sche_getBufLength(T_ZOss_TaskMsgHead *phead)
+{
+ T_ZOss_TaskMsg *pBuf = NULL;
+
+ zOss_AssertEx(phead != NULL, 0);
+
+ if (phead->send_state == ZOSS_MSGSENDTYPE_MSG)
+ {
+ return (phead->msgLen);
+ }
+ else if (phead->send_state == ZOSS_MSGSENDTYPE_DATA)
+ {
+ pBuf = (T_ZOss_TaskMsg *)((CHAR *)phead + SCHE_M_TASKMSGHEAD_LEN);
+ return (pBuf->msgLenEX);
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_SetState
+* ¹¦ÄÜÃèÊö£ºÉ趨ÈÎÎñ״̬
+* ²ÎÊý˵Ã÷£º(IN)
+ next_state:ÈÎÎñ״̬
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS,·ñÔò·µ»ØZOSS_ERROR
+* ÆäËû˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_SetState(UINT8 next_state)
+{
+ T_ZOss_TCB *pTCB = NULL;
+ ZOSS_TASK_ID taskId = NULL;
+ UINT32 nore = ZOSS_ERROR;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_ERROR;
+ }
+
+ taskId = zOss_GetSelfTaskID(); /* »ñÈ¡µ±Ç°ÈÎÎñID */
+ if (ZOSS_INVALID_TASK_ID == taskId)
+ {
+ return ZOSS_ERROR;
+ }
+
+ pTCB = (T_ZOss_TCB *)taskId; /* »ñÈ¡ÈÎÎñTCB±í */
+ if (pTCB->type != SCHE_OSS_TASK)
+ {
+ return ZOSS_ERROR;
+ }
+
+ /* ÐźÅÁ¿±£»¤ */
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER))
+ {
+ if (taskId != pTCB->task_id) /* ÈÎÎñ²»´æÔÚ */
+ {
+ zOss_PutMutex(gSche_TCBMutex);
+ return ZOSS_ERROR;
+ }
+
+ pTCB->state = next_state; /* ÉèÖÃ״̬ */
+ nore = zOss_PutMutex(gSche_TCBMutex);
+ if (nore == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ return ZOSS_SUCCESS;
+ }
+ return ZOSS_ERROR;
+}
+
+#if ZOSS_CAPT_MSG
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_RegTaskSendHook
+* ¹¦ÄÜÃèÊö£ºÉ趨ÈÎÎñÏûÏ¢·¢Ëͻص÷º¯Êý
+* ²ÎÊý˵Ã÷£º(IN)
+ task_id:ÈÎÎñID£¬Îª0Ϊµ±Ç°ÈÎÎñ
+ intercept_Entry:»Øµ÷º¯ÊýÖ¸Õë
+ hooktype:»Øµ÷º¯ÊýÖÖÀà
+ dire: ZOSS_SETHOOKFLAG_MONI :ÏûÏ¢¼à¿Ø
+ ZOSS_SETHOOKFLAG_TRACK : ÏßÐÔ¸ú×Ù
+ ZOSS_SETHOOKFLAG_INTER : ÏûÏ¢½Ø»ñ
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS,·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£ºÉèÖÃSDLÈÎÎñʱ£¬Èë²Îtask_id²»ÄÜΪ0
+**************************************************************************/
+UINT32 zOss_RegTaskSendHook(ZOSS_TASK_ID task_id, UINT8 hooktype, UINT8 dire, TASK_SEND_HOOK intercept_Entry)
+{
+ T_ZOss_TCB *pTCB = NULL;
+ T_ZOss_SDLTCB *pSDLTCB = NULL;
+ UINT32 nore = ZOSS_ERROR;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_ERROR;
+ }
+
+ if (hooktype < 1 || hooktype > 3)
+ {
+ return ZOSS_ERROR;
+ }
+
+ if (intercept_Entry != NULL && (dire < 1 || dire > 3))
+ {
+ return ZOSS_ERROR;
+ }
+
+ if (intercept_Entry == NULL)
+ {
+ dire = 0;
+ }
+
+ if (NULL == task_id) /* Èç¹ûÈÎÎñIDΪ¿ÕÔòÉ趨µ±Ç°ÈÎÎñ */
+ {
+ task_id = zOss_GetSelfTaskID();
+ if (ZOSS_INVALID_TASK_ID == task_id)
+ {
+ return ZOSS_ERROR;
+ }
+ }
+ pTCB = (T_ZOss_TCB *)task_id; /* »ñÈ¡ÈÎÎñTCB±í */
+
+ if (pTCB->type == SCHE_OSS_TASK) /* ÉèÖ÷ÇSDLÈÎÎñ */
+ {
+ /* ÐźÅÁ¿±£»¤ */
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER))
+ {
+ if (task_id != pTCB->task_id) /* ÈÎÎñ²»´æÔÚ */
+ {
+ zOss_PutMutex(gSche_TCBMutex);
+
+ return ZOSS_ERROR;
+ }
+ pTCB->HookEntry[hooktype - 1] = intercept_Entry;
+ pTCB->dire[hooktype - 1] = dire;
+ nore = zOss_PutMutex(gSche_TCBMutex);
+ if (nore == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ return ZOSS_SUCCESS;
+ }
+ }
+ else if (pTCB->type == SCHE_SDL_TASK) /* ÉèÖÃSDLÈÎÎñ */
+ {
+ pSDLTCB = (T_ZOss_SDLTCB *)task_id;
+ pSDLTCB->HookEntry[hooktype - 1] = intercept_Entry;
+ pSDLTCB->dire[hooktype - 1] = dire;
+ return ZOSS_SUCCESS;
+ }
+ return ZOSS_ERROR;
+}
+#endif
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_GetSelfTaskID
+* ¹¦ÄÜÃèÊö£º»ñÈ¡µ±Ç°ÈÎÎñID
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£º·µ»ØÈÎÎñID
+* ÆäËû˵Ã÷£º²»Ö§³ÖSDLÈÎÎñ
+**************************************************************************/
+__tcm_func ZOSS_TASK_ID zOss_GetSelfTaskID(VOID)
+{
+ ZOSS_THREAD_ID threadId = NULL;
+ T_ZOss_TCB *pTCB = NULL;
+ T_ZOss_TRF *pTRF = NULL;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ threadId = zOss_GetCurThreadID(); /* »ñÈ¡µ±Ç°Ïß³ÌID */
+ if (threadId == NULL)
+ {
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ pTRF = (T_ZOss_TRF *)Sche_GetTaskID(threadId);
+ if (pTRF == NULL)
+ {
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ if (pTRF->thread_id == threadId)
+ {
+ pTCB = (T_ZOss_TCB *)zOss_ListFirst(&(pTRF->TCBReady));
+
+ if (NULL != pTCB)
+ {
+ return (ZOSS_TASK_ID)pTCB; /* ·ÀÖ¹ÈÎÎñËûɱʱ»ñ²»µ½ÈÎÎñid */
+ }
+ }
+ return ZOSS_INVALID_TASK_ID;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_GetTaskID
+* ¹¦ÄÜÃèÊö£ºÍ¨¹ýÈÎÎñÃû»ñÈ¡ÈÎÎñID
+* ²ÎÊý˵Ã÷£º(IN)
+ task_name:ÈÎÎñÃû
+ (OUT)
+* ·µ »Ø Öµ£º·µ»ØÈÎÎñID
+* ÆäËû˵Ã÷£º¿ÉÒÔ»ñÈ¡SDLÈÎÎñID
+**************************************************************************/
+__tcm_func ZOSS_TASK_ID zOss_GetTaskID(const CHAR *task_name)
+{
+ T_ZOss_TCB *pCurTCB = NULL;
+ UINT32 nore = ZOSS_ERROR;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ zOss_AssertEx(NULL != task_name, ZOSS_INVALID_TASK_ID);
+
+ /* ÐźÅÁ¿±£»¤ */
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER))
+ {
+ pCurTCB = gSche_TCBHeadPtr;
+ while (NULL != pCurTCB)
+ {
+ if (0 == strcmp((char*)task_name, (char *)pCurTCB->task_name) && pCurTCB == (T_ZOss_TCB *)pCurTCB->task_id)
+ {
+ zOss_PutMutex(gSche_TCBMutex);
+ return (ZOSS_TASK_ID)pCurTCB;
+ }
+ pCurTCB = pCurTCB->next;
+ }
+ nore = zOss_PutMutex(gSche_TCBMutex);
+ if (nore == ZOSS_ERROR)
+ {
+ return ZOSS_INVALID_TASK_ID;
+ }
+ }
+
+ if (gSche_Task_Hook.get_id != NULL)
+ {
+ return gSche_Task_Hook.get_id(task_name);
+ }
+
+ return ZOSS_INVALID_TASK_ID;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_GetTaskName
+* ¹¦ÄÜÃèÊö£ºÍ¨¹ýÈÎÎñID»ñÈ¡ÈÎÎñÃû
+* ²ÎÊý˵Ã÷£º(IN)
+ task_id:ÈÎÎñID
+ (OUT)
+* ·µ »Ø Öµ£º·µ»ØÈÎÎñÃû
+* ÆäËû˵Ã÷£º
+**************************************************************************/
+__tcm_func CHAR *zOss_GetTaskName(ZOSS_TASK_ID task_id)
+{
+ T_ZOss_TCB *pCurTCB = NULL;
+ CHAR *task_name = NULL;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return NULL;
+ }
+
+ zOss_AssertEx(NULL != task_id, NULL);
+
+ if (gSche_Task_Hook.get_name != NULL)
+ {
+ task_name = gSche_Task_Hook.get_name(task_id);
+ if (task_name != NULL)
+ {
+ return task_name;
+ }
+ }
+
+ pCurTCB = (T_ZOss_TCB *)task_id;
+
+ if (pCurTCB == (T_ZOss_TCB *)pCurTCB->task_id)
+ {
+ return pCurTCB->task_name;
+ }
+
+ return NULL;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_Sender
+* ¹¦ÄÜÃèÊö£º»ñÈ¡ÏûÏ¢Ô´ÈÎÎñID
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£ºÏûÏ¢Ô´ÈÎÎñID
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+__tcm_func ZOSS_TASK_ID zOss_Sender(VOID)
+{
+ T_ZOss_TCB *pTCB = NULL;
+
+ pTCB = (T_ZOss_TCB *)zOss_GetSelfTaskID(); /* »ñÈ¡µ±Ç°ÈÎÎñTCB±í */
+ if (pTCB == NULL)
+ {
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ if (pTCB->type != SCHE_OSS_TASK)
+ {
+ return ZOSS_INVALID_TASK_ID;
+ }
+
+ return pTCB->sender_task_id;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_DeadLoop
+* ¹¦ÄÜÃèÊö£ºËÀÑ»·¼ì²â
+* ²ÎÊý˵Ã÷£º(IN)
+ task_id_arr:´æ·ÅËÀÑ»·ÈÎÎñIDµÄ¿Õ¼ä
+ (OUT)
+* ·µ »Ø Öµ£ºËÀÑ»·ÈÎÎñÊýºÍID
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 Sche_DeadLoop(ZOSS_TASK_ID *task_id_arr)
+{
+ T_ZOss_TCB *pCurTCB = NULL;
+ UINT32 Curtask_time = 0;
+ UINT32 i = 0;
+ UINT32 deadloop_task_num = 0;
+ UINT32 nore = ZOSS_ERROR;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_ERROR;
+ }
+
+ zOss_AssertEx(NULL != task_id_arr, ZOSS_ERROR);
+
+ /* ÐźÅÁ¿±£»¤ */
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER))
+ {
+ Curtask_time = Osa_HwTimeRead();
+ pCurTCB = gSche_TCBHeadPtr;
+ while (NULL != pCurTCB)
+ {
+ if (pCurTCB->run_status == ZOSS_STATE_STOPPED || pCurTCB->task_time == 0)
+ {
+ pCurTCB = pCurTCB->next;
+ continue;
+ }
+
+ /* »ñÈ¡ÈÎÎñÖ´ÐÐʱ¼ä */
+ i = Curtask_time - pCurTCB->task_time;
+
+ /* ÅжÏÊÇ·ñ³¬Ê± */
+ if (i >= gSche_DeadLoop_Time * 1000 * 1000)
+ {
+ *task_id_arr = pCurTCB->task_id;
+ task_id_arr++;
+ deadloop_task_num++;
+ }
+ pCurTCB = pCurTCB->next;
+ }
+ nore = zOss_PutMutex(gSche_TCBMutex);
+ if (nore == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ }
+
+ return deadloop_task_num;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºzOss_TaskInit
+* ¹¦ÄÜÃèÊö£º´´½¨¾²Ì¬ÈÎÎñ
+* ²ÎÊý˵Ã÷£º(IN)
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS,·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_TaskInit(VOID)
+{
+ ZOSS_TASK_ID task_id = NULL;
+ UINT32 task_index = 0;
+ UINT32 i = 0;
+ T_OSS_PARAM *pPlatCfg = NULL;
+ T_ZOss_TaskTabItem *TaskTab = NULL;
+ UINT32 uiSche_Max_TaskTab_Num = 0;
+
+ pPlatCfg = zOss_GetOssCfg();
+ TaskTab = pPlatCfg->SysmCfg.pSysm_TaskItemTab;
+ uiSche_Max_TaskTab_Num = pPlatCfg->SysmCfg.task_num;
+ gSche_SaticTaskInitSema = zOss_CreateSemaphore("static_task", 0);
+#ifdef _USE_HAL_HRDTST
+ if (zDrvComm_GetPowerOnState() == POWER_ON_HDT_TEST)
+ {
+ for ( ; task_index < uiSche_Max_TaskTab_Num; task_index++)
+ {
+ if ((1 == TaskTab->is_use) && (TRUE == TaskTab->hardTestFlag))
+ {
+ task_id = zOss_CreateTask_EX(TaskTab->task_name, TaskTab->task_entry,
+ TaskTab->stack_size, TaskTab->priority,
+ TaskTab->private_data_len, TaskTab->process_no, 1);
+
+ if (task_id == ZOSS_INVALID_TASK_ID)
+ {
+ return ZOSS_ERROR;
+ }
+ else
+ {
+ gSysm_TaskIDTab[task_index] = task_id; /* µÇ¼ÇÈÎÎñID */
+ gTask_TaskNum++;
+ }
+ }
+ TaskTab++;
+ }
+ }
+ else
+ {
+#endif
+#ifdef _USE_SDL
+ tasksdl_table = (tasksdl_desc *)zOss_Malloc((nof_signalcode * sizeof(tasksdl_desc)));
+ if (tasksdl_table == NULL)
+ {
+ return ZOSS_ERROR;
+ }
+ memset(tasksdl_table, 0, (nof_signalcode * sizeof(tasksdl_desc)));
+#endif
+ for ( ; task_index < uiSche_Max_TaskTab_Num; task_index++)
+ {
+#ifdef _USE_HAL_HRDTST
+ if ((1 == TaskTab->is_use) && ( FALSE == TaskTab->hardTestFlag))
+#else
+ if (1 == TaskTab->is_use)
+#endif
+ {
+ task_id = zOss_CreateTask_EX(TaskTab->task_name, TaskTab->task_entry,
+ TaskTab->stack_size, TaskTab->priority,
+ TaskTab->private_data_len, TaskTab->process_no, 1);
+
+ if (task_id == ZOSS_INVALID_TASK_ID)
+ {
+ return ZOSS_ERROR;
+ }
+ else
+ {
+ gSysm_TaskIDTab[task_index] = task_id; /* µÇ¼ÇÈÎÎñID */
+ gTask_TaskNum++;
+ }
+ }
+#ifdef _USE_SDL
+ for (i = 0; i < nof_signalcode; i++)
+ {
+ if (strcmp((const char *)TaskTab->task_name, (const char *)signalcode_table[i].task_name) == 0)
+ {
+ tasksdl_table[i].selfid = signalcode_table[i].selfid;
+ tasksdl_table[i].task_id = task_id;
+ break;
+ }
+ }
+#endif
+ TaskTab++;
+ }
+#ifdef _USE_HAL_HRDTST
+ }
+#endif
+
+ return ZOSS_SUCCESS;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: zOss_SetTaskTimer
+* ¹¦ÄÜÃèÊö: ÉèÖÃÖÜÆÚÐÔ/·ÇÖÜÆÚÐÔÈÎÎñ¶¨Ê±Æ÷ÏòÄ¿±êÈÎÎñ·¢ËÍÏûÏ¢;
+ ÉèÖÃʱ¿ÌΪ²Î¿¼µã,¾¹ýÖ¸¶¨Ê±¼äºó, ÏòÉèÖö¨Ê±Æ÷µÄÈÎÎñ·¢ËÍÖ¸¶¨ÏûÏ¢²¢×Ô¶¯ÊͷŶ¨Ê±Æ÷ËùÕ¼×ÊÔ´(·ÇÖÜÆÚÐÔ).
+* ²ÎÊý˵Ã÷: (IN)
+ time_len:ʱ³¤, µ¥Î»ms
+ msg_id:¶¨Ê±µ½ºó,·¢Ë͸øÉèÖö¨Ê±Æ÷ÈÎÎñµÄÏûÏ¢ºÅ
+ arg:¸½¼Ó²ÎÊý,¶¨´«µÝ¸øÈÎÎñÈë¿Úº¯ÊýµÄbufÐβδËʱmsg_lenֵΪ4(sizeof(UINT32/arg))
+ desk_task:Ö¸¶¨Ä¿±êÈÎÎñ£¬Èç¹ûÄ¿±êÈÎÎñΪ¿Õʱ£¬½«·¢ËÍÉèÖö¨Ê±Æ÷µÄÈÎÎñ
+ bPeriod:ÊÇ·ñÖÜÆÚÐÔ
+ (OUT)
+* ·µ »Ø Öµ: ³É¹¦:ÏàÓ¦µÄ¶¨Ê±Æ÷ID; ʧ°Ü:ZOSS_INVALID_TIMER_ID
+* ÆäËü˵Ã÷:
+**************************************************************************/
+ZOSS_TIMER_ID zOss_SetTaskTimer(UINT32 time_len, UINT32 msg_id, UINT32 arg, ZOSS_TASK_ID desk_task_id, BOOL bPeriod)
+{
+ T_TIMER_NODE *pTimerNode = NULL;
+ T_Task_Arg *ptTaskArg = NULL;
+ UINT32 status = 0;
+
+ if (gSche_IsTaskInit == FALSE) /* ¼ì²éÊÇ·ñÒѳõʼ»¯ */
+ {
+ return ZOSS_INVALID_TIMER_ID;
+ }
+
+ if(desk_task_id == NULL)
+ {
+ desk_task_id = zOss_GetSelfTaskID();
+ zOss_AssertEx(NULL != desk_task_id, ZOSS_INVALID_TIMER_ID);
+ }
+
+ ptTaskArg = (T_Task_Arg *)zOss_Malloc(sizeof(T_Task_Arg));
+ if (NULL == ptTaskArg)
+ {
+ return ZOSS_INVALID_TIMER_ID;
+ }
+
+ ptTaskArg->task_id = desk_task_id;
+ ptTaskArg->msg_id = msg_id;
+ ptTaskArg->arg = arg;
+
+ pTimerNode = (T_TIMER_NODE *)zOss_CreateTimer("TaskTimer", (ZOSS_TIMER_FUN)TaskTimer_CallBack, (SINT32)ptTaskArg, bPeriod);
+
+ if (ZOSS_INVALID_TIMER_ID == pTimerNode)
+ {
+ zOss_Free(ptTaskArg);
+ }
+ else
+ {
+ ptTaskArg->pTimerNode = pTimerNode;
+ pTimerNode->attached = (VOID *)ptTaskArg;
+ status = zOss_StartTimer(pTimerNode, time_len, NULL, 0);
+
+ if (status == ZOSS_ERROR)
+ {
+ zOss_KillTimer(pTimerNode);
+ zOss_Free(ptTaskArg);
+ pTimerNode = ZOSS_INVALID_TIMER_ID;
+ }
+ }
+ return (ZOSS_TIMER_ID)pTimerNode;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: zOss_SetRelativeTimer
+* ¹¦ÄÜÃèÊö: ÉèÖ÷ÇÖÜÆÚÐÔÈÎÎñ¶¨Ê±Æ÷;
+ ÉèÖÃʱ¿ÌΪ²Î¿¼µã,¾¹ýÖ¸¶¨Ê±¼äºó, ÏòÉèÖö¨Ê±Æ÷µÄÈÎÎñ·¢ËÍÖ¸¶¨ÏûÏ¢²¢×Ô¶¯ÊͷŶ¨Ê±Æ÷ËùÕ¼×ÊÔ´.
+* ²ÎÊý˵Ã÷: (IN)
+ time_len:ʱ³¤, µ¥Î»ms
+ msg_id:¶¨Ê±µ½ºó,·¢Ë͸øÉèÖö¨Ê±Æ÷ÈÎÎñµÄÏûÏ¢ºÅ
+ arg:¸½¼Ó²ÎÊý,¶¨´«µÝ¸øÈÎÎñÈë¿Úº¯ÊýµÄbufÐβδËʱmsg_lenֵΪ4(sizeof(UINT32/arg))
+ (OUT)
+* ·µ »Ø Öµ: ³É¹¦:ÏàÓ¦µÄ¶¨Ê±Æ÷ID; ʧ°Ü:ZOSS_INVALID_TIMER_ID
+* ÆäËü˵Ã÷: ±ØÐèÔÚÈÎÎñÄÚµ÷ÓÃ
+**************************************************************************/
+ZOSS_TIMER_ID zOss_SetRelativeTimer(UINT32 time_len, UINT32 msg_id, UINT32 arg)
+{
+ return zOss_SetTaskTimer(time_len, msg_id, arg, NULL, FALSE);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: zOss_SetRelativeTimerByTaskId
+* ¹¦ÄÜÃèÊö: ÉèÖ÷ÇÖÜÆÚÐÔÈÎÎñ¶¨Ê±Æ÷ÏòÄ¿±êÈÎÎñ·¢ËÍÏûÏ¢;
+ ÉèÖÃʱ¿ÌΪ²Î¿¼µã,¾¹ýÖ¸¶¨Ê±¼äºó, ÏòÉèÖö¨Ê±Æ÷µÄÈÎÎñ·¢ËÍÖ¸¶¨ÏûÏ¢²¢×Ô¶¯ÊͷŶ¨Ê±Æ÷ËùÕ¼×ÊÔ´.
+* ²ÎÊý˵Ã÷: (IN)
+ time_len:ʱ³¤, µ¥Î»ms
+ msg_id:¶¨Ê±µ½ºó,·¢Ë͸øÉèÖö¨Ê±Æ÷ÈÎÎñµÄÏûÏ¢ºÅ
+ arg:¸½¼Ó²ÎÊý,¶¨´«µÝ¸øÈÎÎñÈë¿Úº¯ÊýµÄbufÐβδËʱmsg_lenֵΪ4(sizeof(UINT32/arg))
+ desk_task:Ö¸¶¨Ä¿±êÈÎÎñ£¬Èç¹ûÄ¿±êÈÎÎñΪ¿Õʱ£¬½«·¢ËÍÉèÖö¨Ê±Æ÷µÄÈÎÎñ
+ (OUT)
+* ·µ »Ø Öµ: ³É¹¦:ÏàÓ¦µÄ¶¨Ê±Æ÷ID; ʧ°Ü:ZOSS_INVALID_TIMER_ID
+* ÆäËü˵Ã÷:
+**************************************************************************/
+ZOSS_TIMER_ID zOss_SetRelativeTimerByTaskId(UINT32 time_len, UINT32 msg_id, UINT32 arg, ZOSS_TASK_ID desk_task_id)
+{
+ return zOss_SetTaskTimer(time_len, msg_id, arg, desk_task_id, FALSE);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: zOss_SetLoopTimer
+* ¹¦ÄÜÃèÊö: ÉèÖÃÖÜÆÚÐÔÈÎÎñ¶¨Ê±Æ÷;
+ ÒÔÉèÖÃʱ¿ÌΪ²Î¿¼µã,¾¹ýÖ¸¶¨Ê±¼äºó, ÏòÉèÖö¨Ê±Æ÷µÄÈÎÎñ·¢ËÍÖ¸¶¨ÏûÏ¢
+* ²ÎÊý˵Ã÷: (IN)
+ time_len:ʱ³¤, µ¥Î»ms
+ msg_id:¶¨Ê±µ½ºó,·¢Ë͸øÉèÖö¨Ê±Æ÷ÈÎÎñµÄÏûÏ¢ºÅ
+ arg:¸½¼Ó²ÎÊý,¶¨´«µÝ¸øÈÎÎñÈë¿Úº¯ÊýµÄbufÐβδËʱmsg_lenֵΪ4(sizeof(UINT32/arg))
+ (OUT)
+* ·µ »Ø Öµ: ³É¹¦:ÏàÓ¦µÄ¶¨Ê±Æ÷±êʶ; ʧ°Ü:ZOSS_INVALID_TIMER_ID
+* ÆäËü˵Ã÷: ±ØÐèÔÚÈÎÎñÄÚµ÷ÓÃ.
+**************************************************************************/
+ZOSS_TIMER_ID zOss_SetLoopTimer(UINT32 time_len, UINT32 msg_id, UINT32 arg)
+{
+ return zOss_SetTaskTimer(time_len, msg_id, arg, NULL, TRUE);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: zOss_SetLoopTimerByTaskId
+* ¹¦ÄÜÃèÊö: ÉèÖÃÖÜÆÚÐÔÈÎÎñ¶¨Ê±Æ÷ÏòÄ¿±êÈÎÎñ·¢ËÍÏûÏ¢;
+ ÉèÖÃʱ¿ÌΪ²Î¿¼µã,¾¹ýÖ¸¶¨Ê±¼äºó, ÏòÉèÖö¨Ê±Æ÷µÄÈÎÎñ·¢ËÍÖ¸¶¨ÏûÏ¢
+* ²ÎÊý˵Ã÷: (IN)
+ time_len:ʱ³¤, µ¥Î»ms
+ msg_id:¶¨Ê±µ½ºó,·¢Ë͸øÉèÖö¨Ê±Æ÷ÈÎÎñµÄÏûÏ¢ºÅ
+ arg:¸½¼Ó²ÎÊý,¶¨´«µÝ¸øÈÎÎñÈë¿Úº¯ÊýµÄbufÐβδËʱmsg_lenֵΪ4(sizeof(UINT32/arg))
+ desk_task:Ö¸¶¨Ä¿±êÈÎÎñ£¬Èç¹ûÄ¿±êÈÎÎñΪ¿Õʱ£¬½«·¢ËÍÉèÖö¨Ê±Æ÷µÄÈÎÎñ
+ (OUT)
+* ·µ »Ø Öµ: ³É¹¦:ÏàÓ¦µÄ¶¨Ê±Æ÷ID; ʧ°Ü:ZOSS_INVALID_TIMER_ID
+* ÆäËü˵Ã÷:
+**************************************************************************/
+ZOSS_TIMER_ID zOss_SetLoopTimerByTaskId(UINT32 time_len, UINT32 msg_id, UINT32 arg, ZOSS_TASK_ID desk_task_id)
+{
+ return zOss_SetTaskTimer(time_len, msg_id, arg, desk_task_id, TRUE);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_SetTaskID
+* ¹¦ÄÜÃèÊö£ºÉèÖõ÷¶ÈÏß³ÌÈÎÎñÐÅÏ¢
+* ²ÎÊý˵Ã÷£º(IN)
+ threadId: µ÷¶ÈÏß³Ìid
+ taskId:ÈÎÎñÐÅÏ¢Ö¸Õë
+ (OUT)
+* ·µ »Ø Öµ£ºZOSS_ERRORÉèÖÃʧ°Ü£¬ZOSS_SUCCESSÉèÖóɹ¦
+* ÆäËü˵Ã÷£º¿ÉÑ¡
+**************************************************************************/
+UINT32 Sche_SetTaskID(ZOSS_THREAD_ID threadId, VOID *taskId)
+{
+ T_ZOsa_ThreadUserArea *ptArea = NULL;
+
+ zOss_AssertEx(threadId != NULL && taskId != NULL, ZOSS_ERROR);
+ ptArea = Osa_GetThreadUserArea(threadId, TRUE);
+ if (NULL == ptArea)
+ {
+ return ZOSS_ERROR;
+ }
+ else
+ {
+ ptArea->ptrf = taskId;
+ return ZOSS_SUCCESS;
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_GetTaskID
+* ¹¦ÄÜÃèÊö£º»ñµÃµ÷¶ÈÏß³ÌÈÎÎñÐÅÏ¢
+* ²ÎÊý˵Ã÷: (IN)
+ threadId: µ÷¶ÈÏß³Ìid
+ (OUT)
+* ·µ »Ø Öµ£ºNULL »ñµÃʧ°Ü
+* ÆäËü˵Ã÷£º¿ÉÑ¡
+**************************************************************************/
+__tcm_func VOID *Sche_GetTaskID(ZOSS_THREAD_ID threadId)
+{
+ T_ZOsa_ThreadUserArea *ptArea = NULL;
+
+ zOss_AssertEx(threadId != NULL, NULL);
+ ptArea = Osa_GetThreadUserArea(threadId, FALSE);
+
+ if (NULL == ptArea)
+ {
+ return NULL;
+ }
+ else
+ {
+ return ptArea->ptrf;
+ }
+}
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_DefTaskEntry
+* ¹¦ÄÜÃèÊö£ºÈ±Ê¡ÈÎÎñÈë¿Ú
+* ²ÎÊý˵Ã÷£º(IN)
+ arg:²ÎÊýÖ¸Õë
+ (OUT)
+* ·µ »Ø Öµ£º
+* ÆäËü˵Ã÷£º¿ÉÑ¡
+**************************************************************************/
+__tcm_func static VOID Sche_DefTaskEntry(SINT32 arg)
+{
+ T_ZOss_TCB *pTCB = NULL;
+ T_ZOss_TRF *pTRF = NULL;
+ T_ZOss_TaskMsgHead *msgPtr = NULL;
+ T_ZOss_TaskMsg *bufPtr = NULL;
+ T_ZOsa_ThreadUserArea *pUa = NULL;
+ ZOSS_THREAD_ID threadId = NULL;
+ VOID *buf = NULL;
+ UINT32 msgLen = 0;
+ UINT32 nRet = ZOSS_ERROR;
+ UINT32 nore = ZOSS_ERROR;
+#ifndef _OS_WIN
+ UINT32 tempTaskTime = 0;
+ UINT32 taskTimeLen = 0;
+#endif
+
+ pTRF = (T_ZOss_TRF *)arg;
+ zOss_AssertExN(NULL != pTRF);
+
+ pUa = Osa_GetThreadUserArea(zOss_GetCurThreadID(), FALSE);
+ zOss_AssertExN(NULL != pUa);
+
+ /* ÏûÏ¢·Ö·¢ */
+ while (1)
+ {
+ /* »ñÈ¡ÏûÏ¢ */
+ nRet = zOss_RecvMsg((VOID **)&msgPtr, &msgLen, ZOSS_WAIT_FOREVER);
+ zOss_AssertExN(nRet != ZOSS_ERROR);
+
+ do
+ {
+ if (msgPtr->send_state > 4)
+ {
+ zOss_ASSERT(0);
+ break;
+ }
+
+ pTCB = (T_ZOss_TCB *)msgPtr->t_task_id; /* »ñÈ¡Ä¿±êÈÎÎñTCB±í */
+
+ switch (msgPtr->msgID)
+ {
+ case EV_TASK_END: /* ÈÎÎñɾ³ýÏûÏ¢ */
+ {
+ if (NULL == Sche_GetTCB(msgPtr->t_task_id))
+ {
+ break;
+ }
+ pTCB->task_id = NULL;
+ switch (pTCB->run_status)
+ {
+ case ZOSS_STATE_STOPPED:
+ {
+ zOss_ListDelete(&(pTRF->TCBStopped), &(pTCB->node));
+ break;
+ }
+ case ZOSS_STATE_IDLE:
+ {
+ zOss_ListDelete(&(pTRF->TCBIdle), &(pTCB->node));
+ break;
+ }
+ case ZOSS_STATE_READY:
+ {
+ zOss_ListDelete(&(pTRF->TCBReady), &(pTCB->node));
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ Sche_RemoveTCB(pTCB);
+ if (pTCB->taskData != NULL)
+ {
+ zOss_Free(pTCB->taskData);
+ }
+
+ while (zOss_ListCount(&pTCB->msg_queue) > 0)
+ {
+ buf = (VOID *)zOss_ListFirst(&pTCB->msg_queue);
+ zOss_AssertExN(buf != NULL);
+ zOss_ListDelete(&pTCB->msg_queue, (T_ZOss_Node *)buf);
+ zOss_RetUB(buf);
+ }
+ zOss_Free(pTCB);
+ nore = zOss_RetUB(msgPtr);
+ if (nore == ZOSS_ERROR)
+ {
+ return;
+ }
+ if (pTRF->pno == 0)
+ {
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TRFMutex, ZOSS_WAIT_FOREVER))
+ {
+ zOss_ListDelete(&gSche_TRF_List, &(pTRF->node));
+ zOss_PutMutex(gSche_TRFMutex);
+ }
+ zOss_Free(pTRF);
+ zOss_ExitThread();
+ }
+ break;
+ }
+
+ case EV_TASK_CRE: /* ÈÎÎñ´´½¨ÏûÏ¢ */
+ {
+ if (pTCB->task_id == msgPtr->t_task_id)
+ {
+ zOss_ListAdd(&(pTRF->TCBIdle), &(pTCB->node));
+ pTCB->run_status = ZOSS_STATE_IDLE;
+ }
+ zOss_RetUB(msgPtr);
+ break;
+ }
+
+ default: /* ÆÕͨÏûÏ¢ */
+ {
+ if (pTCB->task_id == msgPtr->t_task_id)
+ {
+ zOss_ListAdd(&pTCB->msg_queue, &(msgPtr->node));
+ if (pTCB->run_status == ZOSS_STATE_IDLE)
+ {
+ zOss_ListDelete(&(pTRF->TCBIdle), &(pTCB->node));
+ zOss_ListAdd(&(pTRF->TCBReady), &(pTCB->node));
+ pTCB->run_status = ZOSS_STATE_READY;
+ }
+ }
+ else
+ {
+ zOss_RetUB((UINT8 *)msgPtr);
+ }
+ break;
+ }
+ }
+ }while (ZOSS_SUCCESS == zOss_RecvMsg((VOID **)&msgPtr, &msgLen, ZOSS_NO_WAIT));
+
+ /* ÏûÏ¢´¦Àí */
+ while (0 != zOss_ListCount(&(pTRF->TCBReady)))
+ {
+ pTCB = (T_ZOss_TCB *)zOss_ListFirst(&(pTRF->TCBReady)); /* È¡¾ÍÐ÷ÈÎÎñÁ´±íµÄµÚÒ»¸öÈÎÎñ */
+ if (pTCB->task_id == NULL) /* Òѱ»É¾³ý */
+ {
+ pTCB->run_status = ZOSS_STATE_STOPPED;
+ zOss_ListDelete(&(pTRF->TCBReady), &(pTCB->node));
+ zOss_ListAdd(&(pTRF->TCBStopped), &(pTCB->node));
+ }
+ else
+ {
+ msgPtr = (T_ZOss_TaskMsgHead *)zOss_ListFirst(&pTCB->msg_queue); /* È¡ÏûÏ¢¶ÓÁеĵÚÒ»¸öÏûÏ¢ */
+ zOss_AssertExN(msgPtr != NULL);
+ zOss_ListDelete(&pTCB->msg_queue, (T_ZOss_Node *)msgPtr);
+
+ /* ¶¨Ê±Æ÷ÏûÏ¢ */
+ if (msgPtr->send_state == ZOSS_MSGSENDTYPE_TIMER)
+ {
+ /* ¶¨Ê±Æ÷ÒѾɾ³ý»òÕßÔÝÍ£ */
+ if (Timer_IgnoreTaskMsg((ZOSS_TIMER_ID)(msgPtr->s_task_id)))
+ {
+ zOss_RetUB((UINT8 *)msgPtr);
+ zOss_ListDelete(&(pTRF->TCBReady), &(pTCB->node));
+ if (zOss_ListCount(&pTCB->msg_queue) == 0) /* ÏûÏ¢¶ÓÁÐΪ¿Õ */
+ {
+ pTCB->run_status = ZOSS_STATE_IDLE;
+ zOss_ListAdd(&(pTRF->TCBIdle), &(pTCB->node));
+ }
+ else /* ÏûÏ¢¶ÓÁв»Îª¿Õ */
+ {
+ pTCB->run_status = ZOSS_STATE_READY;
+ zOss_ListAdd(&(pTRF->TCBReady), &(pTCB->node));
+ }
+ continue;
+ }
+ msgPtr->s_task_id = NULL;
+ }
+ /* ¼Ç¼ÏûÏ¢ÐÅÏ¢ */
+ pTCB->msg_id = msgPtr->msgID;
+ pTCB->sender_task_id = msgPtr->s_task_id;
+ /* ¸ü¸ÄÈÎÎñ״̬ */
+ pTCB->run_status = ZOSS_STATE_RUN;
+ /* É趨ÈÎÎñ¿ªÊ¼Ê±¼ä */
+ if (gOsa_SwapTimeFlag && gExcep_DaemonTask != NULL)
+ {
+ pTCB->task_time = Osa_HwTimeRead(); //zOss_GetTickCount();
+ }
+ pUa->curtaskid = pTCB->task_id;
+#if ZOSS_SELF_MIMO
+
+ /* ˽ÓÐÊý¾ÝÇø±ß½ç¼ì²é */
+ if (NULL != pTCB->taskData && *(UINT32 *)((UINT32)pTCB->taskData + pTCB->private_data_len) != gSche_pDataRegion_Test)
+ {
+ SCHE_printf("%s private data overflow", pTCB->task_name);
+ zOss_ASSERT(0);
+ return;
+ }
+ threadId = zOss_GetCurThreadID();
+ zOss_AssertExN(pTCB->thread_id == threadId);
+#endif
+ /* µ÷ÓÃÓû§ÏûÏ¢´¦Àíº¯Êý´¦Àí */
+ switch (msgPtr->send_state)
+ {
+ case ZOSS_MSGSENDTYPE_TIMER:
+ case ZOSS_MSGSENDTYPE_MSG:
+ {
+ pTCB->count++;
+ if (0 == msgPtr->msgLen)
+ {
+ pTCB->taskEntry(pTCB->state, msgPtr->msgID, NULL, msgPtr->msgLen, pTCB->taskData);
+ }
+ else
+ {
+ pTCB->taskEntry(pTCB->state, msgPtr->msgID, (UINT8 *)(msgPtr + 1), msgPtr->msgLen, pTCB->taskData);
+ }
+ if (pTCB->reserved[0] == 1 && msgPtr->msgID == EV_INIT && pTCB->state == ZOSS_STATUS_INIT )
+ {
+ zOss_PutSemaphore(gSche_SaticTaskInitSema);
+ pTCB->reserved[0] = 0;
+ }
+ /* ÊÍ·ÅÏûÏ¢ */
+ zOss_RetUB((UINT8 *)msgPtr);
+ break;
+ }
+
+ case ZOSS_MSGSENDTYPE_DATA:
+ {
+ bufPtr = (T_ZOss_TaskMsg *)(msgPtr + 1);
+ pTCB->count++;
+ pTCB->taskEntry(pTCB->state, msgPtr->msgID, (UINT8 *)bufPtr->msgbuf, bufPtr->msgLenEX, pTCB->taskData);
+ zOss_RetUB((UINT8 *)msgPtr);
+ break;
+ }
+
+ case ZOSS_MSGSENDTYPE_INTER:
+ {
+ pTCB->count++;
+ pTCB->taskEntry(pTCB->state, msgPtr->msgID, (UINT8 *)msgPtr, msgPtr->msgLen, pTCB->taskData);
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+
+#if ZOSS_SELF_MIMO
+ /* ˽ÓÐÊý¾ÝÇø±ß½ç¼ì²é */
+ if (NULL != pTCB->taskData && *(UINT32 *)((UINT32)pTCB->taskData + pTCB->private_data_len) != gSche_pDataRegion_Test)
+ {
+ SCHE_printf("%s private data overflow", pTCB->task_name);
+ zOss_ASSERT(0);
+ return;
+ }
+#endif
+#ifndef _OS_WIN
+ if (gOsa_SwapTimeFlag)
+ {
+ tempTaskTime = Osa_HwTimeRead();
+ if (tempTaskTime >= pTCB->task_time)
+ {
+ taskTimeLen = tempTaskTime - pTCB->task_time;
+ }
+ else
+ {
+ taskTimeLen = tempTaskTime + ~pTCB->task_time; /* ʱ¼äÒç³ö´¦Àí */
+ }
+ pTCB->cputime += taskTimeLen;
+ pTCB->runtime += taskTimeLen;
+ }
+#endif
+ pUa->curtaskid = 0;
+ /* ÖØÖÃÈÎÎñÖ´ÐÐʱ¼ä */
+ pTCB->task_time = 0;
+ zOss_ListDelete(&(pTRF->TCBReady), &(pTCB->node));
+ if (zOss_ListCount(&pTCB->msg_queue) == 0) /* ÏûÏ¢¶ÓÁÐΪ¿Õ */
+ {
+ pTCB->run_status = ZOSS_STATE_IDLE;
+ zOss_ListAdd(&(pTRF->TCBIdle), &(pTCB->node));
+ }
+ else /* ÏûÏ¢¶ÓÁв»Îª¿Õ */
+ {
+ pTCB->run_status = ZOSS_STATE_READY;
+ zOss_ListAdd(&(pTRF->TCBReady), &(pTCB->node));
+ }
+ }
+ }
+ }
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_GetTCB
+* ¹¦ÄÜÃèÊö£º¸ù¾ÝÈÎÎñID»ñÈ¡TCB
+* ²ÎÊý˵Ã÷£º(IN)
+ taskId:ÈÎÎñID
+ (OUT)
+* ·µ »Ø Öµ£ºTCB±íÖ¸Õ룬ʧ°Ü·µ»ØNULL
+* ÆäËü˵Ã÷£º¿ÉÑ¡
+**************************************************************************/
+__tcm_func static T_ZOss_TCB *Sche_GetTCB(const ZOSS_TASK_ID taskId)
+{
+ T_ZOss_TCB *pCurTCB = NULL;
+
+ zOss_AssertEx(NULL != gSche_TCBHeadPtr, NULL);
+
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER))
+ {
+ pCurTCB = gSche_TCBHeadPtr;
+ while (NULL != pCurTCB)
+ {
+ if (pCurTCB == (T_ZOss_TCB *)taskId)
+ {
+ zOss_PutMutex(gSche_TCBMutex);
+ return pCurTCB;
+ }
+ pCurTCB = pCurTCB->next;
+ }
+ zOss_PutMutex(gSche_TCBMutex);
+ }
+ return NULL;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_AddTCB
+* ¹¦ÄÜÃèÊö£ºÌí¼ÓÒ»¸öTCB
+* ²ÎÊý˵Ã÷£º(IN)
+ ptTcb:Ìí¼ÓµÄTCB±íÖ¸Õë
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS,·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º¿ÉÑ¡
+**************************************************************************/
+static UINT32 Sche_AddTCB(T_ZOss_TCB *ptTcb)
+{
+ UINT32 nore = ZOSS_ERROR;
+
+ zOss_AssertEx(NULL != ptTcb, ZOSS_ERROR);
+
+ ptTcb->next = NULL;
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER))
+ {
+ if (gSche_MaxTCBLen >= gSche_Max_TaskTab_Num) /* ³¬¹ý×î´óÈÎÎñÊý */
+ {
+ zOss_PutMutex(gSche_TCBMutex);
+ return ZOSS_ERROR;
+ }
+
+ if (NULL == gSche_TCBTailPtr)
+ {
+ gSche_TCBHeadPtr = ptTcb;
+ gSche_TCBTailPtr = ptTcb;
+ }
+ else
+ {
+ gSche_TCBTailPtr->next = ptTcb;
+ gSche_TCBTailPtr = ptTcb;
+ }
+
+ gSche_MaxTCBLen++;
+ nore = zOss_PutMutex(gSche_TCBMutex);
+ if (nore == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ return ZOSS_SUCCESS;
+ }
+ return ZOSS_ERROR;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºSche_RemoveTCB
+* ¹¦ÄÜÃèÊö£ºÉ¾³ýÒ»¸öTCB£¬²»ÊÍ·Å
+* ²ÎÊý˵Ã÷£º(IN)
+ pDelTcb:ÐèҪɾ³ýµÄTCB±íÖ¸Õë
+ (OUT)
+* ·µ »Ø Öµ£º³É¹¦·µ»ØZOSS_SUCCESS,·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º¿ÉÑ¡
+**************************************************************************/
+static UINT32 Sche_RemoveTCB(T_ZOss_TCB *pDelTcb)
+{
+ T_ZOss_TCB *pCurTCB = NULL;
+ UINT32 nore = ZOSS_ERROR;
+
+ zOss_AssertEx(NULL != pDelTcb, ZOSS_ERROR);
+
+ if (ZOSS_SUCCESS == zOss_GetMutex(gSche_TCBMutex, ZOSS_WAIT_FOREVER))
+ {
+ if (NULL == gSche_TCBHeadPtr) /* Á´±íΪ¿Õ */
+ {
+ zOss_PutMutex(gSche_TCBMutex);
+ return ZOSS_ERROR;
+ }
+
+ if (pDelTcb == gSche_TCBHeadPtr) /* ɾ³ýÍ·½áµã */
+ {
+ if (gSche_TCBHeadPtr == gSche_TCBTailPtr) /* Ö»ÓÐÒ»¸ö½áµã */
+ {
+ gSche_TCBTailPtr = NULL;
+ gSche_TCBHeadPtr = NULL;
+ }
+ else
+ {
+ gSche_TCBHeadPtr = gSche_TCBHeadPtr->next;
+ }
+ gSche_MaxTCBLen--;
+ nore = zOss_PutMutex(gSche_TCBMutex);
+ if (nore == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ return ZOSS_SUCCESS;
+ }
+
+ pCurTCB = gSche_TCBHeadPtr;
+ while (NULL != pCurTCB)
+ {
+ if (pCurTCB->next == pDelTcb)
+ {
+ pCurTCB->next = pDelTcb->next;
+ if (gSche_TCBTailPtr == pDelTcb) /* ɾ³ýβ½áµã */
+ {
+ gSche_TCBTailPtr = pCurTCB;
+ }
+ gSche_MaxTCBLen--;
+ nore = zOss_PutMutex(gSche_TCBMutex);
+ if (nore == ZOSS_ERROR)
+ {
+ return ZOSS_ERROR;
+ }
+ return ZOSS_SUCCESS;
+ }
+ pCurTCB = pCurTCB->next;
+ }
+ zOss_PutMutex(gSche_TCBMutex);
+ }
+ return ZOSS_ERROR;
+}
+
+__tcm_func static VOID TaskTimer_CallBack(T_Task_Arg *task_arg)
+{
+ T_ZOss_TaskMsgHead *pTaskMsg = NULL;
+
+ zOss_AssertExN(task_arg != NULL);
+
+ pTaskMsg = (T_ZOss_TaskMsgHead *)zOss_GetUB(sizeof(T_ZOss_TaskMsgHead) + sizeof(task_arg->arg)); /* ÉêÇëÄÚ´æ³Ø */
+
+ zOss_AssertExN(pTaskMsg != NULL);
+
+ pTaskMsg->send_state = ZOSS_MSGSENDTYPE_TIMER;
+ pTaskMsg->msgID = task_arg->msg_id;
+ pTaskMsg->msgLen = sizeof(task_arg->arg);
+ pTaskMsg->t_task_id = task_arg->task_id;
+ pTaskMsg->s_task_id = (ZOSS_TASK_ID)task_arg->pTimerNode;
+ zOss_Memcpy((UINT8 *)(pTaskMsg + 1), &(task_arg->arg), pTaskMsg->msgLen);
+ zOss_TaskSendDataEx(pTaskMsg); /* ·¢ËÍÏûÏ¢ */
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ: Timer_IgnoreTaskMsg
+* ¹¦ÄÜÃèÊö: ÅжÏÊÇ·ñÐèÒªºöÂÔÊÕµ½µÄ¶¨Ê±Æ÷ÏûÏ¢
+* ²ÎÊý˵Ã÷: (IN)
+ timerId:¶¨Ê±Æ÷ID
+ (OUT)
+* ·µ »Ø Öµ: ÐèÒªºöÂÔ:TRUE;·ñÔòFALSE
+* ÆäËü˵Ã÷: ¸Ãº¯Êý½öÌṩ¸øÈÎÎñµ÷¶È³ÌÐòʹÓã¬ÓÉÓû§±£Ö¤¡£
+ ¶ÔÓÚ·ÇÖÜÆÚÐÔ¶¨Ê±Æ÷£¬Èç¹û·µ»ØTRUE,ÔòͬʱÊͷŶ¨Ê±Æ÷ËùÕ¼×ÊÔ´
+**************************************************************************/
+__tcm_func static BOOL Timer_IgnoreTaskMsg(ZOSS_TASK_ID timerId)
+{
+ T_TIMER_NODE *pTimerNode = NULL;
+
+ zOss_AssertEx(NULL != timerId, TRUE);
+ pTimerNode = (T_TIMER_NODE *)timerId;
+
+ if (pTimerNode->Flag != TIMER_USE && pTimerNode->Flag != TIMER_SUSPEND)
+ {
+ return TRUE;
+ }
+
+ if (pTimerNode->bPeriod == FALSE)
+ {
+ zOss_KillTimer(timerId);
+ }
+
+ return FALSE;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_vsim.c b/cp/ps/plat/src/oss/sup/src/sup_vsim.c
new file mode 100644
index 0000000..8bb7963
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_vsim.c
@@ -0,0 +1,781 @@
+/**************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+***************************************************************************
+* Ä£ ¿é Ãû : P98_VSIM
+* ÎÄ ¼þ Ãû : sup_vsim.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : vsimÊý¾Ý¹ÜÀí½Ó¿Ú
+* ×÷ Õß : ´ú¿µ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2016-08-06
+* ÆäËü˵Ã÷ :
+**************************************************************************/
+
+/**************************************************************************
+* #includeÇø
+**************************************************************************/
+#include "oss_api.h"
+#include "drv_api.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**************************************************************************
+* ºê¶¨ÒåÇø
+**************************************************************************/
+#define VSIM_OP_MEM 0x01 /* VSIMÄÚ´æģʽ */
+#define VSIM_OP_FLASH 0x02 /* VSIM FLASHģʽ */
+
+#define VSIM_SYMBOL_DOWNLOAD 0xA2 /* °æ±¾ÏÂÔرê־λ */
+#define VSIM_SYMBOL_NORMAL 0xB3 /* Õý³£±ê־λ */
+#define VSIM_SYMBOL_WRITE 0xC4 /* дÊý¾Ý±ê־λ */
+#define VSIM_SYMBOL_MEM 0xD5 /* VSIM ÄÚ´æģʽ */
+
+#define VSIM_WORK_AREA 0x01 /* ¹¤×÷Çø±êʶ */
+#define VSIM_BACKUP_AREA 0x02 /* ±¸·ÝÇø±êʶ */
+#define VSIM_BOTH_AREA 0x03 /* ¹¤×÷ÇøºÍ±¸·ÝÇø±êʶ */
+
+/**************************************************************************
+* Íⲿº¯ÊýÉùÃ÷
+**************************************************************************/
+extern UINT8 zOss_GetVsimSupport(VOID);
+extern VOID zOss_vSIMAgtInit(VOID);
+extern SINT32 zDrvNand_SimNvRead(UINT32 dwStart, UINT32 dwLen, UINT8* to);
+extern SINT32 zDrvNand_SimNvProgram(UINT32 dwStart, UINT32 dwLen, UINT8* from);
+extern SINT32 zDrvNand_SimNvFacRead(UINT32 dwStart, UINT32 dwLen, UINT8* to);
+extern SINT32 zDrvNand_SimNvFacProgram(UINT32 dwStart, UINT32 dwLen, UINT8* from);
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+**************************************************************************/
+static UINT32 vSIM_Resume_Data(UINT8 index);
+static VOID vSIM_Fill_Factory(VOID);
+static BOOL vSIM_Check_Data(VOID);
+static SINT32 vSIM_ReadWithNoReset(UINT32 dwStart, UINT32 dwLen, UINT8* to);
+
+/**************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+**************************************************************************/
+static BOOL gvSIM_Inited = FALSE;
+static BOOL gvSIM_OP_MODE = VSIM_OP_FLASH;
+static BOOL gvSIM_InResume = FALSE; /* vSIM»Ö¸´Á÷³ÌÖÐ */
+static VOID *gvSIM_FacMem = NULL;
+static ZOSS_MUTEX_ID gvSIM_Mutex = ZOSS_NULL;
+static T_vSIM_PARAM *gpvSIM_Param = NULL;
+
+/**************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* º¯ÊýÃû³Æ£º VSIM_Init
+* ¹¦ÄÜÃèÊö£º VSIM³õʼ»¯
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_vSIMInit(VOID)
+{
+#if 0
+ T_OSS_PARAM *pOssParam = NULL;
+
+ if (!zOss_GetVsimSupport())
+ {
+ return ZOSS_SUCCESS;
+ }
+
+ if (gvSIM_Inited)
+ {
+ return ZOSS_SUCCESS;
+ }
+
+ pOssParam = zOss_GetOssCfg();
+ gpvSIM_Param = &(pOssParam->vSIMCfg);
+
+ if (!vSIM_Check_Data())
+ {
+ return ZOSS_ERROR;
+ }
+
+ gvSIM_Mutex = zOss_CreateMutex("vSIM_Mutex", ZOSS_INHERIT);
+ if (gvSIM_Mutex == NULL)
+ {
+ return ZOSS_ERROR;
+ }
+
+#ifdef _USE_VSIM_AGT
+ zOss_vSIMAgtInit();
+#endif
+
+ gvSIM_Inited = TRUE;
+
+ return ZOSS_SUCCESS;
+#else
+ return ZOSS_SUCCESS;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_vSIMDataRead
+* ¹¦ÄÜÃèÊö£º ¶ÁÈ¡Ö¸¶¨Çø¼äµÄvSIMÊý¾Ý
+* ²ÎÊý˵Ã÷£º (IN)
+* addr: Æ«ÒƵØÖ·
+* data: Êý¾Ý´æ´¢¿Õ¼ä
+* len: ¶ÁÈ¡Êý¾ÝµÄ³¤¶È,µ¥Î»×Ö½Ú;
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_vSIMDataRead(UINT32 addr, VOID *data, UINT32 len)
+{
+#if 0
+ SINT32 status = -1;
+
+ zOss_AssertEx(gvSIM_Inited, ZOSS_ERROR);
+ zOss_AssertEx(addr >= gpvSIM_Param->Work_Area_Base_Addr
+ && len <= gpvSIM_Param->Area_Size
+ && addr + len <= gpvSIM_Param->Work_Area_Base_Addr + gpvSIM_Param->Area_Size,
+ ZOSS_ERROR);
+
+ zOss_GetMutex(gvSIM_Mutex, ZOSS_WAIT_FOREVER);
+
+ if(VSIM_OP_MEM == gvSIM_OP_MODE)
+ {
+ if(!gvSIM_FacMem)
+ {
+ zOss_PutMutex(gvSIM_Mutex);
+ return ZOSS_ERROR;
+ }
+ zOss_Memcpy(data, (VOID *)((UINT8 *)gvSIM_FacMem + addr), len);
+ status = 0;
+ }
+ else
+ {
+ status = zDrvNand_SimNvRead(gpvSIM_Param->Work_Area_Base_Addr + addr, len, data);
+ }
+
+
+ zOss_PutMutex(gvSIM_Mutex);
+
+ return (status == 0) ? ZOSS_SUCCESS : ZOSS_ERROR;
+#else
+ zOss_AssertEx(0, ZOSS_ERROR);
+ return ZOSS_ERROR;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_vSIMDataWrite
+* ¹¦ÄÜÃèÊö£º дÈëÖ¸¶¨Çø¼äµÄvSIMÊý¾Ý
+* ²ÎÊý˵Ã÷£º (IN)
+* addr: µØÖ·
+* data: Êý¾ÝÔ´¿Õ¼ä
+* len: дÈëÊý¾ÝµÄ³¤¶È,µ¥Î»×Ö½Ú;
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_vSIMDataWrite(UINT32 addr, VOID *data, UINT32 len)
+{
+#if 0
+ UINT8 symbol = VSIM_SYMBOL_WRITE;
+ SINT32 status = -1;
+
+ zOss_AssertEx(gvSIM_Inited, ZOSS_ERROR);
+ zOss_AssertEx(addr >= gpvSIM_Param->Work_Area_Base_Addr
+ && len <= gpvSIM_Param->Area_Size
+ && addr + len <= gpvSIM_Param->Work_Area_Base_Addr + gpvSIM_Param->Area_Size,
+ ZOSS_ERROR);
+
+ zOss_GetMutex(gvSIM_Mutex, ZOSS_WAIT_FOREVER);
+
+ if(VSIM_OP_MEM == gvSIM_OP_MODE)
+ {
+ if(!gvSIM_FacMem)
+ {
+ zOss_PutMutex(gvSIM_Mutex);
+ return ZOSS_ERROR;
+ }
+ zOss_Memcpy((VOID *)((UINT8 *)gvSIM_FacMem + addr), data, len);
+ status = 0;
+ }
+ else
+ {
+ do
+ {
+ /* д¹¤×÷Çø */
+ symbol = VSIM_SYMBOL_WRITE;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Base_Addr + addr, len, data);
+ if (status != 0)
+ {
+ break;
+ }
+
+ symbol = VSIM_SYMBOL_NORMAL;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ /* д±¸·ÝÇø */
+ symbol = VSIM_SYMBOL_WRITE;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Base_Addr + addr, len, data);
+ if (status != 0)
+ {
+ break;
+ }
+
+ symbol = VSIM_SYMBOL_NORMAL;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+ }while(0);
+ }
+
+ zOss_PutMutex(gvSIM_Mutex);
+
+ return (status == 0) ? ZOSS_SUCCESS : ZOSS_ERROR;
+#else
+ zOss_AssertEx(0, ZOSS_ERROR);
+ return ZOSS_ERROR;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_vSIMFacWrite
+* ¹¦ÄÜÃèÊö£º дÈëvSIM³ö³§ÇøµÄÈ«²¿Êý¾Ý
+* ²ÎÊý˵Ã÷£º (IN)
+* data: Êý¾Ý´æ´¢¿Õ¼ä
+* len: ¶ÁÈ¡Êý¾ÝµÄ³¤¶È,µ¥Î»×Ö½Ú;
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+UINT32 zOss_vSIMFacWrite(VOID *data, UINT32 len)
+{
+#if 0
+ UINT8 symbol = VSIM_SYMBOL_WRITE;
+ SINT32 status = -1;
+
+ zOss_AssertEx(gvSIM_Inited && gpvSIM_Param->Area_Size >= len, ZOSS_ERROR);
+
+ if(VSIM_OP_MEM == gvSIM_OP_MODE)
+ {
+ zOss_AssertEx(!gvSIM_FacMem, ZOSS_ERROR);
+ gvSIM_FacMem = zOss_Malloc(len);
+ if(NULL == gvSIM_FacMem)
+ {
+ return ZOSS_ERROR;
+ }
+ zOss_Memcpy(gvSIM_FacMem, data, len);
+ status = 0;
+ }
+ else
+ {
+ do
+ {
+ symbol = VSIM_SYMBOL_WRITE;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Factory_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ status = zDrvNand_SimNvFacProgram(gpvSIM_Param->Factory_Area_Base_Addr, len, data);
+ if(status != 0)
+ {
+ break;
+ }
+
+ symbol = VSIM_SYMBOL_DOWNLOAD;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Factory_Area_Symbol_Addr, 1, &symbol);
+ if(status != 0)
+ {
+ break;
+ }
+ }while(0);
+ }
+
+ return (status == 0) ? ZOSS_SUCCESS : ZOSS_ERROR;
+#else
+ zOss_AssertEx(0, ZOSS_ERROR);
+ return ZOSS_ERROR;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_vSIMRecovery
+* ¹¦ÄÜÃèÊö£º ´Ó³ö³§Çø»Ö¸´Êý¾Ýµ½¹¤×÷ÇøºÍ±¸·ÝÇø
+* ²ÎÊý˵Ã÷£º (IN)
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS
+* ÆäËü˵Ã÷£º ÖØÆôºóÉúЧ
+**************************************************************************/
+UINT32 zOss_vSIMRecovery(VOID)
+{
+#if 0
+ UINT8 symbol = VSIM_SYMBOL_DOWNLOAD;
+
+ if(gvSIM_OP_MODE == VSIM_OP_MEM)
+ return ZOSS_ERROR;
+
+ return zDrvNand_SimNvProgram(gpvSIM_Param->Factory_Area_Symbol_Addr, 1, &symbol) == DRV_SUCCESS ? ZOSS_SUCCESS : ZOSS_ERROR;
+#else
+ zOss_AssertEx(0, ZOSS_ERROR);
+ return ZOSS_ERROR;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_vSIMSetErrorAddr
+* ¹¦ÄÜÃèÊö£º ¸ù¾Ý³ö´íµÄµØÖ·¿Õ¼ä,ÉèÖöÔÓ¦Çø¼äµÄ±ê־λ,ÒÔ±ãÖØÆôºó½øÈë»Ö¸´Á÷³Ì,½â¾önandµÄ±ÈÌØλ·´×ªÎÊÌâ
+* ²ÎÊý˵Ã÷£º addr:²Ù×÷³ö´íÇøÓòµÄÂß¼µØÖ·
+* ·µ »Ø Öµ£º ÎÞ
+* ÆäËü˵Ã÷£º Çý¶¯½öÔÚvSIMÇø²Ù×÷³öÏÖECC´íÎóʱµ÷ÓÃ
+**************************************************************************/
+VOID zOss_vSIMSetErrorAddr(UINT32 addr)
+{
+#if 0
+ UINT8 symbol = VSIM_SYMBOL_WRITE;
+ UINT32 rw_start = 0;
+ UINT32 bk_start = 0;
+ UINT32 rw_end = 0;
+ UINT32 bk_end = 0;
+
+ rw_start = gpvSIM_Param->Work_Area_Base_Addr;
+ bk_start = gpvSIM_Param->Backup_Area_Base_Addr;
+ rw_end = rw_start + gpvSIM_Param->Area_Size - 1;
+ bk_end = bk_start + gpvSIM_Param->Area_Size - 1;
+
+ gvSIM_InResume = TRUE;
+ if(addr >= rw_start && addr <= rw_end)
+ {
+ zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Symbol_Addr, 1, &symbol);
+ }
+ else if(addr >= bk_start && addr <= bk_end)
+ {
+ zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Symbol_Addr, 1, &symbol);
+ }
+ else
+ {
+ zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Symbol_Addr, 1, &symbol);
+ zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Symbol_Addr, 1, &symbol);
+ symbol = VSIM_SYMBOL_DOWNLOAD;
+ zDrvNand_SimNvProgram(gpvSIM_Param->Factory_Area_Symbol_Addr, 1, &symbol);
+ }
+ gvSIM_InResume = FALSE;
+ return;
+#else
+ return;
+#endif
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º zOss_vSIMInResume
+* ¹¦ÄÜÃèÊö£º ÊÇ·ñ´¦ÓÚ»Ö¸´Á÷³ÌÖÐ
+* ²ÎÊý˵Ã÷£º ÎÞ
+* ·µ »Ø Öµ£º TRUE:´¦ÓÚ»Ö¸´Á÷³Ì£»FLASE:²»´¦ÓÚ»Ö¸´Á÷³Ì
+* ÆäËü˵Ã÷£º Çý¶¯Ê¹ÓÃ
+**************************************************************************/
+BOOL zOss_vSIMInResume(VOID)
+{
+ return gvSIM_InResume;
+}
+
+/**************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+**************************************************************************/
+/**************************************************************************
+* º¯ÊýÃû³Æ£º vSIM_Resume_Data
+* ¹¦ÄÜÃèÊö£º »Ö¸´Êý¾Ý
+* ²ÎÊý˵Ã÷£º (IN)
+* index: ÇøÓòË÷ÒýºÅ:
+* index = VSIM_WORK_AREA: »Ö¸´¹¤×÷Çø
+* index = VSIM_BACKUP_AREA: »Ö¸´±¸·ÝÇø
+* index = VSIM_BOTH_AREA: »Ö¸´¹¤×÷ÇøºÍ±¸·ÝÇø
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static UINT32 vSIM_Resume_Data(UINT8 index)
+{
+ UINT8 symbol = 0;
+ UINT8 *temp = NULL;
+ SINT32 status = -1;
+
+ switch (index)
+ {
+ case VSIM_WORK_AREA:
+ {
+ temp = (UINT8 *)zOss_Malloc(gpvSIM_Param->Area_Size);
+ if (temp == NULL)
+ {
+ return ZOSS_ERROR;
+ }
+ status = zDrvNand_SimNvRead(gpvSIM_Param->Backup_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+
+ if (status != 0)
+ {
+ break;
+ }
+
+ gvSIM_InResume = TRUE;
+
+ symbol = VSIM_SYMBOL_WRITE;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+ if (status != 0)
+ {
+ break;
+ }
+
+ symbol = VSIM_SYMBOL_NORMAL;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ gvSIM_InResume = FALSE;
+
+ zOss_Free(temp);
+ return ZOSS_SUCCESS;
+ }
+ case VSIM_BACKUP_AREA:
+ {
+ temp = (UINT8 *)zOss_Malloc(gpvSIM_Param->Area_Size);
+ if (temp == NULL)
+ {
+ return ZOSS_ERROR;
+ }
+
+ status = zDrvNand_SimNvRead(gpvSIM_Param->Work_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+ if (status != 0)
+ {
+ break;
+ }
+
+ gvSIM_InResume = TRUE;
+
+ symbol = VSIM_SYMBOL_WRITE;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+ if (status != 0)
+ {
+ break;
+ }
+
+ symbol = VSIM_SYMBOL_NORMAL;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ gvSIM_InResume = FALSE;
+
+ zOss_Free(temp);
+ return ZOSS_SUCCESS;
+ }
+ case VSIM_BOTH_AREA:
+ {
+ temp = (UINT8 *)zOss_Malloc(gpvSIM_Param->Area_Size);
+ if (temp == NULL)
+ {
+ return ZOSS_ERROR;
+ }
+ zOss_Memset(temp, 0xff, gpvSIM_Param->Area_Size);
+
+ status = zDrvNand_SimNvFacRead(gpvSIM_Param->Factory_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+ if (status != 0)
+ {
+ zOss_Free(temp);
+ zOss_AssertEx(0, ZOSS_ERROR);
+ }
+
+ gvSIM_InResume = TRUE;
+
+ /* »Ö¸´¹¤×÷Çø */
+ symbol = VSIM_SYMBOL_WRITE;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+ if (status != 0)
+ {
+ break;
+ }
+
+ symbol = VSIM_SYMBOL_NORMAL;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Work_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ /* »Ö¸´±¸·ÝÇø */
+ symbol = VSIM_SYMBOL_WRITE;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+ if (status != 0)
+ {
+ break;
+ }
+
+ symbol = VSIM_SYMBOL_NORMAL;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Backup_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ /* ÖØÖóö³¡Çø±ê־λ */
+ symbol = VSIM_SYMBOL_NORMAL;
+ status = zDrvNand_SimNvProgram(gpvSIM_Param->Factory_Area_Symbol_Addr, 1, &symbol);
+ if (status != 0)
+ {
+ break;
+ }
+
+ gvSIM_InResume = FALSE;
+
+ zOss_Free(temp);
+
+ return ZOSS_SUCCESS;
+ }
+ default:
+ {
+ return ZOSS_ERROR;
+ }
+ }
+
+ gvSIM_InResume = FALSE;
+
+ if(temp != NULL)
+ {
+ zOss_Free(temp);
+ }
+ return ZOSS_ERROR;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£ºvSIM_Fill_Factory
+* ¹¦ÄÜÃèÊö£º´Ó¹¤×÷Çø/±¸·ÝÇø¿½±´Êý¾Ýµ½³ö³§Çø
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£ºÎÞ
+**************************************************************************/
+static VOID vSIM_Fill_Factory(VOID)
+{
+ VOID *temp = NULL;
+ UINT8 symbol = 0;
+ SINT32 Status = -1;
+
+ temp = zOss_Malloc(gpvSIM_Param->Area_Size);
+ zOss_AssertExN(temp != NULL);
+
+ do
+ {
+ Status = vSIM_ReadWithNoReset(gpvSIM_Param->Work_Area_Symbol_Addr, 1, &symbol);
+ if(Status != 0 || symbol != VSIM_SYMBOL_NORMAL)
+ {
+ break;
+ }
+
+ Status = zDrvNand_SimNvRead(gpvSIM_Param->Work_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+ if(Status != 0)
+ {
+ break;
+ }
+
+ symbol = VSIM_SYMBOL_NORMAL;
+ gvSIM_InResume = TRUE;
+ zDrvNand_SimNvFacProgram(gpvSIM_Param->Factory_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+ zDrvNand_SimNvProgram(gpvSIM_Param->Factory_Area_Symbol_Addr, 1, &symbol);
+ gvSIM_InResume = FALSE;
+
+ zOss_Free(temp);
+ return;
+ }while(0);
+
+ do
+ {
+ Status = vSIM_ReadWithNoReset(gpvSIM_Param->Backup_Area_Symbol_Addr, 1, &symbol);
+ if(Status != 0 || symbol != VSIM_SYMBOL_NORMAL)
+ {
+ break;
+ }
+
+ Status = zDrvNand_SimNvRead(gpvSIM_Param->Backup_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+ if(Status != 0)
+ {
+ break;
+ }
+
+ symbol = VSIM_SYMBOL_NORMAL;
+ gvSIM_InResume = TRUE;
+ zDrvNand_SimNvFacProgram(gpvSIM_Param->Factory_Area_Base_Addr, gpvSIM_Param->Area_Size, temp);
+ zDrvNand_SimNvProgram(gpvSIM_Param->Factory_Area_Symbol_Addr, 1, &symbol);
+ gvSIM_InResume = FALSE;
+
+ zOss_Free(temp);
+ return;
+ }while(0);
+
+ zOss_Free(temp);
+ zOss_AssertExN(0);
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º vSIM_ReadWithNoReset
+* ¹¦ÄÜÃèÊö£º ¼òµ¥·â×°Çý¶¯¶Á½Ó¿Ú£¬·¢ÉúECC´íÎóʱ²»ÖØÆô
+* ²ÎÊý˵Ã÷£º (IN)
+* dwStart: Æ«ÒƵØÖ·
+* dwLen: ³¤¶È
+* to: Ä¿±ê»º´æ¿Õ¼ä
+* (OUT)
+* ·µ »Ø Öµ£º ͬÇý¶¯½Ó¿Ú·µ»ØÖµ£¬³É¹¦·µ»Ø0
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static SINT32 vSIM_ReadWithNoReset(UINT32 dwStart, UINT32 dwLen, UINT8* to)
+{
+ SINT32 status = -1;
+
+ gvSIM_InResume = TRUE;
+ status = zDrvNand_SimNvRead(dwStart, dwLen, to);
+ gvSIM_InResume = FALSE;
+
+ return status;
+}
+
+/**************************************************************************
+* º¯ÊýÃû³Æ£º vSIM_Check_Data
+* ¹¦ÄÜÃèÊö£º vSIMÊý¾Ý»Ö¸´Á÷³Ì
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØTRUE, ·ñÔò·µ»ØFALSE
+* ÆäËü˵Ã÷£º
+**************************************************************************/
+static BOOL vSIM_Check_Data(VOID)
+{
+ UINT8 index = 0;
+ UINT8 WorkArea_Symbol = 0;
+ UINT8 BackUp_Symbol = 0;
+ UINT8 Factory_Symbol = 0;
+ UINT32 status = ZOSS_ERROR;
+ SINT32 WorkArea_Status = -1;
+ SINT32 BackUp_Status = -1;
+
+ status = vSIM_ReadWithNoReset(gpvSIM_Param->Factory_Area_Symbol_Addr, 1, &Factory_Symbol);
+ if(Factory_Symbol == VSIM_SYMBOL_MEM)
+ {
+ gvSIM_OP_MODE = VSIM_OP_MEM;
+ return TRUE;
+ }
+
+ /* °æ±¾ÏÂÔØ */
+ if(Factory_Symbol == VSIM_SYMBOL_DOWNLOAD)
+ {
+ return (vSIM_Resume_Data(VSIM_WORK_AREA | VSIM_BACKUP_AREA) == ZOSS_SUCCESS) ? TRUE : FALSE;
+ }
+
+ /* ³ö³§Çøµôµç */
+ if(status != 0 || Factory_Symbol == VSIM_SYMBOL_WRITE)
+ {
+ vSIM_Fill_Factory();
+ }
+
+ /* ¶ÁÈ¡¹¤×÷ÇøºÍ±¸·ÝÇøÖеıê־λ */
+ WorkArea_Status = zDrvNand_SimNvRead(gpvSIM_Param->Work_Area_Symbol_Addr, 1, &WorkArea_Symbol);
+ BackUp_Status = zDrvNand_SimNvRead(gpvSIM_Param->Backup_Area_Symbol_Addr, 1, &BackUp_Symbol);
+ if (WorkArea_Status == 0 && BackUp_Status == 0)
+ {
+ if (WorkArea_Symbol != VSIM_SYMBOL_NORMAL)
+ {
+ index = VSIM_WORK_AREA;
+ }
+
+ if (BackUp_Symbol != VSIM_SYMBOL_NORMAL)
+ {
+ index |= VSIM_BACKUP_AREA;
+ }
+
+ if (index != 0)
+ {
+ status = vSIM_Resume_Data(index);
+ if (status != ZOSS_SUCCESS)
+ {
+ return FALSE;
+ }
+ }
+ }
+ else if (WorkArea_Status == 0 && WorkArea_Symbol == VSIM_SYMBOL_NORMAL)
+ {
+ index = VSIM_BACKUP_AREA;
+ status = vSIM_Resume_Data(index);
+ if (status != ZOSS_SUCCESS)
+ {
+ return FALSE;
+ }
+ }
+ else if (BackUp_Status == 0 && BackUp_Symbol == VSIM_SYMBOL_NORMAL)
+ {
+ index = VSIM_WORK_AREA;
+ status = vSIM_Resume_Data(index);
+ if (status != ZOSS_SUCCESS)
+ {
+ return FALSE;
+ }
+ }
+ else
+ {
+ index = VSIM_WORK_AREA | VSIM_BACKUP_AREA;
+ status = vSIM_Resume_Data(index);
+ if (status != ZOSS_SUCCESS)
+ {
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/src/sup_vsim_agt.c b/cp/ps/plat/src/oss/sup/src/sup_vsim_agt.c
new file mode 100644
index 0000000..b9ce357
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/src/sup_vsim_agt.c
@@ -0,0 +1,215 @@
+/*******************************************************************************
+*
+* Copyright (c) 2012 ZTE Corporation.
+*
+********************************************************************************
+* Ä£ ¿é Ãû : P98_VSIM
+* ÎÄ ¼þ Ãû : vsim_icp.c
+* Ïà¹ØÎļþ :
+* ʵÏÖ¹¦ÄÜ : vsimÊý¾Ý¹ÜÀí½Ó¿Ú
+* ×÷ Õß : ´ú¿µ
+* °æ ±¾ : V1.0
+* Íê³ÉÈÕÆÚ : 2016-08-06
+* ÆäËü˵Ã÷ :
+*******************************************************************************/
+
+/*******************************************************************************
+* #includeÇø
+*******************************************************************************/
+#include "oss_api.h"
+#include "drv_api.h"
+#include "drvs_rpmsg.h"
+#include "drvs_icp.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*******************************************************************************
+* ºê¶¨ÒåÇø
+*******************************************************************************/
+#define VSIM_ICP_CHANNEL_SIZE (1 * 1024)
+#define VSIM_ICP_CHANNEL (VSIM)
+#define VSIM_ICP_MAX_SIZE (5 * 1024)
+#define VSIM_ICP_MSG_HEADER_SIZE (16)
+#define VSIM_ICP_BUF_SIZE (VSIM_ICP_MAX_SIZE-VSIM_ICP_MSG_HEADER_SIZE)
+
+/*******************************************************************************
+* Êý¾ÝÀàÐͶ¨Òå *
+*******************************************************************************/
+
+typedef struct
+{
+ UINT32 addr;
+ UINT32 len;
+ CHAR buf[VSIM_ICP_BUF_SIZE];
+} icp_msg_data_t;
+
+typedef struct
+{
+ unsigned long cmd;
+ unsigned long total;
+ icp_msg_data_t data;
+} icp_msg_t;
+
+enum
+{
+ VSIM_CMD_RECOVERY = 1,
+ VSIM_CMD_WRITE_FACTORY,
+ VSIM_CMD_WRITE_SPECIAL,
+};
+
+/*******************************************************************************
+* Íⲿº¯ÊýÉùÃ÷
+*******************************************************************************/
+
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýÔÐÍ
+*******************************************************************************/
+static UINT32 vsim_icp_buf[VSIM_ICP_MAX_SIZE / sizeof(UINT32)];
+
+/*******************************************************************************
+* È«¾Ö³£Á¿/±äÁ¿
+*******************************************************************************/
+
+
+/*******************************************************************************
+* ¾Ö²¿º¯ÊýʵÏÖ
+*******************************************************************************/
+
+/*******************************************************************************
+* º¯ÊýÃû³Æ£º vSIM_Resume_Data
+* ¹¦ÄÜÃèÊö£º »Ö¸´Êý¾Ý
+* ²ÎÊý˵Ã÷£º (IN)
+* index: ÇøÓòË÷ÒýºÅ:
+* index = VSIM_WORK_AREA: »Ö¸´¹¤×÷Çø
+* index = VSIM_BACKUP_AREA: »Ö¸´±¸·ÝÇø
+* index = VSIM_BOTH_AREA: »Ö¸´¹¤×÷ÇøºÍ±¸·ÝÇø
+* (OUT)
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+*******************************************************************************/
+static VOID vsim_icp_read_blocked(SINT32 args)
+{
+ UINT32 ret = ZOSS_ERROR;
+ CHAR *pBuf = NULL;
+ CHAR *pTmp = NULL;
+ UINT32 len = 0;
+ icp_msg_t *pMsg = NULL;
+ T_ZDrvRpMsg_Msg msgRead;
+ T_ZDrvRpMsg_Msg msgWrite;
+
+ msgRead.actorID = ICP_MSG_ACTOR_A9;
+ msgRead.chID = VSIM_ICP_CHANNEL;
+ msgRead.buf = vsim_icp_buf;
+
+ msgWrite.actorID = ICP_MSG_ACTOR_A9;
+ msgWrite.chID = VSIM_ICP_CHANNEL;
+
+ while(1)
+ {
+ ret = ZOSS_ERROR;
+ msgRead.flag = ~RPMSG_READ_POLL;
+ msgRead.len = sizeof(vsim_icp_buf);
+
+ do
+ {
+ ret = zDrvRpMsg_Read(&msgRead);
+ if (ret == RPMSG_CHANNEL_INEXISTANCE)
+ break;
+ zOss_ASSERT(ret > 0);
+
+ pMsg = (icp_msg_t *)vsim_icp_buf;
+ if(pMsg->total)
+ {
+ if(!pBuf)
+ {
+ pBuf = zOss_Malloc(pMsg->total);
+ if (pBuf == NULL)
+ zOss_ASSERT(pBuf != NULL);
+
+ pTmp = pBuf;
+ len = pMsg->total;
+ }
+ zOss_Memcpy(pTmp, pMsg->data.buf, pMsg->data.len);
+ pTmp += pMsg->data.len;
+ len -= pMsg->data.len;
+
+ msgWrite.buf = &ret;
+ ret = 0;
+ msgWrite.flag = RPMSG_WRITE_INT;
+ msgWrite.len = sizeof(ret);
+ ret = zDrvRpMsg_Write(&msgWrite);
+ zOss_ASSERT(ret > 0);
+ }
+ }while(len > 0);
+
+ if (ret == RPMSG_CHANNEL_INEXISTANCE)
+ continue;
+
+ switch (pMsg->cmd)
+ {
+ case VSIM_CMD_RECOVERY:
+ ret = zOss_vSIMRecovery();
+ break;
+
+ case VSIM_CMD_WRITE_FACTORY:
+ ret = zOss_vSIMFacWrite((VOID *)pBuf, pMsg->total);
+ ret = 0;
+ break;
+
+ case VSIM_CMD_WRITE_SPECIAL:
+ ret = zOss_vSIMDataWrite(pMsg->data.addr, (VOID *)pBuf, pMsg->total);
+ ret = 0;
+ break;
+
+ default:
+ break;
+ }
+
+ if (pBuf != NULL)
+ {
+ zOss_Free(pBuf);
+ pBuf = NULL;
+ }
+
+ msgWrite.buf = &ret;
+ msgWrite.flag = RPMSG_WRITE_INT;
+ msgWrite.len = sizeof(ret);
+ ret = zDrvRpMsg_Write(&msgWrite);
+ zOss_ASSERT(ret > 0);
+
+ zOss_Memset(vsim_icp_buf, 0, VSIM_ICP_MAX_SIZE);
+ }
+}
+
+
+/*******************************************************************************
+* È«¾Öº¯ÊýʵÏÖ
+*******************************************************************************/
+/*******************************************************************************
+* º¯ÊýÃû³Æ£º zOss_vSIMAgtInit
+* ¹¦ÄÜÃèÊö£º VSIM´úÀí³õʼ»¯
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
+* ÆäËü˵Ã÷£º
+*******************************************************************************/
+VOID zOss_vSIMAgtInit(VOID)
+{
+ SINT32 ret;
+ ZOSS_THREAD_ID threadID;
+
+ ret = zDrvRpMsg_CreateChannel(ICP_MSG_ACTOR_A9, VSIM_ICP_CHANNEL, VSIM_ICP_CHANNEL_SIZE);
+ zOss_ASSERT(ret == DRV_SUCCESS);
+
+
+ threadID = zOss_CreateThread("vsim_icp_read_thread", vsim_icp_read_blocked, 0, 4 * 1024, 25, 1, 1);
+ zOss_ASSERT(threadID != NULL);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/cp/ps/plat/src/oss/sup/ws/makefile b/cp/ps/plat/src/oss/sup/ws/makefile
new file mode 100644
index 0000000..4c9e1f0
--- /dev/null
+++ b/cp/ps/plat/src/oss/sup/ws/makefile
@@ -0,0 +1,48 @@
+# /*****************************************************************************
+#* °æȨËùÓÐ(C) 2013 ÖÐÐËͨѶ¹É·ÝÓÐÏÞ¹«Ë¾
+#*
+#* ÎļþÃû³Æ: Makefile
+#* Îļþ±êʶ: Makefile
+#* ÄÚÈÝÕªÒª: ±àÒë×Óϵͳsup
+#* ʹÓ÷½·¨:
+#*
+#* ÐÞ¸ÄÈÕÆÚ °æ±¾ºÅ Ð޸ıê¼Ç ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
+#* -----------------------------------------------------------------------------
+#* 2013/01/01 V1.0 001 P98G ´´½¨
+#*
+# *****************************************************************************/
+
+include $(PRJ_PATH)/config/project.mk
+
+#===============================================================================
+#·¾¶ÉèÖÃ
+#===============================================================================
+_SUBSYS_NAME = plat_sup
+
+_SUBSYS_LIB_PATH = $(PLAT_LIB_INTERNAL_PATH)
+
+_ALL_MDLS =
+_ALL_OBJECTS =
+
+MDL_PATH = $(PLAT_PATH)/src/oss/sup/src
+
+#===============================================================================
+#SUPÄ£¿é
+#===============================================================================
+sup:
+ @$(GNUMAKE) --no-print-directory $(MAKEOPTS) -C $(MDL_PATH)
+supclean:
+ @$(GNUMAKE) --no-print-directory $(MAKEOPTS) -C $(MDL_PATH) clean
+
+_ALL_MDLS += sup
+_ALL_OBJECTS += $(wildcard $(OBJ_PATH)/plat/oss/sup/*.o)
+
+ifeq ($(USE_VDD),yes)
+_ALL_OBJECTS += $(wildcard $(OBJ_PATH)/plat/drv/vdd/*.o)
+endif
+
+#===============================================================================
+# ±àÒë¹æÔò
+#===============================================================================
+include $(FRAME_PATH)/rules/lib_rules.mk
+