bool_t AddSubMenuitem(struct menu_item * pParent, struct menu_item *pNewmenuitem, bool_t head)
{
bool_t result=false;
struct tagRscNode *temp_node;
//check if any sub menuitem named this
if(NULL!=SearchSubMenuitemByName(pParent,pNewmenuitem->name))
{
printf("There has been a sub menuitem named this!\n");
return result;
}
if (head)
{
temp_node= Rsc_AddHeadSon((struct tagRscNode *)pParent, (struct tagRscNode *)pNewmenuitem, \
sizeof(struct menu_item),RSCTYPE_USER,pNewmenuitem->name);
}
else
{
temp_node= Rsc_AddSon((struct tagRscNode *)pParent, (struct tagRscNode *)pNewmenuitem, \
sizeof(struct menu_item),RSCTYPE_USER,pNewmenuitem->name);
}
if(temp_node!=NULL)
result=true;
return result;
}
//----安装输入设备-------------------------------------------------------------
//功能: 把输入设备登记到资源结点中
//参数: device_name，目标设备的资源名
//返回: 输入设备ID,-1表示失败
//-----------------------------------------------------------------------------
s32 Stddev_InstallDevice(char *device_name,enum _STDIN_INPUT_TYPE_ stdin_type,
void *myprivate)
{
struct tagStdinDeviceRsc *djy_stdin;
if(Rsc_SearchSon(&s_ptStdinDeviceRscTree->stdin_device_node,device_name))
{
return -1;
}
else
{
djy_stdin = Mb_Malloc(g_ptStdinDevicePool,0);
if(djy_stdin != NULL)
{
Rsc_AddSon(&s_ptStdinDeviceRscTree->stdin_device_node,
&djy_stdin->stdin_device_node,sizeof(struct tagStdinDeviceRsc),
RSC_STDIN_OUT,device_name);
djy_stdin->input_type = stdin_type;
djy_stdin->stdin_private = (ptu32_t)myprivate;
djy_stdin->input_counter = 0;
djy_stdin->FocusMsgQ = tg_pDefaultFocusMsgQ;
g_s32NextId += 1;
djy_stdin->device_id = g_s32NextId;
return djy_stdin->device_id;
}
else
{
Djy_SaveLastError(EN_MEM_TRIED);
printf("内存不足\n\r");
return -1;
}
}
}
// =============================================================================
// 功能：将调用者提供的新增器件结点挂接到SPI总线结点上,并初始化器件所对应的参数配置寄
// 存器,调用者提供tagSPI_Device控制块
// 参数：BusName,新增子器件挂接的总线名称
// DevName,器件名称
// cs,该器件所属的片选序号
// charlen,器件的字符长度，比特位数
// mode,配置从器件模式,CHPA和CPOL组合成成的模式
// freq,SPI总线的时钟频率，单位Hz
// NewDev,新增器件指针
// autocs,新增加设备是否自动片选
// 返回：控制块结点指针，添加失败时返回NULL
// =============================================================================
struct tagSPI_Device *SPI_DevAdd_s(char *BusName, char *DevName,
struct tagSPI_Device *NewDev)
{
struct tagSPI_CB *SPI;
tagSpiConfig spicfg;
//查询是否该总线存在
SPI = SPI_BusFind(BusName);
if((NULL == SPI) || (NULL == NewDev))
return NULL;
//避免建立同名的SPI器件
if(NULL != Rsc_SearchSon(&SPI->SPI_BusNode,DevName))
return NULL;
Rsc_AddSon(&SPI->SPI_BusNode,&NewDev->DevNode,
sizeof(struct tagSPI_Device),RSC_SPI_DEVICE,DevName);
spicfg.CharLen = NewDev->CharLen;
spicfg.Mode = NewDev->Mode;
spicfg.Freq = NewDev->Freq;
spicfg.ShiftDir= NewDev->ShiftDir;
if(true == SPI->MultiCsReg)
{
SPI_BusCtrl(NewDev,CN_SPI_CS_CONFIG,(ptu32_t)NewDev->Cs,(ptu32_t)&spicfg);
}
printk("SPI Device %s Added Succeeded!\r\n",DevName);
return (struct tagSPI_Device *)&NewDev->DevNode;
}
// =============================================================================
// 功能：新增SPI总线结点到SPI总线类型结点,并初始化tagSPI_CB控制块结构体
// 参数：NewSPIParam,新增总线参数，参数说明详细请参照tagSPI_Param结构体
// 返回：返回建立的资源结点指针，失败时返回NULL
// =============================================================================
struct tagSPI_CB *SPI_BusAdd(struct tagSPI_Param *NewSPIParam)
{
struct tagSPI_CB *NewSPI;
if(NULL == NewSPIParam)
goto exit_from_param;
//避免重复建立同名的SPI总线
if(NULL != Rsc_SearchSon(&s_SPIBusType,NewSPIParam->BusName))
goto exit_from_readd;
NewSPI = (struct tagSPI_CB *)M_Malloc(sizeof(struct tagSPI_CB),0);
if(NewSPI == NULL)
goto exit_from_malloc;
//将总线结点挂接到总线类型结点的子结点
Rsc_AddSon(&s_SPIBusType,&NewSPI->SPI_BusNode,
sizeof(struct tagSPI_CB),RSC_SPIBUS,NewSPIParam->BusName);
if(&NewSPI->SPI_BusNode == NULL)
goto exit_from_add_node;
//创建总线信号量和阻塞信号量
NewSPI->SPI_BusSemp= Lock_SempCreate(1,1,CN_SEMP_BLOCK_FIFO,"spi bus semp");
if(NewSPI->SPI_BusSemp== NULL)
goto exit_from_spi_bus_semp;
NewSPI->SPI_BlockSemp = Lock_SempCreate(1,0,CN_SEMP_BLOCK_FIFO,"spi block semp");
if(NewSPI->SPI_BlockSemp== NULL)
goto exit_from_spi_buf_semp;
//tagSPI_CB控制块初始化
NewSPI->SpecificFlag = NewSPIParam->SpecificFlag;
NewSPI->pTransferTxRx = NewSPIParam->pTransferTxRx;
NewSPI->pCsActive = NewSPIParam->pCsActive;
NewSPI->pCsInActive = NewSPIParam->pCsInActive;
NewSPI->pBusCtrl = NewSPIParam->pBusCtrl;
NewSPI->pTransferPoll = NewSPIParam->pTransferPoll;
//缓冲区初始化
NewSPI->SPI_Buf.pBuf = NewSPIParam->SPIBuf;
NewSPI->SPI_Buf.MaxLen = NewSPIParam->SPIBufLen;
NewSPI->SPI_Buf.Offset = 0;
printk("%s Added Succeeded!\r\n",NewSPIParam->BusName);
return NewSPI;
exit_from_spi_buf_semp:
Lock_SempDelete(NewSPI->SPI_BusSemp);
exit_from_spi_bus_semp:
Rsc_DelNode(&NewSPI->SPI_BusNode);
exit_from_add_node:
free(NewSPI);
exit_from_malloc:
exit_from_readd:
exit_from_param:
return NULL;
}
// =============================================================================
// 功能：在SPI总线结点上增加器件，即总线上挂接的器件，并初始化器件所对应的参数配置寄
// 存器,该器件属于总线结点的子结点
// 参数：BusName,新增子器件挂接的总线名称
// DevName,器件名称
// cs,该器件所属的片选序号
// charlen,器件的字符长度，比特位数
// mode,配置从器件模式,CHPA和CPOL组合成成的模式
// freq,SPI总线的时钟频率，单位Hz
// autocs,新增加设备是否自动片选
// 返回：控制块结点指针，添加失败时返回NULL
// =============================================================================
struct tagSPI_Device *SPI_DevAdd(char *BusName ,char *DevName,u8 cs,u8 charlen,
u8 mode,u8 shiftdir,u32 freq,u8 autocs)
{
struct tagSPI_CB *SPI;
struct tagSPI_Device *NewDev;
tagSpiConfig spicfg;
//查询是否该总线存在
SPI = SPI_BusFind(BusName);
if(NULL == SPI)
return NULL;
//避免建立同名的SPI器件
if(NULL != Rsc_SearchSon(&SPI->SPI_BusNode,DevName))
return NULL;
//为新的器件结点动态分配内存
NewDev = (struct tagSPI_Device *)M_Malloc(sizeof(struct tagSPI_Device),0);
if(NULL == NewDev)
return NULL;
//为新结点初始化
NewDev->Cs = cs;
Rsc_AddSon(&SPI->SPI_BusNode,&NewDev->DevNode,
sizeof(struct tagSPI_Device),RSC_SPI_DEVICE,DevName);
if(NULL == &NewDev->DevNode)
{
free(NewDev);
return NULL;
}
NewDev->CharLen = charlen;
NewDev->Cs = cs;
NewDev->AutoCs = autocs;
NewDev->Mode = mode;
NewDev->Freq = freq;
NewDev->ShiftDir = shiftdir;
spicfg.CharLen = charlen;
spicfg.Mode = mode;
spicfg.Freq = freq;
spicfg.ShiftDir= shiftdir;
//如果SPI控制器有多套CS寄存器，则配置它，否则不作配置
if(true == SPI->MultiCsReg)
{
SPI_BusCtrl(NewDev,CN_SPI_CS_CONFIG,(ptu32_t)cs,(ptu32_t)&spicfg);
}
printk("SPI Device %s Added Succeeded!\r\n",DevName);
return NewDev;
}
// =============================================================================
// 功能：在DjyBus总线树结点上增加新的总线类型结点，新增总线类型结点是DjyBus的子结点,
// 该函数带r，表示由调用者提供内存，即NewBusType由用户定义
// 参数：NewBusTypeName,创建总线类型名称
// NewBusType,创建总线类型结点，用记定义
// 返回：返回建立的资源结点指针，失败时返回NULL
// =============================================================================
struct tagRscNode * DjyBus_BusTypeAdd_s(char* NewBusTypeName,
struct tagRscNode * NewBusType)
{
if((NewBusType == NULL) && (NewBusTypeName == NULL))
return NULL;
//避免重复创建同名的总线类型
if(NULL != Rsc_SearchSon(&tg_djybus_root,NewBusTypeName))
return NULL;
Rsc_AddSon(&tg_djybus_root,NewBusType,
sizeof(struct tagRscNode),RSC_RSCNODE,NewBusTypeName);
return NewBusType;
}
// =============================================================================
// 功能：在DjyBus总线树结点上增加新的总线类型结点，新增总线类型结点是DjyBus的子结点,
// 使用内存池分配的方式分配内存
// 参数：NewBusTypeName,总线类型名称
// 返回：返回建立的资源结点指针，失败时返回NULL
// =============================================================================
struct tagRscNode * DjyBus_BusTypeAdd (char* NewBusTypeName)
{
struct tagRscNode * NewBusType;
NewBusType = (struct tagRscNode *)M_Malloc(sizeof(struct tagRscNode),0);
if(NewBusType == NULL)
return NULL;
//避免重复创建同名的总线类型
if(NULL != Rsc_SearchSon(&tg_djybus_root,NewBusTypeName))
return NULL;
Rsc_AddSon(&tg_djybus_root,NewBusType,
sizeof(struct tagRscNode),RSC_RSCNODE,NewBusTypeName);
return NewBusType;
}
// =============================================================================
// 函数功能：TransProto_GetTypeNode
// 根据指定的family和type找到指定的type资源节点
// 输入参数：family（域,AF_INET等）
// type,(类型，SOCK_DGRAM等)
// create,true则找不到对应的节点就建立，否则不建立
// 输出参数：无
// 返回值 ：返回找到的或者建立的type节点，如果不存在
// 说明 ：如果没有对应的FAMILY和TYPE则会创建对应的FAMILY或者TYPE
// =============================================================================
tagNetRscNode *__TPL_GetTypeNode(int family, int type, bool_t needcreate)
{
bool_t findit;
tagNetRscNode *result;
tagNetRscNode *temp;
tagNetRscNode *headson;
if(NULL != pgNetRscNodeTree)
{
findit = false;
//先找family
headson = (tagNetRscNode *)Rsc_GetSon(pgNetRscNodeTree);
if(NULL == headson) //没有需要建立
{
findit = false;
}
else
{
temp = headson;
do{
if(temp->number == family)
{
findit = true;
result = temp;
temp = headson;
}
else
{
temp = (tagNetRscNode *)Rsc_GetNext(&temp->node);
}
}while(headson != temp);
}
if(true == findit)
{
//找到了family节点，则在该family节点上查找type节点
findit = false;
headson = (tagNetRscNode *)Rsc_GetSon(&result->node);
if(NULL == headson)
{
findit = false;
}
else
{
temp = headson;
do{
if(type == temp->number)
{
result = temp;
findit = true;
temp = headson;
}
else
{
temp = (tagNetRscNode *)Rsc_GetNext(&temp->node);
}
}while(temp != headson);
}
if(true != findit)//没有找到type节点
{
if(true == needcreate)
{
temp = result;
result = M_Malloc(sizeof(tagNetRscNode), CN_TIMEOUT_FOREVER);
if(NULL != result)
{
result->number = type;
Rsc_AddSon(&temp->node, &result->node,\
sizeof(tagNetRscNode),RSC_RSCNODE,NULL);
}
}
else
{
result = NULL;
}
}
}
else
{
//没有找到family节点，看是否需要建立
if(true == needcreate)
{
result = M_Malloc(sizeof(tagNetRscNode), CN_TIMEOUT_FOREVER);
if(result != NULL)
{
result->number = family;
Rsc_AddSon(pgNetRscNodeTree, &result->node, \
sizeof(tagNetRscNode),RSC_RSCNODE,NULL);
//建立对应的type节点
temp = result;
result = M_Malloc(sizeof(tagNetRscNode), CN_TIMEOUT_FOREVER);
if(NULL != result)
{
result->number = type;
Rsc_AddSon(&temp->node, &result->node, \
sizeof(tagNetRscNode),RSC_RSCNODE,NULL);
}
}
}
else
{
result = NULL;
}
}
}
return result;
}
// =============================================================================
// 函数功能：TPL_RegisterProto
// 添加一个具体的传输层协议
// 输入参数：family（域,AF_INET等）
// type,(类型，SOCK_DGRAM等)
// protocal,（协议号）
// proto,具体的传输层协议
// 输出参数：
// 返回值 ：注册成功的资源树节点，NULL表示注册不成功（空间不足）
// 说明 ：如果没有对应的FAMILY和TYPE则会创建对应的FAMILY或者TYPE
// =============================================================================
tagTplProtoRscNode* TPL_RegisterProto(int family, int type, int protocal,\
tagTlayerProto *proto)
{
tagTplProtoRscNode *result = NULL;
tagNetRscNode *typenode = NULL;
tagTplProtoRscNode *headson = NULL;
tagTplProtoRscNode *temp = NULL;
if((NULL != proto)&&(NULL != pgNetRscNodeTree))
{
if(true == Lock_MutexPend(pgNetRscNodeSync, CN_TIMEOUT_FOREVER))
{
typenode = __TPL_GetTypeNode(family, type, true);
if(NULL != typenode) //找到或者创建成功了
{
headson = (tagTplProtoRscNode *)Rsc_GetSon(&typenode->node);
if(NULL == headson)
{
//现在的type下还没有节点，则完全可以建立新的
result = M_Malloc(sizeof(tagTplProtoRscNode), CN_TIMEOUT_FOREVER);
if(NULL != result)
{
result->protocal = protocal;
result->proto = *proto;
Rsc_AddSon(&typenode->node, &result->node,\
sizeof(tagTplProtoRscNode),RSC_RSCNODE,NULL);
}
}
else
{
//看看是否有重复的，有重复的不必再添加，否则要添加
temp = headson;
do{
if(temp->protocal == protocal)
{
result = temp;
temp = headson;
}
else
{
temp = (tagTplProtoRscNode *)Rsc_GetNext(&temp->node);
}
}while(temp != headson);
if(result != NULL) //已经有存在的
{
result = NULL;
}
else
{
//没有protocal的节点，建立
result = M_Malloc(sizeof(tagTplProtoRscNode), CN_TIMEOUT_FOREVER);
if(NULL != result)
{
result->protocal = protocal;
result->proto = *proto;
Rsc_AddSon(&typenode->node, &result->node,\
sizeof(tagTplProtoRscNode),RSC_RSCNODE,NULL);
}
}
}
}
Lock_MutexPost(pgNetRscNodeSync);
}
}
return result;
}
