/*********************************************************************************************************
** 函数名称: _rngBufPut
** 功能描述: 向一个 VxWorks 兼容 ring buffer 缓冲区写入最多 iMaxBytes 个字节
** 输 入 :
** vxringid 缓冲区控制块地址
** pcBuffer 读出数据存放位置
** iMaxBytes 读出最多的字节数
** 输 出 : 实际读出的字节数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT _rngBufPut (VX_RING_ID vxringid,
PCHAR pcBuffer,
INT iNBytes)
{
REGISTER INT iBytesPut = 0;
REGISTER INT iFromBuf = vxringid->VXRING_iFromBuf;
REGISTER INT iBytes2;
REGISTER INT iRngTemp = 0;
if (iFromBuf > vxringid->VXRING_iToBuf) {
/* pFromBuf is ahead of pToBuf. We can fill up to two bytes
* before it */
iBytesPut = __MIN(iNBytes, iFromBuf - vxringid->VXRING_iToBuf - 1);
lib_memcpy(&vxringid->VXRING_pcBuf[vxringid->VXRING_iToBuf], pcBuffer, iBytesPut);
vxringid->VXRING_iToBuf += iBytesPut;
} else if (iFromBuf == 0) {
/* pFromBuf is at the beginning of the buffer. We can fill till
* the next-to-last element */
iBytesPut = __MIN(iNBytes, vxringid->VXRING_iBufByteSize - vxringid->VXRING_iToBuf - 1);
lib_memcpy(&vxringid->VXRING_pcBuf[vxringid->VXRING_iToBuf], pcBuffer, iBytesPut);
vxringid->VXRING_iToBuf += iBytesPut;
} else {
/* pFromBuf has wrapped around, and its not 0, so we can fill
* at least to the end of the ring buffer. Do so, then see if
* we need to wrap and put more at the beginning of the buffer. */
iBytesPut = __MIN(iNBytes, vxringid->VXRING_iBufByteSize - vxringid->VXRING_iToBuf);
lib_memcpy(&vxringid->VXRING_pcBuf[vxringid->VXRING_iToBuf], pcBuffer, iBytesPut);
iRngTemp = vxringid->VXRING_iToBuf + iBytesPut;
if (iRngTemp == vxringid->VXRING_iBufByteSize) {
/* We need to wrap, and perhaps put some more chars */
iBytes2 = __MIN(iNBytes - iBytesPut, iFromBuf - 1);
lib_memcpy(vxringid->VXRING_pcBuf, pcBuffer + iBytesPut, iBytes2);
vxringid->VXRING_iToBuf = iBytes2;
iBytesPut += iBytes2;
} else {
vxringid->VXRING_iToBuf = iRngTemp;
}
}
return (iBytesPut);
}
/*********************************************************************************************************
** 函数名称: archDbgBpInsert
** 功能描述: 插入一个断点.
** 输 入 : ulAddr 断点地址
** stSize 断点大小
** pulIns 返回的之前的指令
** bLocal 是否仅更新当前 CPU I-CACHE
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID archDbgBpInsert (addr_t ulAddr, size_t stSize, ULONG *pulIns, BOOL bLocal)
{
ULONG ulIns = ARM_BREAKPOINT_INS;
lib_memcpy((PCHAR)pulIns, (PCHAR)ulAddr, stSize); /* memcpy 避免 arm 对齐问题 */
lib_memcpy((PCHAR)ulAddr, (PCHAR)&ulIns, stSize);
#if LW_CFG_CACHE_EN > 0
if (bLocal) {
API_CacheLocalTextUpdate((PVOID)ulAddr, stSize);
} else {
API_CacheTextUpdate((PVOID)ulAddr, stSize);
}
#endif /* LW_CFG_CACHE_EN > 0 */
}
/*********************************************************************************************************
** 函数名称: __tshellCharBackspace
** 功能描述: shell 收到退格键.
** 输 入 : iFd 文件描述符
** cChar 键值
** psicContext 当前输入上下文
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __tshellCharBackspace (INT iFd, CHAR cChar, __PSHELL_INPUT_CTX psicContext)
{
CHAR cBsCharList[3];
if (CTX_CURSOR == 0) {
return;
}
if (CTX_CURSOR == CTX_TOTAL) {
cBsCharList[0] = cChar;
cBsCharList[1] = ' ';
cBsCharList[2] = cChar;
write(iFd, cBsCharList, 3);
CTX_CURSOR--;
CTX_TOTAL--;
} else if (CTX_CURSOR < CTX_TOTAL) {
write(iFd, &cChar, 1);
lib_memcpy(&CTX_BUFFER[CTX_CURSOR - 1],
&CTX_BUFFER[CTX_CURSOR],
CTX_TOTAL - CTX_CURSOR);
CTX_BUFFER[CTX_TOTAL - 1] = ' ';
CTX_CURSOR--;
write(iFd, &CTX_BUFFER[CTX_CURSOR], CTX_TOTAL - CTX_CURSOR);
__tshellTtyCursorMoveLeft(iFd, CTX_TOTAL - CTX_CURSOR);
CTX_TOTAL--;
}
}
/*********************************************************************************************************
** 函数名称: iw_handler_get_private
** 功能描述: 执行私有控制句柄
** 输 入 : dev 网络接口
** 输 出 : OK or ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
int iw_handler_get_private (struct netif *dev,
struct iw_request_info *info,
union iwreq_data *wrqu,
char *extra)
{
struct iw_handler_def *handlers = (struct iw_handler_def *)dev->wireless_handlers;
if (!handlers) {
return (-EOPNOTSUPP);
}
/* Check if the driver has something to export */
if ((handlers->num_private_args == 0) ||
(handlers->private_args == NULL)) {
return (-EOPNOTSUPP);
}
/* Check if there is enough buffer up there */
if (wrqu->data.length < handlers->num_private_args) {
/* User space can't know in advance how large the buffer
* needs to be. Give it a hint, so that we can support
* any size buffer we want somewhat efficiently... */
wrqu->data.length = handlers->num_private_args;
return (-E2BIG);
}
/* Set the number of available ioctls. */
wrqu->data.length = handlers->num_private_args;
/* Copy structure to the user buffer. */
lib_memcpy(extra, handlers->private_args,
sizeof(struct iw_priv_args) * wrqu->data.length);
return (0);
}
/*********************************************************************************************************
** 函数名称: __procFsYaffsRead
** 功能描述: procfs 读一个 yaffs 文件
** 输 入 : p_pfsn 节点控制块
** pcBuffer 缓冲区
** stMaxBytes 缓冲区大小
** oft 文件指针
** 输 出 : 实际读取的数目
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t __procFsYaffsRead (PLW_PROCFS_NODE p_pfsn,
PCHAR pcBuffer,
size_t stMaxBytes,
off_t oft)
{
REGISTER PCHAR pcFileBuffer;
size_t stRealSize; /* 实际的文件内容大小 */
size_t stCopeBytes;
/*
* 程序运行到这里, 文件缓冲一定已经分配了预置的内存大小.
*/
pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn);
if (pcFileBuffer == LW_NULL) {
_ErrorHandle(ENOMEM);
return (0);
}
stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn);
if (stRealSize == 0) { /* 需要生成文件 */
/*
* 在这里生成文件的内容
*/
INT i = 0;
PCHAR pcVolName;
struct yaffs_dev *pyaffsDev; /* yaffs 挂载设备 */
do {
pcVolName = yaffs_getdevname(i, &i);
if (pcVolName == LW_NULL) {
break; /* 没有其他的卷 */
}
pyaffsDev = (struct yaffs_dev *)yaffs_getdev(pcVolName);
if (pyaffsDev == LW_NULL) {
break; /* 无法查询到设备节点 */
}
/*
* (__PROCFS_BUFFER_SIZE_YAFFS - stRealSize) 为文件缓冲区剩余的空间大小
*/
stRealSize = __procFsYaffsPrint(pyaffsDev,
pcVolName,
pcFileBuffer,
__PROCFS_BUFFER_SIZE_YAFFS,
stRealSize);
} while (i != PX_ERROR);
API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize); /* 回写文件实际大小 */
}
if (oft >= stRealSize) {
_ErrorHandle(ENOSPC);
return (0);
}
stCopeBytes = __MIN(stMaxBytes, (size_t)(stRealSize - oft)); /* 计算实际拷贝的字节数 */
lib_memcpy(pcBuffer, (CPVOID)(pcFileBuffer + oft), (UINT)stCopeBytes);
return ((ssize_t)stCopeBytes);
}
/*********************************************************************************************************
** 函数名称: __ram_write
** 功能描述: ramfs 写入文件内容
** 输 入 : pramn 文件节点
** pvBuffer 缓冲区
** stNBytes 需要读取的大小
** stOft 偏移量
** 输 出 : 读取的字节数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
ssize_t __ram_write (PRAM_NODE pramn, CPVOID pvBuffer, size_t stNBytes, size_t stOft)
{
PRAM_BUFFER pramb;
UINT8 *pucDest = (UINT8 *)pvBuffer;
size_t stEnd = stOft + stNBytes;
size_t stWrite = 0;
size_t stStart;
ULONG ulNBlk;
ulNBlk = (ULONG)(stEnd / __RAM_BDATASIZE);
if (stEnd % __RAM_BDATASIZE) {
ulNBlk++;
}
if (__ram_automem(pramn, ulNBlk, stOft, stNBytes)) {
return (0); /* 没有内存空间可供分配 */
}
pramb = __ram_getbuf(pramn, stOft, &stStart);
while (pramb && stNBytes) {
size_t stBufSize = (__RAM_BDATASIZE - stStart);
if (stBufSize >= stNBytes) {
lib_memcpy(&pramb->RAMB_ucData[stStart], pucDest, stNBytes);
stWrite += stNBytes;
break;
} else {
lib_memcpy(&pramb->RAMB_ucData[stStart], pucDest, stBufSize);
pucDest += stBufSize;
stWrite += stBufSize;
stNBytes -= stBufSize;
stStart = 0; /* 下次从 0 开始 */
}
pramb = __ram_getbuf_next(pramn);
}
if (pramn->RAMN_stSize < (stOft + stWrite)) {
pramn->RAMN_stSize = (stOft + stWrite);
if (pramn->RAMN_stVSize < pramn->RAMN_stSize) {
pramn->RAMN_stVSize = pramn->RAMN_stSize;
}
}
return ((ssize_t)stWrite);
}
/*********************************************************************************************************
** 函数名称: _rngBufGet
** 功能描述: 从一个 VxWorks 兼容 ring buffer 缓冲区读出最多 iMaxBytes 个字节
** 输 入 :
** vxringid 缓冲区控制块地址
** pcBuffer 读出数据存放位置
** iMaxBytes 读出最多的字节数
** 输 出 : 实际读出的字节数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT _rngBufGet (VX_RING_ID vxringid,
PCHAR pcBuffer,
INT iMaxBytes)
{
REGISTER INT iBytesGot = 0;
REGISTER INT iToBuf = vxringid->VXRING_iToBuf;
REGISTER INT iBytes2;
REGISTER INT iRngTemp = 0;
if (iToBuf >= vxringid->VXRING_iFromBuf) {
/* pToBuf has not wrapped around */
iBytesGot = __MIN(iMaxBytes, iToBuf - vxringid->VXRING_iFromBuf);
lib_memcpy(pcBuffer, &vxringid->VXRING_pcBuf[vxringid->VXRING_iFromBuf], iBytesGot);
vxringid->VXRING_iFromBuf += iBytesGot;
} else {
/* pToBuf has wrapped around. Grab chars up to the end of the
* buffer, then wrap around if we need to. */
iBytesGot = __MIN(iMaxBytes, vxringid->VXRING_iBufByteSize - vxringid->VXRING_iFromBuf);
lib_memcpy(pcBuffer, &vxringid->VXRING_pcBuf[vxringid->VXRING_iFromBuf], iBytesGot);
iRngTemp = vxringid->VXRING_iFromBuf + iBytesGot;
/* If pFromBuf is equal to bufSize, we've read the entire buffer,
* and need to wrap now. If bytesgot < maxbytes, copy some more chars
* in now. */
if (iRngTemp == vxringid->VXRING_iBufByteSize) {
iBytes2 = __MIN(iMaxBytes - iBytesGot, iToBuf);
lib_memcpy(pcBuffer + iBytesGot, vxringid->VXRING_pcBuf, iBytes2);
vxringid->VXRING_iFromBuf = iBytes2;
iBytesGot += iBytes2;
} else {
vxringid->VXRING_iFromBuf = iRngTemp;
}
}
return (iBytesGot);
}
HRESULT InStreamRead(void *aData, UINT32 aSize, UINT32* aProcessedSize) {
if (aSize > in_stream.remainingBytes)
aSize = in_stream.remainingBytes;
*aProcessedSize = aSize;
lib_memcpy(aData, in_stream.data, aSize); // brcm modification
in_stream.remainingBytes -= aSize;
in_stream.data += aSize;
return S_OK;
}
/*********************************************************************************************************
** 函数名称: __ram_read
** 功能描述: ramfs 读取文件内容
** 输 入 : pramn 文件节点
** pvBuffer 缓冲区
** stSize 缓冲区大小
** stOft 偏移量
** 输 出 : 读取的字节数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
ssize_t __ram_read (PRAM_NODE pramn, PVOID pvBuffer, size_t stSize, size_t stOft)
{
PRAM_BUFFER pramb;
UINT8 *pucDest = (UINT8 *)pvBuffer;
size_t stDataLeft;
size_t stNBytes;
size_t stRead = 0;
size_t stStart;
if (pramn->RAMN_stVSize <= stOft) { /* 已经到文件末尾 */
return (0);
}
stDataLeft = pramn->RAMN_stVSize - stOft; /* 计算剩余数据量 */
stNBytes = __MIN(stDataLeft, stSize);
pramb = __ram_getbuf(pramn, stOft, &stStart);
do {
if (pramb == LW_NULL) { /* 需要填充 0 (POSIX) */
lib_bzero(pucDest, stNBytes);
stRead += stNBytes;
break;
} else {
size_t stBufSize = (__RAM_BDATASIZE - stStart);
if (stBufSize >= stNBytes) {
lib_memcpy(pucDest, &pramb->RAMB_ucData[stStart], stNBytes);
stRead += stNBytes;
break;
} else {
lib_memcpy(pucDest, &pramb->RAMB_ucData[stStart], stBufSize);
pucDest += stBufSize;
stRead += stBufSize;
stNBytes -= stBufSize;
stStart = 0; /* 下次拷贝从头开始 */
}
}
pramb = __ram_getbuf_next(pramn);
} while (stNBytes);
return ((ssize_t)stRead);
}
/*
* Transform string s2 to string s1 using the current locale so that
* strcmp of transformed strings yields the same result as strcoll.
* Since Bionic really does not support locales, we assume we always use
* the C locale.
*
* This function is provided to make libstdc++-v3 usable.
*/
size_t
lib_strxfrm(char *s1, const char *s2, size_t n)
{
size_t len = lib_strlen(s2) + 1;
if (len < n)
n = len;
lib_memcpy(s1, s2, n);
return len;
}
/*********************************************************************************************************
** 函数名称: __procFssupRootfsRead
** 功能描述: procfs 读一个根文件系统信息 proc 文件
** 输 入 : p_pfsn 节点控制块
** pcBuffer 缓冲区
** stMaxBytes 缓冲区大小
** oft 文件指针
** 输 出 : 实际读取的数目
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t __procFssupStatRead (PLW_PROCFS_NODE p_pfsn,
PCHAR pcBuffer,
size_t stMaxBytes,
off_t oft)
{
REGISTER PCHAR pcFileBuffer;
size_t stRealSize; /* 实际的文件内容大小 */
size_t stCopeBytes;
/*
* 程序运行到这里, 文件缓冲一定已经分配了预置的内存大小(创建节点时预置大小为 64 字节).
*/
pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn);
if (pcFileBuffer == LW_NULL) {
_ErrorHandle(ENOMEM);
return (0);
}
stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn);
if (stRealSize == 0) { /* 需要生成文件 */
struct statfs statfsBuf;
PCHAR pcFs;
if (p_pfsn->PFSN_p_pfsnoFuncs == &_G_pfsnoFssupRootfsFuncs) {
pcFs = "/";
} else if (p_pfsn->PFSN_p_pfsnoFuncs == &_G_pfsnoFssupProcfsFuncs) {
pcFs = "/proc";
} else {
pcFs = "/"; /* 不可能运行到这里 */
}
if (statfs(pcFs, &statfsBuf) < ERROR_NONE) {
stRealSize = bnprintf(pcFileBuffer,
__PROCFS_BUFFER_SIZE_ROOTFS, 0,
"get root file system status error.");
} else {
stRealSize = bnprintf(pcFileBuffer,
__PROCFS_BUFFER_SIZE_ROOTFS, 0,
"memory used : %ld bytes\n"
"total files : %ld\n",
(ULONG)(statfsBuf.f_bsize * statfsBuf.f_blocks),
statfsBuf.f_files);
}
API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize);
}
if (oft >= stRealSize) {
_ErrorHandle(ENOSPC);
return (0);
}
stCopeBytes = __MIN(stMaxBytes, (size_t)(stRealSize - oft)); /* 计算实际拷贝的字节数 */
lib_memcpy(pcBuffer, (CPVOID)(pcFileBuffer + oft), (UINT)stCopeBytes);
return ((ssize_t)stCopeBytes);
}
/*********************************************************************************************************
** 函数名称: archDbgBpRemove
** 功能描述: 删除一个断点.
** 输 入 : ulAddr 断点地址
** stSize 断点大小
** pulIns 返回的之前的指令
** bLocal 是否仅更新当前 CPU I-CACHE
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID archDbgBpRemove (addr_t ulAddr, size_t stSize, ULONG ulIns, BOOL bLocal)
{
lib_memcpy((PCHAR)ulAddr, (PCHAR)&ulIns, stSize);
#if LW_CFG_CACHE_EN > 0
if (bLocal) {
API_CacheLocalTextUpdate((PVOID)ulAddr, stSize);
} else {
API_CacheTextUpdate((PVOID)ulAddr, stSize);
}
#endif /* LW_CFG_CACHE_EN > 0 */
}
/*********************************************************************************************************
** 函数名称: __tshellCharDelete
** 功能描述: shell 收到一个 del 键值.
** 输 入 : iFd 文件描述符
** psicContext 当前输入上下文
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __tshellCharDelete (INT iFd, __PSHELL_INPUT_CTX psicContext)
{
if (CTX_CURSOR < CTX_TOTAL) {
lib_memcpy(&CTX_BUFFER[CTX_CURSOR],
&CTX_BUFFER[CTX_CURSOR + 1],
CTX_TOTAL - CTX_CURSOR);
CTX_BUFFER[CTX_TOTAL - 1] = ' ';
write(iFd, &CTX_BUFFER[CTX_CURSOR], CTX_TOTAL - CTX_CURSOR);
__tshellTtyCursorMoveLeft(iFd, CTX_TOTAL - CTX_CURSOR);
CTX_TOTAL--;
}
}
void lib_dev_set_address(struct SimDevice *dev, unsigned char buffer[6])
{
/* called by ns-3 to synchronize the kernel address with */
/* the simulation address. */
struct sockaddr sa;
sa.sa_family = dev->dev.type;
lib_memcpy(&sa.sa_data, buffer, 6);
dev->dev.netdev_ops->ndo_set_mac_address(&dev->dev, &sa);
/* Note that we don't call dev_set_mac_address (&dev->dev, &sa); */
/* because this function expects to be called from within */
/* the netlink layer so, it expects to hold */
/* the netlink lock during the execution of the associated notifiers */
}
/*********************************************************************************************************
** 函数名称: __procFssupRootfsRead
** 功能描述: procfs 读一个根文件系统支持信息 proc 文件
** 输 入 : p_pfsn 节点控制块
** pcBuffer 缓冲区
** stMaxBytes 缓冲区大小
** oft 文件指针
** 输 出 : 实际读取的数目
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t __procFssupRead (PLW_PROCFS_NODE p_pfsn,
PCHAR pcBuffer,
size_t stMaxBytes,
off_t oft)
{
REGISTER PCHAR pcFileBuffer;
size_t stRealSize; /* 实际的文件内容大小 */
size_t stCopeBytes;
/*
* 程序运行到这里, 文件缓冲一定已经分配了预置的内存大小(创建节点时预置大小为 64 字节).
*/
pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn);
if (pcFileBuffer == LW_NULL) {
_ErrorHandle(ENOMEM);
return (0);
}
stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn);
if (stRealSize == 0) { /* 需要生成文件 */
lib_strcpy(pcFileBuffer, "rootfs procfs ramfs romfs ");
#if LW_CFG_FATFS_EN > 0
lib_strlcat(pcFileBuffer, "vfat ", __PROCFS_BUFFER_SIZE_FSSUP);
#endif /* LW_CFG_FATFS_EN */
#if LW_CFG_NFS_EN > 0
lib_strlcat(pcFileBuffer, "nfs ", __PROCFS_BUFFER_SIZE_FSSUP);
#endif /* LW_CFG_NFS_EN */
#if LW_CFG_YAFFS_EN > 0
lib_strlcat(pcFileBuffer, "yaffs ", __PROCFS_BUFFER_SIZE_FSSUP);
#endif /* LW_CFG_YAFFS_EN */
stRealSize = lib_strlen(pcFileBuffer);
API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize);
}
if (oft >= stRealSize) {
_ErrorHandle(ENOSPC);
return (0);
}
stCopeBytes = __MIN(stMaxBytes, (size_t)(stRealSize - oft)); /* 计算实际拷贝的字节数 */
lib_memcpy(pcBuffer, (CPVOID)(pcFileBuffer + oft), (UINT)stCopeBytes);
return ((ssize_t)stCopeBytes);
}
/*********************************************************************************************************
** 函数名称: API_PciDevAdd
** 功能描述: 增加一个设备
** 输 入 : iBus 总线号
** iDevice 设备号
** iFunction 功能号
** 输 出 : 设备控制句柄
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
PCI_DEV_HANDLE API_PciDevAdd (INT iBus, INT iDevice, INT iFunction)
{
PCI_DEV_HANDLE hDevHandle = LW_NULL;
PCI_HDR phPciHdr;
hDevHandle = API_PciDevHandleGet(iBus, iDevice, iFunction);
if (hDevHandle != LW_NULL) {
return (hDevHandle);
}
lib_bzero(&phPciHdr, sizeof(PCI_HDR));
API_PciGetHeader(iBus, iDevice, iFunction, &phPciHdr);
switch (phPciHdr.PCIH_ucType & PCI_HEADER_TYPE_MASK) {
case PCI_HEADER_TYPE_NORMAL:
hDevHandle = (PCI_DEV_HANDLE)__SHEAP_ZALLOC(sizeof(PCI_DEV_TCB));
if (hDevHandle == LW_NULL) {
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
break;
}
hDevHandle->PDT_iDevBus = iBus;
hDevHandle->PDT_iDevDevice = iDevice;
hDevHandle->PDT_iDevFunction = iFunction;
lib_memcpy(&hDevHandle->PDT_phDevHdr, &phPciHdr, sizeof(PCI_HDR));
__PCI_DEV_LOCK();
_List_Line_Add_Ahead(&hDevHandle->PDT_lineDevNode, &_GplinePciDevHeader);
_GuiPciDevTotalNum += 1;
__PCI_DEV_UNLOCK();
break;
case PCI_HEADER_TYPE_BRIDGE:
case PCI_HEADER_TYPE_CARDBUS:
hDevHandle = LW_NULL;
break;
default:
hDevHandle = LW_NULL;
break;
}
return (hDevHandle);
}
/*********************************************************************************************************
** 函数名称: __rtGetCallback
** 功能描述: 获取路由表接口(在 TCPIP 上下文中执行)
** 输 入 : prte 路由条目
** flag 获取的类型掩码
** msgbuf 缓冲表
** num 缓冲表总数
** piIndex 当前下标
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __rtGetCallback (PLW_RT_ENTRY prte,
u_char flag,
struct route_msg *msgbuf,
size_t num,
int *piIndex)
{
struct netif *pnetif = prte->RTE_pnetif;
u_char ucGetFlag = 0;
if (*piIndex >= num) {
return;
}
if (prte->RTE_uiFlag & LW_RT_FLAG_U) { /* 有效路由 */
ucGetFlag |= ROUTE_RTF_UP;
}
if (prte->RTE_uiFlag & LW_RT_FLAG_H) {
ucGetFlag |= ROUTE_RTF_HOST; /* 主机路由 */
}
if (prte->RTE_uiFlag & LW_RT_FLAG_G) {
ucGetFlag |= ROUTE_RTF_GATEWAY; /* 目的是一个网关的路由 */
}
if ((ucGetFlag & flag) == flag) { /* 满足获取条件 */
msgbuf[*piIndex].rm_flag = ucGetFlag;
msgbuf[*piIndex].rm_metric = 1;
msgbuf[*piIndex].rm_dst.s_addr = prte->RTE_ipaddrDest.addr; /* 目的地址 */
if (pnetif) {
msgbuf[*piIndex].rm_gw.s_addr = pnetif->gw.addr; /* 网关地址 */
msgbuf[*piIndex].rm_mask.s_addr = pnetif->netmask.addr; /* 子网掩码 */
msgbuf[*piIndex].rm_if.s_addr = pnetif->ip_addr.addr; /* 网络接口 IP */
} else {
msgbuf[*piIndex].rm_gw.s_addr = IPADDR_ANY;
msgbuf[*piIndex].rm_mask.s_addr = IPADDR_ANY;
msgbuf[*piIndex].rm_if.s_addr = IPADDR_ANY;
}
lib_memcpy(msgbuf[*piIndex].rm_ifname,
prte->RTE_cNetifName, IF_NAMESIZE); /* 网卡名称 */
(*piIndex)++; /* 索引向下移动 */
}
}
/*********************************************************************************************************
** 函数名称: __tshellCharInster
** 功能描述: shell 收到一个普通键值.
** 输 入 : iFd 文件描述符
** cChar 键值
** psicContext 当前输入上下文
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __tshellCharInster (INT iFd, CHAR cChar, __PSHELL_INPUT_CTX psicContext)
{
if (CTX_CURSOR == CTX_TOTAL) {
write(iFd, &cChar, 1);
CTX_BUFFER[CTX_CURSOR] = cChar;
CTX_CURSOR++;
CTX_TOTAL++;
} else if (CTX_CURSOR < CTX_TOTAL) {
lib_memcpy(&CTX_BUFFER[CTX_CURSOR + 1],
&CTX_BUFFER[CTX_CURSOR],
CTX_TOTAL - CTX_CURSOR);
CTX_BUFFER[CTX_CURSOR] = cChar;
CTX_TOTAL++;
write(iFd, &CTX_BUFFER[CTX_CURSOR], CTX_TOTAL - CTX_CURSOR);
CTX_CURSOR++;
__tshellTtyCursorMoveLeft(iFd, CTX_TOTAL - CTX_CURSOR);
}
}
/*********************************************************************************************************
** 函数名称: OSFpuInitCtx
** 功能描述: 初始化一个 Fpu 上下文控制块 (这里并没有使能 FPU)
** 输 入 : pvFpuCtx FPU 上下文
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID archFpuCtxInit (PVOID pvFpuCtx)
{
lib_memcpy(pvFpuCtx, &_G_fpuCtxInit, sizeof(LW_FPU_CONTEXT));
}
/*********************************************************************************************************
** 函数名称: _evtfdRead
** 功能描述: 读 eventfd 设备
** 输 入 : pevtfdfil eventfd 文件
** pcBuffer 接收缓冲区
** stMaxBytes 接收缓冲区大小
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t _evtfdRead (PLW_EVTFD_FILE pevtfdfil,
PCHAR pcBuffer,
size_t stMaxBytes)
{
INTREG iregInterLevel;
ULONG ulLwErrCode;
ULONG ulTimeout;
BOOL bRelease = LW_FALSE;
if (!pcBuffer || (stMaxBytes < sizeof(UINT64))) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
if (LW_CPU_GET_CUR_NESTING()) { /* 是否在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (PX_ERROR); /* 不能在中断中调用 */
}
if (pevtfdfil->EF_iFlag & O_NONBLOCK) {
ulTimeout = LW_OPTION_NOT_WAIT;
} else {
ulTimeout = LW_OPTION_WAIT_INFINITE;
}
for (;;) {
ulLwErrCode = API_SemaphoreBPend(pevtfdfil->EF_ulReadLock, ulTimeout);
if (ulLwErrCode != ERROR_NONE) { /* 超时 */
_ErrorHandle(EAGAIN);
return (0);
}
LW_SPIN_LOCK_QUICK(&pevtfdfil->EF_slLock, &iregInterLevel);
if (pevtfdfil->EF_u64Counter) {
break;
}
LW_SPIN_UNLOCK_QUICK(&pevtfdfil->EF_slLock, iregInterLevel);
}
if (pevtfdfil->EF_iFlag & EFD_SEMAPHORE) { /* EFD_SEMAPHORE */
UINT64 u64One = 1;
lib_memcpy(pcBuffer, &u64One, sizeof(UINT64)); /* host bytes order */
pevtfdfil->EF_u64Counter--;
} else {
lib_memcpy(pcBuffer, &pevtfdfil->EF_u64Counter, sizeof(UINT64));
pevtfdfil->EF_u64Counter = 0;
}
if (pevtfdfil->EF_u64Counter) {
bRelease = LW_TRUE;
}
LW_SPIN_UNLOCK_QUICK(&pevtfdfil->EF_slLock, iregInterLevel);
if (bRelease) {
API_SemaphoreBPost(pevtfdfil->EF_ulReadLock);
SEL_WAKE_UP_ALL(&pevtfdfil->EF_selwulist, SELREAD);
}
API_SemaphoreBPost(pevtfdfil->EF_ulWriteLock);
SEL_WAKE_UP_ALL(&pevtfdfil->EF_selwulist, SELWRITE);
return (sizeof(UINT64));
}
/*********************************************************************************************************
** 函数名称: __procFsPowerInfoRead
** 功能描述: procfs 读一个 pminfo 文件
** 输 入 : p_pfsn 节点控制块
** pcBuffer 缓冲区
** stMaxBytes 缓冲区大小
** oft 文件指针
** 输 出 : 实际读取的数目
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t __procFsPowerInfoRead (PLW_PROCFS_NODE p_pfsn,
PCHAR pcBuffer,
size_t stMaxBytes,
off_t oft)
{
REGISTER PCHAR pcFileBuffer;
size_t stRealSize; /* 实际的文件内容大小 */
size_t stCopeBytes;
/*
* 程序运行到这里, 文件缓冲一定已经分配了预置的内存大小.
*/
pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn);
if (pcFileBuffer == LW_NULL) {
_ErrorHandle(ENOMEM);
return (0);
}
stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn);
if (stRealSize == 0) { /* 需要生成文件 */
PCHAR pcSysMode;
PCHAR pcPowerLevel;
UINT uiPowerLevel;
ULONG ulActive;
API_PowerMCpuGet(&ulActive, &uiPowerLevel);
switch (uiPowerLevel) {
case LW_CPU_POWERLEVEL_TOP:
pcPowerLevel = "Top";
break;
case LW_CPU_POWERLEVEL_FAST:
pcPowerLevel = "Fast";
break;
case LW_CPU_POWERLEVEL_NORMAL:
pcPowerLevel = "Normal";
break;
case LW_CPU_POWERLEVEL_SLOW:
pcPowerLevel = "Slow";
break;
default:
pcPowerLevel = "<unknown>";
break;
}
if (_G_bPowerSavingMode) {
pcSysMode = "Power-Saving";
} else {
pcSysMode = "Running";
}
stRealSize = bnprintf(pcFileBuffer, __PROCFS_BUFFER_SIZE_INFO, 0,
"NCPUS : %u\n"
"ACTIVE : %u\n"
"POWERLevel : %s\n"
"SYSStatus : %s\n",
(UINT)LW_NCPUS,
(UINT)ulActive,
pcPowerLevel,
pcSysMode);
API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize);
}
if (oft >= stRealSize) {
_ErrorHandle(ENOSPC);
return (0);
}
stCopeBytes = __MIN(stMaxBytes, (size_t)(stRealSize - oft)); /* 计算实际读取的数量 */
lib_memcpy(pcBuffer, (CPVOID)(pcFileBuffer + oft), (UINT)stCopeBytes);
return ((ssize_t)stCopeBytes);
}
/*********************************************************************************************************
** 函数名称: _evtfdWrite
** 功能描述: 写 eventfd 设备
** 输 入 : pevtfdfil eventfd 文件
** pcBuffer 将要写入的数据指针
** stNBytes 写入数据大小
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t _evtfdWrite (PLW_EVTFD_FILE pevtfdfil,
PCHAR pcBuffer,
size_t stNBytes)
{
INTREG iregInterLevel;
UINT64 u64Add;
ULONG ulLwErrCode;
ULONG ulTimeout;
BOOL bRelease = LW_FALSE;
if (!pcBuffer || (stNBytes < sizeof(UINT64))) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
if (LW_CPU_GET_CUR_NESTING()) { /* 是否在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (PX_ERROR); /* 不能在中断中调用 */
}
lib_memcpy(&u64Add, pcBuffer, sizeof(UINT64));
if (u64Add == LW_EVENTFD_MAX_CNT) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
if (pevtfdfil->EF_iFlag & O_NONBLOCK) {
ulTimeout = LW_OPTION_NOT_WAIT;
} else {
ulTimeout = LW_OPTION_WAIT_INFINITE;
}
for (;;) {
ulLwErrCode = API_SemaphoreBPend(pevtfdfil->EF_ulWriteLock, ulTimeout);
if (ulLwErrCode != ERROR_NONE) { /* 超时 */
_ErrorHandle(EAGAIN);
return (0);
}
LW_SPIN_LOCK_QUICK(&pevtfdfil->EF_slLock, &iregInterLevel);
if ((LW_EVENTFD_MAX_CNT - u64Add) > pevtfdfil->EF_u64Counter) { /* 不能产生溢出 */
break;
}
LW_SPIN_UNLOCK_QUICK(&pevtfdfil->EF_slLock, iregInterLevel);
}
pevtfdfil->EF_u64Counter += u64Add;
if (pevtfdfil->EF_u64Counter) {
bRelease = LW_TRUE;
}
LW_SPIN_UNLOCK_QUICK(&pevtfdfil->EF_slLock, iregInterLevel);
if (bRelease) {
API_SemaphoreBPost(pevtfdfil->EF_ulReadLock);
SEL_WAKE_UP_ALL(&pevtfdfil->EF_selwulist, SELREAD);
}
return (sizeof(UINT64));
}
/*********************************************************************************************************
** 函数名称: __procFsPowerAdapterRead
** 功能描述: procfs 读一个读取网络 adapter 文件
** 输 入 : p_pfsn 节点控制块
** pcBuffer 缓冲区
** stMaxBytes 缓冲区大小
** oft 文件指针
** 输 出 : 实际读取的数目
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t __procFsPowerAdapterRead (PLW_PROCFS_NODE p_pfsn,
PCHAR pcBuffer,
size_t stMaxBytes,
off_t oft)
{
const CHAR cAdapterInfoHdr[] =
"ADAPTER MAX-CHANNLE\n";
PCHAR pcFileBuffer;
size_t stRealSize; /* 实际的文件内容大小 */
size_t stCopeBytes;
/*
* 由于预置内存大小为 0 , 所以打开后第一次读取需要手动开辟内存.
*/
pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn);
if (pcFileBuffer == LW_NULL) { /* 还没有分配内存 */
size_t stNeedBufferSize = 0;
PLW_LIST_LINE plineTemp;
PLW_PM_ADAPTER pmadapter;
__POWERM_LOCK();
for (plineTemp = _G_plinePMAdapter;
plineTemp != LW_NULL;
plineTemp = _list_line_get_next(plineTemp)) {
stNeedBufferSize += 32;
}
__POWERM_UNLOCK();
stNeedBufferSize += sizeof(cAdapterInfoHdr);
if (API_ProcFsAllocNodeBuffer(p_pfsn, stNeedBufferSize)) {
_ErrorHandle(ENOMEM);
return (0);
}
pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn); /* 重新获得文件缓冲区地址 */
stRealSize = bnprintf(pcFileBuffer, stNeedBufferSize, 0, cAdapterInfoHdr);
/* 打印头信息 */
__POWERM_LOCK();
for (plineTemp = _G_plinePMAdapter;
plineTemp != LW_NULL;
plineTemp = _list_line_get_next(plineTemp)) {
pmadapter = _LIST_ENTRY(plineTemp, LW_PM_ADAPTER, PMA_lineManage);
stRealSize = bnprintf(pcFileBuffer, stNeedBufferSize, stRealSize,
"%-14s %u\n",
pmadapter->PMA_cName,
pmadapter->PMA_uiMaxChan);
}
__POWERM_UNLOCK();
API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize);
} else {
stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn);
}
if (oft >= stRealSize) {
_ErrorHandle(ENOSPC);
return (0);
}
stCopeBytes = __MIN(stMaxBytes, (size_t)(stRealSize - oft)); /* 计算实际拷贝的字节数 */
lib_memcpy(pcBuffer, (CPVOID)(pcFileBuffer + oft), (UINT)stCopeBytes);
return ((ssize_t)stCopeBytes);
}
