static HI_S32 DMXTsBufProcRead(struct seq_file *p, HI_VOID *v)
{
HI_U32 PortId;
PROC_PRINT(p, "Id BufAddr BufSize BufUsed Read Write Get(Try/Ok) Put\n");
for (PortId = 0; PortId < DMX_RAMPORT_CNT; PortId++)
{
DMX_Proc_RamPort_BufInfo_S BufInfo;
if (HI_SUCCESS != DMX_OsiRamPortGetBufInfo(PortId, &BufInfo))
{
continue;
}
PROC_PRINT(p, "%u 0x%-8x 0x%-8x 0x%-8x 0x%-8x 0x%-8x %10u/%-10u %u\n",
HI_UNF_DMX_PORT_RAM_0 + PortId,
BufInfo.PhyAddr,
BufInfo.BufSize,
BufInfo.UsedSize,
BufInfo.Read,
BufInfo.Write,
BufInfo.GetCount,
BufInfo.GetValidCount,
BufInfo.PutCount
);
}
return HI_SUCCESS;
}
static int rtnet_mgr_read_proc (char *page, char **start,
off_t off, int count, int *eof, void *data)
{
PROC_PRINT_VARS;
int i;
struct rtnet_device *rtdev;
unsigned int rtskb_len;
PROC_PRINT("\nRTnet\n\n");
PROC_PRINT("Devices:\n");
for (i = 1; i <= MAX_RT_DEVICES; i++) {
rtdev = rtdev_get_by_index(i);
if (rtdev != NULL) {
PROC_PRINT(" %s: %s rxq=%d\n",
rtdev->name,
(rtdev->flags & IFF_UP) ? "UP" : "DOWN",
rtdev->rxqueue_len);
rtdev_dereference(rtdev);
}
}
rtskb_len = ALIGN_RTSKB_STRUCT_LEN + SKB_DATA_ALIGN(RTSKB_SIZE);
PROC_PRINT("\nrtskb pools current/max: %d / %d\n"
"rtskbs current/max: %d / %d\n"
"rtskb memory need current/max: %d / %d\n\n",
rtskb_pools, rtskb_pools_max,
rtskb_amount, rtskb_amount_max,
rtskb_amount * rtskb_len, rtskb_amount_max * rtskb_len);
PROC_PRINT_DONE;
}
static HI_S32 DMXProcRead(struct seq_file *p, HI_VOID *v)
{
HI_U32 DmxId;
PROC_PRINT(p, "DmxId\tPortId\n");
for (DmxId = 0; DmxId < DMX_CNT; DmxId++)
{
HI_S32 ret;
HI_CHAR PortStr[8] = "--";
DMX_PORT_MODE_E PortMode;
HI_U32 PortId;
ret = HI_DRV_DMX_GetPortId(DmxId, &PortMode, &PortId);
if (HI_SUCCESS == ret)
{
snprintf(PortStr, 8,"%u", (DMX_PORT_MODE_TUNER == PortMode) ? PortId : HI_UNF_DMX_PORT_RAM_0 + PortId);
}
PROC_PRINT(p, " %u\t%s\n", DmxId, PortStr);
}
PROC_PRINT(p, "type \"echo help > /proc/msp/demux_main\" to get help informatin\n");
return HI_SUCCESS;
}
static int rtnet_mgr_read_proc (char *page, char **start,
off_t off, int count, int *eof, void *data)
{
PROC_PRINT_VARS;
PROC_PRINT("\nRTnet\n\n");
PROC_PRINT_DONE;
}
static int rt_arp_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
{
PROC_PRINT_VARS;
struct rt_arp_table_struct *arp_entry;
PROC_PRINT("IPaddress\t\tHWaddress\n");
for (arp_entry=arp_list; arp_entry!=NULL; arp_entry=arp_entry->next) {
union { unsigned long l; unsigned char c[4]; } u;
unsigned char *a;
u.l=arp_entry->ip_addr;
a = arp_entry->hw_addr;
PROC_PRINT("%d.%d.%d.%d\t\t%02x:%02x:%02x:%02x:%02x:%02x\n",
u.c[0], u.c[1], u.c[2], u.c[3],
a[0], a[1], a[2], a[3], a[4], a[5]);
}
PROC_PRINT_DONE;
}
static HI_S32 DMXRecProcRead(struct seq_file *p, HI_VOID *v)
{
HI_U32 RecId;
PROC_PRINT(p, "DmxId Type Descramed Status Size BlkCnt BlkSize Read Write Overflow\n");
for (RecId = 0; RecId < DMX_CNT; RecId++)
{
DMX_Proc_Rec_BufInfo_S RecInfo;
HI_CHAR *Type;
HI_CHAR *Status;
HI_U32 Size;
if (HI_SUCCESS != DMX_OsiGetDmxRecProc(RecId, &RecInfo))
{
continue;
}
switch (RecInfo.RecType)
{
case HI_UNF_DMX_REC_TYPE_SELECT_PID :
Type = "pid";
break;
case HI_UNF_DMX_REC_TYPE_ALL_PID :
Type = "all";
break;
default :
continue;
}
Size = RecInfo.BlockCnt * RecInfo.BlockSize / 1024;
Status = RecInfo.RecStatus ? "start" : "stop ";
PROC_PRINT(p, "%3u %s %u %s %5uK %-6u %-7u %-4u %-5u %u\n",
RecId, Type, RecInfo.Descramed, Status, Size, RecInfo.BlockCnt,
RecInfo.BlockSize, RecInfo.BufRead, RecInfo.BufWrite, RecInfo.Overflow);
}
return HI_SUCCESS;
}
static int rtnet_mgr_read_proc (char *page, char **start,
off_t off, int count, int *eof, void *data)
{
PROC_PRINT_VARS;
PROC_PRINT("\nRTnet\n\n"
"rtskbpool low/high water mark: %d / %d \n"
"rtskbs in pool/allocated/max: %d / %d / %d\n\n",
rtskb_pool_min, rtskb_pool_max,
rtskb_pool.qlen, rtskb_amount, rtskb_amount_max);
PROC_PRINT_DONE;
}
static HI_S32 DMXRecScdProcRead(struct seq_file *p, HI_VOID *v)
{
HI_U32 RecId;
PROC_PRINT(p, "DmxId Type Pid Size BlkCnt BlkSize Read Write Overflow\n");
for (RecId = 0; RecId < DMX_CNT; RecId++)
{
DMX_Proc_RecScd_BufInfo_S ScdInfo;
HI_CHAR *Type;
HI_U32 Size;
if (HI_SUCCESS != DMX_OsiGetDmxRecScdProc(RecId, &ScdInfo))
{
continue;
}
switch (ScdInfo.IndexType)
{
case HI_UNF_DMX_REC_INDEX_TYPE_VIDEO :
Type = "video";
break;
case HI_UNF_DMX_REC_INDEX_TYPE_AUDIO :
Type = "audio";
break;
case HI_UNF_DMX_REC_INDEX_TYPE_NONE :
default :
Type = "none ";
}
Size = ScdInfo.BlockCnt * ScdInfo.BlockSize / 1024;
PROC_PRINT(p, "%3u %s 0x%-4x %3uK %-6u %-7u %-4u %-5u %u\n",
RecId, Type, ScdInfo.IndexPid, Size, ScdInfo.BlockCnt,
ScdInfo.BlockSize, ScdInfo.BufRead, ScdInfo.BufWrite, ScdInfo.Overflow);
}
return HI_SUCCESS;
}
static HI_S32 DMXChanProcRead(struct seq_file *p, HI_VOID *v)
{
HI_U32 ChanId;
PROC_PRINT(p, "Id DmxId PID\tType Mod Stat KeyId Acquire(Try/Ok) Release\n");
for (ChanId = 0; ChanId < DMX_CHANNEL_CNT; ChanId++)
{
DMX_ChanInfo_S *ChanInfo;
HI_CHAR ChanType[][8] = {"SEC", "PES", "AUD", "VID", "PST", "ECM"};
HI_CHAR OutMode[][8] = {"Reserve","PLY", "REC", "P&R"};
HI_CHAR KeyStr[8] = "--";
ChanInfo = DMX_OsiGetChannelProc(ChanId);
if (!ChanInfo)
{
continue;
}
if (ChanInfo->KeyId < DMX_KEY_CNT)
{
snprintf(KeyStr, 8,"%-2u", ChanInfo->KeyId);
}
PROC_PRINT(p, "%-2u %u 0x%x\t%s %s %s\t%s %10u/%-10u %u\n",
ChanId,
ChanInfo->DmxId,
ChanInfo->ChanPid,
ChanType[ChanInfo->ChanType],
(ChanInfo->ChanOutMode == HI_UNF_DMX_CHAN_OUTPUT_MODE_BUTT)?"UNO":OutMode[ChanInfo->ChanOutMode ],
(ChanInfo->ChanStatus == HI_UNF_DMX_CHAN_CLOSE) ? "CLOSE" : "OPEN",
KeyStr,
ChanInfo->u32TotolAcq,
ChanInfo->u32HitAcq,
ChanInfo->u32Release
);
}
return HI_SUCCESS;
}
static int proc_read(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
PROC_PRINT_VARS;
PROC_PRINT("\n## RTAI latency calibration tool ##\n");
PROC_PRINT("# period = %i (ns) \n", period);
PROC_PRINT("# avrgtime = %i (s)\n", avrgtime);
PROC_PRINT("# check %s worst case\n", overall ? "overall" : "each average");
PROC_PRINT("#%suse the FPU\n", use_fpu ? " " : " do not " );
PROC_PRINT("#%sstart the timer\n", start_timer ? " " : " do not ");
PROC_PRINT("# timer_mode is %s\n", timer_mode ? "periodic" : "oneshot");
PROC_PRINT("\n");
PROC_PRINT_DONE;
}
static int rtnet_mgr_read_proc (char *page, char **start,
off_t off, int count, int *eof, void *data)
{
PROC_PRINT_VARS;
struct rtnet_device *rtdev;
PROC_PRINT("\nRTnet\n\n");
PROC_PRINT("Devices:\n");
for (rtdev = rtnet_devices; rtdev; rtdev = rtdev->next) {
PROC_PRINT(" %s: %s rxq=%d\n",
rtdev->name,
(rtdev->flags & IFF_UP) ? "UP" : "DOWN",
rtskb_queue_len(&rtdev->rxqueue));
}
PROC_PRINT("rtskbpool low/high water mark: %d / %d \n"
"rtskbs in pool/allocated/max: %d / %d / %d\n\n",
rtskb_pool_min, rtskb_pool_max,
rtskb_pool.qlen, rtskb_amount, rtskb_amount_max);
PROC_PRINT_DONE;
}
static HI_S32 DMXPcrProcRead(struct seq_file *p, HI_VOID *v)
{
HI_U32 PcrId;
PROC_PRINT(p, "Id DmxId PID CurrPcr CurrScr\n");
for (PcrId = 0; PcrId < DMX_PCR_CHANNEL_CNT; PcrId++)
{
DMX_PCR_Info_S *PcrInfo;
PcrInfo = DMX_OsiGetPcrChannelProc(PcrId);
if (!PcrInfo)
{
continue;
}
PROC_PRINT(p, "%-2u %u 0x%-4x 0x%-9llx 0x%-9llx\n",
PcrId, PcrInfo->DmxId, PcrInfo->PcrPid, PcrInfo->PcrValue, PcrInfo->ScrValue);
}
return HI_SUCCESS;
}
static int rtai_read_shm(char *page, char **start, off_t off, int count,
int *eof, void *data) {
PROC_PRINT_VARS;
struct rtai_kmalloc_node* node = rtai_kmalloc_node_root.next;
PROC_PRINT("\nRTAI Shared Memory Manager for uClinux.\n\n");
PROC_PRINT("Name Address Size Used\n");
PROC_PRINT("------------------------------------\n" );
while(node != &rtai_kmalloc_node_root) {
int flags,name,addr,size,used;
save_and_cli(flags);
name=node->name;
addr=node->addr;
size=node->size;
used=node->used;
node=node->next;
restore_flags(flags);
PROC_PRINT("0x%-9x 0x%-9x %-7i %-4i\n",name,addr,size,used);
};
PROC_PRINT_DONE;
} /* End function - rtai_read_shm */
static HI_S32 DMXFilterProcRead(struct seq_file *p, HI_VOID *v)
{
HI_U32 FilterId;
HI_U32 i;
PROC_PRINT(p, "Id ChanId Depth Param\n");
for (FilterId = 0; FilterId < DMX_FILTER_CNT; FilterId++)
{
DMX_FilterInfo_S *FilterInfo;
HI_CHAR str[16] = "--";
FilterInfo = DMX_OsiGetFilterProc(FilterId);
if (!FilterInfo)
{
continue;
}
if (FilterInfo->ChanId < DMX_CHANNEL_CNT)
{
snprintf(str, 16,"%2u", FilterInfo->ChanId);
}
PROC_PRINT(p, "%2u %s %3u Match :", FilterId, str, FilterInfo->Depth);
for (i = 0; i < FilterInfo->Depth; i++)
{
PROC_PRINT(p, " %02x", FilterInfo->Match[i]);
}
PROC_PRINT(p, "\n\t\tMask :");
for (i = 0; i < FilterInfo->Depth; i++)
{
PROC_PRINT(p, " %02x", FilterInfo->Mask[i]);
}
PROC_PRINT(p, "\n\t\tNegate:");
for (i = 0; i < FilterInfo->Depth; i++)
{
PROC_PRINT(p, " %02x", FilterInfo->Negate[i]);
}
PROC_PRINT(p, "\n");
}
return 0;
}
static HI_S32 DMXChanBufProcRead(struct seq_file *p, HI_VOID *v)
{
HI_U32 i;
PROC_PRINT(p, "Id Size BlkCnt BlkSize Read Write Used Overflow\n");
for (i = 0; i < DMX_CHANNEL_CNT; i++)
{
DMX_Proc_ChanBuf_S BufInfo;
HI_U32 UsedPercent = 0;
HI_U32 Size;
if (HI_SUCCESS != DMX_OsiGetChanBufProc(i, &BufInfo))
{
continue;
}
if (BufInfo.DescDepth)
{
if (BufInfo.DescRead <= BufInfo.DescWrite)
{
UsedPercent = (BufInfo.DescWrite - BufInfo.DescRead) * 100 / BufInfo.DescDepth;
}
else
{
UsedPercent = (BufInfo.DescDepth + BufInfo.DescWrite - BufInfo.DescRead) * 100 / BufInfo.DescDepth;
}
}
Size = BufInfo.DescDepth * BufInfo.BlockSize / 1024;
PROC_PRINT(p, "%2u %5uK %-6u %-7u %-4u %-5u %3u%% %u\n",
i, Size, BufInfo.DescDepth, BufInfo.BlockSize, BufInfo.DescRead, BufInfo.DescWrite, UsedPercent, BufInfo.Overflow);
}
return HI_SUCCESS;
}
static HI_S32 DMXPortProcRead(struct seq_file *p, HI_VOID *v)
{
HI_U32 i;
HI_U32 TsPacks;
HI_U32 ErrTsPacks;
HI_UNF_DMX_PORT_ATTR_S PortAttr;
PROC_PRINT(p, "--------------------------tuner port--------------------------------\n");
PROC_PRINT(p, " Id AllTsCnt ErrTsCnt Lock/lost Type TsInClkReverse BitSel\n");
for (i = 0; i < DMX_TUNERPORT_CNT; i++)
{
HI_CHAR str[16] = "";
HI_DRV_DMX_TunerPortGetAttr(i, &PortAttr);
HI_DRV_DMX_TunerPortGetPacketNum(i, &TsPacks, &ErrTsPacks);
PortTypeToString(str, sizeof(str),PortAttr.enPortType);
PROC_PRINT(p, "%3u 0x%-8x 0x%-4x %u/%u %s %d %d\n",
i, TsPacks, ErrTsPacks, PortAttr.u32SyncLockTh, PortAttr.u32SyncLostTh, str,PortAttr.u32TunerInClk,PortAttr.u32SerialBitSelector);
}
PROC_PRINT(p, "\n---------------------------ram port---------------------------------\n");
PROC_PRINT(p, " Id AllTsCnt ErrTsCnt Lock/lost Type TsLenChk1 TsLenChk2\n");
for (i = 0; i < DMX_RAMPORT_CNT; i++)
{
HI_CHAR str[16] = "";
HI_DRV_DMX_RamPortGetAttr(i, &PortAttr);
HI_DRV_DMX_RamPortGetPacketNum(i, &TsPacks);
PortTypeToString(str, sizeof(str),PortAttr.enPortType);
if ( PortAttr.enPortType != HI_UNF_DMX_PORT_TYPE_USER_DEFINED)
{
PROC_PRINT(p, "%3u 0x%-8x 0x0 %u/%u %s -- --\n",
HI_UNF_DMX_PORT_RAM_0 + i, TsPacks, PortAttr.u32SyncLockTh, PortAttr.u32SyncLostTh, str);
}
else
{
PROC_PRINT(p, "%3u 0x%-8x 0x0 %u/%u %s %d %dn",
HI_UNF_DMX_PORT_RAM_0 + i, TsPacks, PortAttr.u32SyncLockTh, PortAttr.u32SyncLostTh, str,PortAttr.u32UserDefLen1,PortAttr.u32UserDefLen2);
}
}
return HI_SUCCESS;
}
int rtmac_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
PROC_PRINT_VARS;
PROC_PRINT("\nRTmac\n\n");
PROC_PRINT_DONE;
}
struct seq_file * wprintinfo(struct seq_file *page)
{
#if HI_TDE_MEMCOUNT_SUPPORT
HI_U32 u32MaxUsed64 = g_struMemBlock[UNIT_SIZE_64].nMaxUsed;
HI_U32 u32MaxUsed128 = g_struMemBlock[UNIT_SIZE_128].nMaxUsed;
HI_U32 u32MaxUsed1024 = g_struMemBlock[UNIT_SIZE_1024].nMaxUsed;
#else
HI_U32 u32Free64 = g_struMemBlock[UNIT_SIZE_64].nFree;
HI_U32 u32Free128 = g_struMemBlock[UNIT_SIZE_128].nFree;
HI_U32 u32Free1024 = g_struMemBlock[UNIT_SIZE_1024].nFree;
#endif
#ifndef CONFIG_TDE_STR_DISABLE
PROC_PRINT(page, "--------- Hisilicon TDE Memory Pool Info ---------\n");
#if HI_TDE_MEMCOUNT_SUPPORT
PROC_PRINT(page, " Type Total MaxUsed\n");
PROC_PRINT(page, "[Unit 64 ] %8u %8u\n", HI_TDE_UNIT64_NUM, u32MaxUsed64);
PROC_PRINT(page, "[Unit 128 ] %8u %8u\n", HI_TDE_UNIT128_NUM, u32MaxUsed128);
PROC_PRINT(page, "[Unit 1024] %8u %8u\n", HI_TDE_UNIT1024_NUM, u32MaxUsed1024);
PROC_PRINT(page, "[Total ] %8uK %8uK\n", TDE_MEMPOOL_SIZE/1024, (64 * u32MaxUsed64 + 128 * u32MaxUsed128 + 1024 * u32MaxUsed1024)/1024);
#else
PROC_PRINT(page, " Type Total Used\n");
PROC_PRINT(page, "[Unit 64 ] %8u %8u\n", HI_TDE_UNIT64_NUM, HI_TDE_UNIT64_NUM - u32Free64);
PROC_PRINT(page, "[Unit 128 ] %8u %8u\n", HI_TDE_UNIT128_NUM, HI_TDE_UNIT128_NUM - u32Free128);
PROC_PRINT(page, "[Unit 1024] %8u %8u\n", HI_TDE_UNIT1024_NUM, HI_TDE_UNIT1024_NUM - u32Free1024);
PROC_PRINT(page, "[Total ] %8uK %8uK\n", TDE_MEMPOOL_SIZE/1024, (TDE_MEMPOOL_SIZE - (64 * u32Free64 + 128 * u32Free128 + 1024 * u32Free1024))/1024);
#endif
#endif
return page;
}
static HI_S32 AI_ShowChnProc(struct seq_file* p,HI_U32 u32Chn)
{
HI_S32 Ret;
HI_U32 u32BufSizeUsed, u32BufPerCentUsed;
AIAO_PORT_ID_E enPort;
AIAO_PORT_STAUTS_S pstPortStatus;
AI_CHANNEL_STATE_S *state = HI_NULL;
state = g_pstGlobalAIRS.pstAI_ATTR_S[u32Chn];
enPort = state->enPort;
Ret = HAL_AIAO_P_GetStatus(enPort, &pstPortStatus);
if(*(pstPortStatus.stCircBuf.pu32Write) >= *(pstPortStatus.stCircBuf.pu32Read))
{
u32BufSizeUsed = *(pstPortStatus.stCircBuf.pu32Write) - *(pstPortStatus.stCircBuf.pu32Read);
}
else
{
u32BufSizeUsed = pstPortStatus.stCircBuf.u32Lenght - (*(pstPortStatus.stCircBuf.pu32Read) - *(pstPortStatus.stCircBuf.pu32Write));
}
u32BufPerCentUsed = u32BufSizeUsed*100/pstPortStatus.stCircBuf.u32Lenght;
PROC_PRINT( p,
"\n--------------------- AI[%d] Status ---------------------\n",
u32Chn);
PROC_PRINT(p,
"Status :%s\n",
(HI_CHAR*)((AIAO_PORT_STATUS_START == pstPortStatus.enStatus) ? "start" : ((AIAO_PORT_STATUS_STOP == pstPortStatus.enStatus) ? "stop" : "stopping")));
PROC_PRINT(p,
"AiPort :%s\n",
(HI_CHAR*)((AIAO_PORT_RX0 == enPort) ? "I2S0" : ((AIAO_PORT_RX1 == enPort) ? "I2S1" : "UNKOWN")));
PROC_PRINT(p,
"SampleRate :%d\n",
state->stSndPortAttr.enSampleRate);
PROC_PRINT(p,
"PcmFrameMaxNum :%d\n",
state->stSndPortAttr.u32PcmFrameMaxNum);
PROC_PRINT(p,
"PcmSamplesPerFrame :%d\n\n",
state->stSndPortAttr.u32PcmSamplesPerFrame);
PROC_PRINT(p,
"DmaCnt :%d\n",
pstPortStatus.stProcStatus.uDMACnt);
PROC_PRINT(p,
"BufFullCnt :%d\n",
pstPortStatus.stProcStatus.uBufFullCnt);
PROC_PRINT(p,
"FiFoFullCnt :%d\n",
pstPortStatus.stProcStatus.uInfFiFoFullCnt);
PROC_PRINT(p,
"FrameBuf(Total/Use/Percent)(Bytes) :%d/%d/%d%%\n",
pstPortStatus.stBuf.u32BUFF_SIZE, u32BufSizeUsed, u32BufPerCentUsed);
PROC_PRINT(p,
"AcquireFrame(Try/OK) :%d/%d\n",
state->stAiProc.u32AqcTryCnt, state->stAiProc.u32AqcCnt);
PROC_PRINT(p,
"ReleaseFrame(Try/OK) :%d/%d\n\n",
state->stAiProc.u32RelTryCnt, state->stAiProc.u32RelCnt);
return HI_SUCCESS;
}
