WCECOMPAT_API int __cdecl
wceWasMenuGesture(HWND hwnd, int x, int y, int button, int down, UINT flags)
{
#ifdef POCKETPC_MENUS
SHRGINFO shrginfo;
int result;
static int doit = 0 ;
shrginfo.cbSize = sizeof(SHRGINFO);
shrginfo.hwndClient = hwnd;
shrginfo.ptDown.x = x;
shrginfo.ptDown.y = y;
shrginfo.dwFlags = SHRG_RETURNCMD;
NKDbgPrintfW(TEXT("entering recognize\n"));
if (doit) {
result = SHRecognizeGesture(&shrginfo);
}
NKDbgPrintfW(TEXT("got %d\n"), result);
return (result);// SHRecognizeGesture(&shrginfo));
#else
return 0; /* handled elsewhere, for now */
#endif
}
// -----------------------------------------------------------------------------
BOOL QueryWzcIntf
// Query's WZC information for the specified adapter.
// Callers MUST deallocate Intf with WZCDeleteInterfaceEx.
(
IN LPCWSTR pAdapter,
OUT INTF_ENTRY_EX *pIntf,
IN DWORD IntfFlags, // usually INTF_ALL
OUT DWORD *pOutFlags
)
{
memset(pIntf, 0x00, sizeof(INTF_ENTRY_EX));
pIntf->wszGuid = const_cast<LPWSTR>(pAdapter);
DWORD result = WZCQueryInterfaceEx(NULL,
IntfFlags,
pIntf,
pOutFlags);
if (NO_ERROR != result)
{
if (ERROR_FILE_NOT_FOUND == result)
NKDbgPrintfW(L"WZCQueryInterfaceEx() error %u: adapter \"%s\" not found \r\n", result, pAdapter);
else
NKDbgPrintfW(L"WZCQueryInterfaceEx() error %u out-flags 0x%08X \r\n", result, *pOutFlags);
return FALSE;
}
return TRUE;
} // QueryWzcIntf()
BOOL WINAPI DllMain (HINSTANCE hInstance, DWORD dwReason, LPVOID lpVoid)
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
NKDbgPrintfW (_T("%s: DLL_PROCESS_ATTACH\r\n"), _T(__FILE__));
g_hinstDll = hInstance;
break;
case DLL_PROCESS_DETACH:
NKDbgPrintfW (_T("%s: DLL_PROCESS_DETACH\r\n"), _T(__FILE__));
break;
case DLL_THREAD_ATTACH:
NKDbgPrintfW (_T("%s: DLL_THREAD_ATTACH\r\n"), _T(__FILE__));
break;
case DLL_THREAD_DETACH:
NKDbgPrintfW (_T("%s: DLL_THREAD_DETACH\r\n"), _T(__FILE__));
break;
default:
NKDbgPrintfW (_T("%s: ERROR!!! Unknown dwReason: %d\r\n"), _T(__FILE__), dwReason);
return FALSE;
break;
}
return TRUE;
}
/// Gets Interupt Number and Processor Type
/// @param[in] device CAN port
/// 0 or 1 for Apalis
/// always 0 for Colibri
/// @param[out] gpio gpio which is used as MCP2515_INT# signal
/// @param[out] procType current processor ID (see coproclib, getPROCID() )
/// @retval 0 Successful exit
static BOOL GetInterruptGpio(DWORD device, DWORD *gpio, DWORD *procType)
{
BOOL successStatus = TRUE;
PIN_INSTANCE IntGpio;
*procType = getPROCID();
if(getModuleFamily()==MODULE_FAMILY_APALIS)
{
*gpio = TEGRA_GPIONUM('w', 2)+device; //device 0 -> GPIO W2, device 1 ->GPIO W3
}
else
{
switch (*procType) //device is ignored
{
case TYPE_PXA270:
case TYPE_PXA320:
case TYPE_PXA300:
case TYPE_TEGRA2:
case TYPE_TEGRA3:
GetGPIOFromPin(73, FALSE, &IntGpio); // CANINT# signal is on SODIMM pin 73
*gpio = IntGpio.inst1;
break;
case TYPE_PXA310:
GetGPIOFromPin(133, FALSE, &IntGpio); // for PXA310, CANINT# signal is on SODIMM pin 133!
*gpio = IntGpio.inst1;
break;
default:
NKDbgPrintfW(L"CAN Demo: Unknown Processor type");
successStatus = FALSE;
}
}
return(successStatus);
}
static void
ViewXIPChain(DWORD dwNumXIPs, PXIPCHAIN_ENTRY pEntry)
{
UINT i, j;
wchar_t szXIPName[XIP_NAMELEN];
NKDbgPrintfW(TEXT("dwNumXIPs = %d\r\n"), dwNumXIPs);
for (i = 0; i < dwNumXIPs; i ++)
{
MSMDD_RTL_PRINT(TEXT("[MSMDD: ] REGION[%d]\r\n"), i);
MSMDD_RTL_PRINT(TEXT("[MSMDD: ] \t pvAddr[%d].pvAddr = 0x%X\r\n"), i, (DWORD) pEntry[i].pvAddr);
MSMDD_RTL_PRINT(TEXT("[MSMDD: ] \t pEntry[%d].dwLength = 0x%X\r\n"), i, (DWORD) pEntry[i].dwLength);
MSMDD_RTL_PRINT(TEXT("[MSMDD: ] \t pEntry[%d].dwMaxLength = 0x%X\r\n"), i, (DWORD) pEntry[i].dwMaxLength);
MSMDD_RTL_PRINT(TEXT("[MSMDD: ] \t pEntry[%d].usOrder = 0x%X\r\n"), i, (USHORT) pEntry[i].usOrder);
MSMDD_RTL_PRINT(TEXT("[MSMDD: ] \t pEntry[%d].usFlags = 0x%X\r\n"), i, (USHORT) pEntry[i].usFlags);
MSMDD_RTL_PRINT(TEXT("[MSMDD: ] \t pEntry[%d].dwVersion = 0x%X\r\n"), i, (DWORD) pEntry[i].dwVersion);
for (j = 0; j < XIP_NAMELEN; j ++)
szXIPName[j] = (TCHAR) (pEntry[i].szName[j]);
MSMDD_RTL_PRINT(TEXT("[MSMDD: ] \t pEntry[%d].szName = %s\r\n"), i, szXIPName);
MSMDD_RTL_PRINT(TEXT("[MSMDD: ] \t pEntry[%d].dwAlgoFlags = 0x%x\r\n"), i, (DWORD) pEntry[i].dwAlgoFlags);
MSMDD_RTL_PRINT(TEXT("[MSMDD: ] \t pEntry[%d].dwKeyLen = 0x%x\r\n"), i, (DWORD) pEntry[i].dwKeyLen);
}
}
static void debug_print(const char *dbg, const char *buf)
{
#if defined(ENABLE_NETWORK)
if (_debug_socket != INVALID_SOCKET) {
char buf2[1024 + 32];
snprintf(buf2, lengthof(buf2), "%sdbg: [%s] %s\n", GetLogPrefix(), dbg, buf);
send(_debug_socket, buf2, (int)strlen(buf2), 0);
return;
}
#endif /* ENABLE_NETWORK */
if (strcmp(dbg, "desync") != 0) {
#if defined(WINCE)
/* We need to do OTTD2FS twice, but as it uses a static buffer, we need to store one temporary */
TCHAR tbuf[512];
_sntprintf(tbuf, sizeof(tbuf), _T("%s"), OTTD2FS(dbg));
NKDbgPrintfW(_T("dbg: [%s] %s\n"), tbuf, OTTD2FS(buf));
#else
fprintf(stderr, "%sdbg: [%s] %s\n", GetLogPrefix(), dbg, buf);
#endif
IConsoleDebug(dbg, buf);
} else {
static FILE *f = FioFOpenFile("commands-out.log", "wb", AUTOSAVE_DIR);
if (f == NULL) return;
fprintf(f, "%s%s\n", GetLogPrefix(), buf);
fflush(f);
}
}
BOOL BkgPingStatusCheckStop()
{
BOOL bRet = TRUE;
NKDbgPrintfW( _T("[NETUI] ===== [BkgPingStatusCheckStop] ===== \r\n") );
// 이미 스레드가 동작중이라면, 종료시키고 새로 생성
if( g_hCheckThread != NULL || g_bIsOperating == TRUE )
{
DWORD dwExitCode = 0;
// 동작 상태 변경
g_bIsOperating = FALSE;
// 2초까지 종료를 기다려 주고, 그안에 종료되지 않으면 강제 종료
if( WaitForSingleObject(g_hCheckThread, 2000) == WAIT_TIMEOUT )
{
bRet = TerminateThread(g_hCheckThread, 0);
}
CloseHandle(g_hCheckThread);
g_hCheckThread = NULL;
}
Sleep(500);
return bRet;
}
BOOL BkgPingStatusCheckStart(BBS_BKG_PINGCHECK_OPT bkgPingCheckOpt)
{
NKDbgPrintfW( _T("\r\n\r\n[NETUI] ========== Ping Check Program Start! ==========\r\n\r\n") );
// 스레드가 동작중이라면 종료시켜 준다.
BkgPingStatusCheckStop();
g_dwBreakInterval = bkgPingCheckOpt.dwBreakInterval;
g_dwPingInterval = bkgPingCheckOpt.dwPingInterval;
g_dwMaxCheckCount = bkgPingCheckOpt.dwMaxCheckCount;
if( _tcslen(bkgPingCheckOpt.tszCustomDestAddr) == 0 )
{
memset(g_tszCustomDestAddr, L'\0', sizeof(g_tszCustomDestAddr));
}
else
{
_tcscpy(g_tszCustomDestAddr, bkgPingCheckOpt.tszCustomDestAddr);
}
NKDbgPrintfW( _T("[NETUI] ---------- [Option Value] ---------- \r\n") );
NKDbgPrintfW( _T("[NETUI] CheckNBreakInterval(%d), PingInterval(%d) \r\n"), g_dwBreakInterval, g_dwPingInterval );
NKDbgPrintfW( _T("[NETUI] MaxCheckCount(%d), CustomDestIP(%s) \r\n"), g_dwMaxCheckCount, g_tszCustomDestAddr );
NKDbgPrintfW( _T("[NETUI] ---------------------------------------- \r\n\r\n") );
// 일단 동작중이 아니라고 표시, BkgPingStatusCheckThread 함수내에서 실행하면서 TRUE 설정
g_bIsOperating = FALSE;
g_hCheckThread = CreateThread(NULL, 0, BkgPingStatusCheckThread, NULL, 0, NULL);
if(g_hCheckThread == NULL)
{
// ERROR
return FALSE;
}
return TRUE;
}
CVMInt32
CVMioWrite(CVMInt32 fd, const void *buf, CVMUint32 nBytes)
{
DWORD bytes;
HANDLE h = WIN_GET_HANDLE((HANDLE)fd);
int b;
/* check if redirection sockets are used */
if (CVMglobals.target.stdoutPort >= 0 || CVMglobals.target.stderrPort >= 0) {
/* check if output should be redirected */
if ((fd >= 1) && (fd <= 2)) {
SIOWrite(fd, (char *)buf, nBytes);
}
}
#ifndef WINCE
switch (fd) {
case 0: h = GetStdHandle(STD_INPUT_HANDLE); break;
case 1: h = GetStdHandle(STD_OUTPUT_HANDLE); break;
case 2: h = GetStdHandle(STD_ERROR_HANDLE); break;
}
b = WriteFile(h, buf, nBytes, &bytes, NULL);
#else /* WINCE */
if (fd >= 1 && fd <= 2) {
FILE *fp = NULL;
#ifdef CVM_DEBUG
NKDbgPrintfW(TEXT("%.*hs"), nBytes, buf);
#endif
switch (fd) {
case 1:
fp = stdout;
break;
case 2:
fp = stderr;
break;
}
fwrite(buf, sizeof (char), nBytes, fp);
/* Silently ignore errors */
writeStandardIO(fd, buf, nBytes);
bytes = nBytes;
b = 1;
} else {
b = WriteFile(h, buf, nBytes, &bytes, NULL);
}
#endif /* WINCE */
if (b) {
return (bytes);
} else {
return -1;
}
}
void printD(char* fmt, ...)
{
char str[512];
wchar_t wstr[512];
int alen;
int wlen;
vsprintf(str, fmt, (char *)(&fmt+1));
alen = strlen(str);
wlen = MultiByteToWideChar(CP_ACP, 0, str, alen, 0, 0);
MultiByteToWideChar(CP_ACP, 0, str, alen, wstr, wlen);
wstr[wlen] = 0;
NKDbgPrintfW(wstr);
}
/*----------------------------------------------------------------------------*/
NDIS_STATUS dbgLogWr2(IN PINT_8 debugStr, IN ...
)
{
#define TMP_BUF_LEN 256
#define TMP_WBUF_LEN (TMP_BUF_LEN * 2)
va_list paramList;
PINT_16 wbuf_p;
PINT_8 buf_p;
INT_32 strLen;
/* Create log message buffer */
buf_p = (PINT_8) kalMemAlloc(TMP_BUF_LEN, VIR_MEM_TYPE);
if (buf_p == NULL) {
return NDIS_STATUS_FAILURE;
}
wbuf_p = (PINT_16) kalMemAlloc(TMP_WBUF_LEN, VIR_MEM_TYPE);
if (wbuf_p == NULL) {
kalMemFree(buf_p, VIR_MEM_TYPE, TMP_BUF_LEN);
return NDIS_STATUS_FAILURE;
}
/* Format message */
kalMemZero(buf_p, TMP_BUF_LEN);
kalMemZero(wbuf_p, TMP_WBUF_LEN);
va_start(paramList, debugStr);
_vsnprintf(buf_p, TMP_BUF_LEN - 1, debugStr, paramList);
va_end(paramList);
strLen = strlen(buf_p);
/* Converts a sequence of multibyte characters to a corresponding sequence
of wide characters. */
mbstowcs(wbuf_p, buf_p, strLen);
/* Print unicode message */
NKDbgPrintfW(TEXT("%s"), wbuf_p);
/* Free message buffer */
kalMemFree(buf_p, VIR_MEM_TYPE, TMP_BUF_LEN);
kalMemFree(wbuf_p, VIR_MEM_TYPE, TMP_WBUF_LEN);
return NDIS_STATUS_SUCCESS;
} /* dbgLogWr2 */
void PyCom_StreamMessage(const char *pszMessageText)
{
#ifndef MS_WINCE
OutputDebugStringA(pszMessageText);
#else
NKDbgPrintfW(pszMessageText);
#endif
// PySys_WriteStderr has an internal 1024 limit due to varargs.
// weve already resolved them, so we gotta do it the hard way
// We can't afford to screw with the Python exception state
PyObject *typ, *val, *tb;
PyErr_Fetch(&typ, &val, &tb);
PyObject *pyfile = PySys_GetObject("stderr");
if (pyfile)
if (PyFile_WriteString((char *)pszMessageText, pyfile)!=0)
// eeek - Python error writing this error - write it to stdout.
fprintf(stdout, "%s", pszMessageText);
PyErr_Restore(typ, val, tb);
}
void CReg6410Uart::DumpRegister()
{
NKDbgPrintfW(TEXT("DumpRegister (ULCON=%x, UCON=%x, UFCON=%x, UMCOM = %x, UBDIV =%x)\r\n"),
Read_ULCON(),Read_UCON(),Read_UFCON(),Read_UMCON(),Read_UBRDIV());
}
// -----------------------------------------------------------------------------
BOOL AddToPreferredNetworkList
// adding to the Preferred Networks List
// Preferred Networks is a list of SSIDs in preference order.
// WZC continuously scans available SSIDs and attempts to connect to the most preferable SSID.
(
IN LPCWSTR pAdapter,
IN const WZC_WLAN_CONFIG &wzcConfig
)
{
DWORD dwOutFlags = 0;
INTF_ENTRY_EX Intf;
TCHAR tszLogMsg[128] = L"";
if (!QueryWzcIntf(pAdapter, &Intf, INTF_ALL, &dwOutFlags))
return FALSE;
WZC_802_11_CONFIG_LIST *pConfigList = (PWZC_802_11_CONFIG_LIST)Intf.rdStSSIDList.pData;
if (NULL == pConfigList) // empty [Preferred Networks] list case
{
DWORD dwDataLen = sizeof(WZC_802_11_CONFIG_LIST);
WZC_802_11_CONFIG_LIST *pNewConfigList = (WZC_802_11_CONFIG_LIST *)LocalAlloc(LPTR, dwDataLen);
pNewConfigList->NumberOfItems = 1;
pNewConfigList->Index = 0;
memcpy(pNewConfigList->Config, &wzcConfig, sizeof(wzcConfig));
Intf.rdStSSIDList.pData = (BYTE*)pNewConfigList;
Intf.rdStSSIDList.dwDataLen = dwDataLen;
wsprintf(tszLogMsg, L"[AddPref] Preferred Networks List has no entries \r\n");
AddLogData(1, tszLogMsg);
}
else
{
ULONG uiNumberOfItems = pConfigList->NumberOfItems;
for (UINT i=0; i<uiNumberOfItems; i++)
{
if (memcmp(&wzcConfig.Ssid, &pConfigList->Config[i].Ssid, sizeof(NDIS_802_11_SSID)) == 0)
{
wsprintf(tszLogMsg, L"[AddPref] already in the Preferred Networks list \r\n");
AddLogData(1, tszLogMsg);
WZCDeleteIntfObjEx(&Intf);
return TRUE;
}
}
wsprintf(tszLogMsg, L"[AddPref] Preferred Networks List has [%d] entries \r\n", uiNumberOfItems);
AddLogData(1, tszLogMsg);
DWORD dwDataLen = sizeof(WZC_802_11_CONFIG_LIST) + (uiNumberOfItems+1)*sizeof(WZC_WLAN_CONFIG);
WZC_802_11_CONFIG_LIST *pNewConfigList = (WZC_802_11_CONFIG_LIST *)LocalAlloc(LPTR, dwDataLen);
pNewConfigList->NumberOfItems = uiNumberOfItems + 1;
pNewConfigList->Index = 0;
memcpy(pNewConfigList->Config, &wzcConfig, sizeof(wzcConfig));
if (pConfigList->NumberOfItems)
{
pNewConfigList->Index = pConfigList->Index;
memcpy(pNewConfigList->Config+1, pConfigList->Config, (uiNumberOfItems)*sizeof(WZC_WLAN_CONFIG));
LocalFree(pConfigList);
pConfigList = NULL;
}
Intf.rdStSSIDList.pData = (BYTE*)pNewConfigList;
Intf.rdStSSIDList.dwDataLen = dwDataLen;
}
PrintConfigItem(wzcConfig, FALSE);
DWORD result = WZCSetInterfaceEx(NULL, INTF_PREFLIST, &Intf, &dwOutFlags);
if (NO_ERROR != result)
{
NKDbgPrintfW( L"WZCSetInterfaceEx() error %u, dwOutFlags=0x%08X \r\n", result, dwOutFlags);
}
WZCDeleteIntfObjEx(&Intf);
return result? FALSE : TRUE;
}// AddToPreferredNetworkList()
LRESULT CALLBACK
DlgOptions(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam
)
{
static LPCWSTR szExeName;
SHIM_SETTINGS ShimSettingsTemp;
LPSHIM_SETTINGS pShimSettings = & gShimSettings;
DWORD cbSize;
switch (message) {
case WM_INITDIALOG:
{
//
// find out what exe we're handling settings for
//
szExeName = ExeNameFromLParam(lParam);
GetShimSettings (szExeName, & pShimSettings, & cbSize);
RefreshDlgData (hDlg);
return TRUE;
}
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_DEFAULT:
{
// Save off the globals
memcpy (& ShimSettingsTemp, & gShimSettings, sizeof (SHIM_SETTINGS));
// Set the default values
gShimSettings.dwFoo = 0;
// Update the UI to reflect the default values.
RefreshDlgData (hDlg);
// Restore the globals (in case this isn't 'applied')
memcpy (& gShimSettings, & ShimSettingsTemp, sizeof (SHIM_SETTINGS));
break;
}
}
break;
case WM_NOTIFY:
switch (((NMHDR FAR *) lParam)->code) {
case PSN_KILLACTIVE:
{
break;
}
case PSN_APPLY:
{
NKDbgPrintfW (_T("Applying settings for %s\r\n"), szExeName);
// Retrieve settings from the UI.
gShimSettings.dwFoo = GetDlgItemInt (
hDlg,
IDC_EDIT_FOO,
NULL,
FALSE
);
SetShimSettings (szExeName, & gShimSettings, sizeof (SHIM_SETTINGS));
break;
}
}
break;
}
return FALSE;
}
/*************************************************************************************
// Function: SYSCheckBattVoltage
// Purpose: Check battery voltage and Calculate Battery status in percent
// Returns: Battery status in percent
//***********************************************************************************/
static USHORT
SYSCheckBattVoltage(BOOL bSet)
{
//[david.modify] 2008-05-24 14:51
// 这里应该有更复杂的算法
//应该测一段时间内的平均电压
//=================================
USHORT usBatteryPer=0;
USHORT avgVol=0;
USHORT avgADC=0;
USHORT u16Vbat=0;
USHORT usCurrentVoltage=0;
UINT32 u32Temp = 0;
int iCount=0;
USHORT usBatteryLowLevel=0;
USHORT usBatteryHighLevel=0;
SYSTEMTIME st;
//Set battery percent when battery full
if(bSet)
{
avgVol =0;
DPNOK(bSet);
return 100;
}
// OEM_GetBattVoltage(&avgVol);
for(iCount=0;iCount<ADC_COUNT;iCount++)
{
OEM_GetBattVoltage(&avgADC);
u32Temp+=avgADC;
Sleep(10);
}
avgADC=u32Temp/ADC_COUNT;
DPNOK(avgADC);
// 方法1:最简单算法，根据ADC值，固定公式算出电压值
//===============================================
avgVol = (avgADC*2*BATTERY_REF_VOLTAGE)/(1024);
//[david.modify] 2008-06-16 15:16
// 从现像看, ADC测出值比实际电源输出值小 120mv;
//=======================
// #define REALVBAT_ADC_OFFSET 120
#define REALVBAT_ADC_OFFSET 0 //为了保持和EBOOT中一样
avgVol+=REALVBAT_ADC_OFFSET;
// 方法2:最简单算法，根据ADC值，在ADC不同范围内
// 乘以的参数不同
//===============================================
//[david.modify] 2008-05-31 11:00
//确定最低电池电压的ADC值和最高电池电压的ADC值
//=======================
//[david.modify] 2008-05-22 19:03
// 实际电压 = 10bit adc/1024 *2 *3.3v
// 4200 = ADC/1024 * 2 * 3.3 *1000
// --> ADC=4200 *1024 / (1000 *2*3.3) = 4200/6.445
// 每读一次ADC间隔时间(ms)
// vol adc adc*2
//=====================================
// 4200 651 1303
// 3400 527 1055
// 3700 574 1148
//=====================================
GetSystemTime(&st);
usBatteryPer = (USHORT)BattGetPercentFromVoltage(avgVol);
DPNOK(avgVol);
DPNOK(usBatteryPer);
if(g_stBattParam.u32Debug&SHOWVBAT_BIT) {
NKDbgPrintfW(L"Avl Vbat=%d%%, %d mv (adc=%d) (cnt=%d) [%d:%d:%d]\r\n", usBatteryPer, avgVol, avgADC, ADC_COUNT,
st.wHour, st.wMinute, st.wSecond );
}
#ifdef DEBUG
EPRINT(L"Avl Vbat=%d%%, %d mv (adc=%d) (cnt=%d) [%d:%d:%d]\r\n ", usBatteryPer, avgVol, avgADC, ADC_COUNT,
st.wHour, st.wMinute, st.wSecond );
#endif
return (usBatteryPer);
//=================================
}
//
// Perform the actual DMA copy
// WARNING!! This function assumes the physical memory is contiguous.
// No check is performed for performance improvement.
// Buffers passed-in come from CMEM and DISPLAY drivers.
//
DWORD SdmaPx::Copy( LPVOID pSource,
LPVOID pDestination,
DWORD dwClientIdx )
{
DWORD dwRet = 0;
DWORD dwCause, dwStatus;
DWORD paSrc, paDst;
BYTE ffCached = 0;
DmaConfigInfo_t dmaSettings = m_SdmaPxClient[dwClientIdx].GetConfig();
DWORD dwDataLength = m_SdmaPxClient[dwClientIdx].GetDataLength();
DWORD dwElementCount = m_SdmaPxClient[dwClientIdx].GetElementCount();
DWORD dwFrameCount = m_SdmaPxClient[dwClientIdx].GetFrameCount();
ASSERTMSG(L"Client must be configured before Copy I/O control is called !!!\n", m_SdmaPxClient[dwClientIdx].IsClientConfigured());
// Configure SDMA for specific client
// Need to call this first for length
// memset() on DmaConfigInfo_t not needed as done in the SdmaPxClient::Init() method.
// m_SdmaPxClient[dwClientIdx].GetConfig(&dmaSettings, &dwDataLength);
if(DmaConfigure(m_hDmaChannel, &dmaSettings, 0, &m_dmaInfo) != TRUE)
{
ERRORMSG(ZONE_ERROR, (TEXT("ERROR! Unable to configure DMA for client\r\n")));
goto cleanUp;
}
// flush cache if necessary
if (ISUNCACHEDADDRESS(pSource) == FALSE)
{
ffCached |= SOURCE_CACHED;
}
if (ISUNCACHEDADDRESS(pDestination) == FALSE)
{
ffCached |= DESTINATION_CACHED;
}
if (ffCached & (SOURCE_CACHED | DESTINATION_CACHED))
{
FlushCache(pSource, pDestination, dwDataLength, ffCached);
}
// Retrieve base physical address of buffer to be copied and READ lock the pages on the length.
if(LockPages(
(LPVOID)pSource,
(DWORD)dwDataLength,
m_rgPFNsrc,
LOCKFLAG_READ) == FALSE)
{
ERRORMSG(ZONE_ERROR, (TEXT("LockPages call \"src\" failed. (error code=%d)\r\n"), GetLastError()));
goto cleanUp;
}
// Not necessary to do the page shift on ARM platform as always 0. (ref. MSDN)
// paSrc = (m_rgPFNsrc[0] << m_pageShift) + ((DWORD)pSource & m_pageMask);
paSrc = m_rgPFNsrc[0] + ((DWORD)pSource & m_pageMask);
// Retrieve base physical address of destination buffer and WRITE lock the pages on the length.
if(LockPages(
(LPVOID)pDestination,
dwDataLength,
m_rgPFNdst,
LOCKFLAG_WRITE) == FALSE)
{
ERRORMSG(ZONE_ERROR, (TEXT("LockPages \"dest\" call failed. (error code=%d)\r\n"), GetLastError()));
goto cleanUp;
}
// Not necessary to do the page shift on ARM platform as always 0. (ref. MSDN)
// paDst = (m_rgPFNdst[0] << UserKInfo[KINX_PFN_SHIFT]) + ((DWORD)pDestination & m_pageMask);
paDst = m_rgPFNdst[0] + ((DWORD)pDestination & m_pageMask);
// Configure Dest and Src buffers for DMA.
DmaSetSrcBuffer(&m_dmaInfo, (UINT8 *)pSource, paSrc);
DmaSetDstBuffer(&m_dmaInfo, (UINT8 *)pDestination, paDst);
// Watch out parameters in DmaSetElemenAndFrameCount. For e.g., shift right element count by 2 if you have bytes in input and you use 32bits element size.
DmaSetElementAndFrameCount(&m_dmaInfo, dwElementCount, (UINT16)(dwFrameCount));
// start dma
DmaStart(&m_dmaInfo);
// wait until we hit the end of buffer
// Wait for dma interrupt...
dwCause = WaitForSingleObject(m_hEvent, DMA_IRQ_TIMEOUT);
switch(dwCause)
{
case WAIT_OBJECT_0:
{
// Verify cause of interrupt was because we hit the end of block
dwStatus = DmaGetStatus(&m_dmaInfo);
if ((dwStatus & (dmaSettings.interrupts)) == 0)
{
ERRORMSG(ZONE_ERROR, (TEXT("Unexpected cause of interrupt\r\n")));
break;
}
DmaClearStatus(&m_dmaInfo, dwStatus);
if (DmaInterruptDone(m_hDmaChannel) == FALSE)
{
ERRORMSG(ZONE_ERROR, (TEXT("ERROR! Unable to get status for dma interrupt\r\n")));
break;
}
// Do the "good" client job
DmaStop(&m_dmaInfo);
break;
}
default:
RETAILMSG(ZONE_ERROR, (TEXT("ERROR! didn't receive DMA interrupt\r\n")));
break;
}
#if DEBUG_VERIFY_SDMA_COPY
//
// Beware!! Bring a lot of overhead and can lead to bad display rendering.
//
NKDbgPrintfW(L"verify memory\r\n");
if (memcmp(pSource, pDestination, dwDataLength) != 0)
{
NKDbgPrintfW(L"ERROR! memory doesn't match up\r\n");
DebugBreak();
goto cleanUp;
}
#endif
dwRet = dwDataLength; // everything went fine obviously...
cleanUp:
UnlockPages((LPVOID)pSource, dwDataLength);
UnlockPages((LPVOID)pDestination, dwDataLength);
return dwRet;
}
DWORD WINAPI BkgPingStatusCheckThread(LPVOID lpVoid)
{
BBS_PING_OPTION pingOpt = {0,};
BBS_CUR_NET_INFO netInfo;
BBS_PING_RESULT pingResult;
BBS_ADAPTER_INFO adapterInfo;
DWORD dwPingFailCount = 0;
CBBS_Ping ping;
TCHAR tszLiteralIP[18] = {'\0',};
memset(&pingOpt, 0, sizeof(BBS_PING_OPTION));
memset(&netInfo, 0, sizeof(BBS_CUR_NET_INFO));
memset(&pingResult, 0, sizeof(BBS_PING_RESULT));
memset(&adapterInfo, 0, sizeof(BBS_ADAPTER_INFO));
NKDbgPrintfW( _T("[NETUI] ===== [BkgPingStatusCheckThread Start] ===== \r\n") );
g_bIsOperating = TRUE;
while(g_bIsOperating == TRUE)
{
// 1초씩 g_dwBreakInterval 만큼 쉬어준다.
// 1초씩 마다 스레드가 종료 조건이 걸려있는지 확인
for(UINT i=1; i<=g_dwBreakInterval; i++)
{
// BreakTime Interval
Sleep(1000);
if(g_bIsOperating == FALSE)
{
return 0;
}
}
// PIng 실패 횟수 초기화 필수!
dwPingFailCount = 0;
GetWlanDefaultInformation(&adapterInfo);
GetCurrentNetworkInfo(adapterInfo.tszAdapterName, &netInfo);
NKDbgPrintfW( _T("[NETUI] ---------- [Default Information] ---------- \r\n") );
NKDbgPrintfW( _T("[NETUI] Adapter(%s), DHCP(%d) \r\n"), adapterInfo.tszAdapterName, adapterInfo.bDHCPEnabled );
NKDbgPrintfW( _T("[NETUI] IPAddr(%s) \r\n"), adapterInfo.tszIPAddr );
NKDbgPrintfW( _T("[NETUI] DefaultGateWay(%s) \r\n"), adapterInfo.tszDefaultGateWay );
NKDbgPrintfW( _T("[NETUI] DnsAddr(%s) \r\n"), adapterInfo.tszDnsAddr );
NKDbgPrintfW( _T("[NETUI] ---------------------------------------- \r\n\r\n") );
// 아답터가 검색되었는지?
if( _tcslen(adapterInfo.tszAdapterName) == 0 )
{
// 아답터가 검색되지 않았다면, 기본 대기시간만큼 다시 대기
// ERROR
NKDbgPrintfW( _T("[NETUI] [ERROR] Can't Find Adapter! \r\n") );
continue;
}
NKDbgPrintfW( _T("[NETUI] SSID : %s \r\n"), netInfo.tszSSID );
// 현재 접속된 SSID가 있을 때만 Ping 시도
if( _tcslen(netInfo.tszSSID) != 0 )
{
// Custom Dest IP를 지정 되어있으면, 읽어온 값으로, 지정되지 않았다면, 기본 DefaultGateWay로 시도
if( _tcslen(g_tszCustomDestAddr) > 0 )
{
_tcscpy(pingOpt.tszDestIP, g_tszCustomDestAddr);
}
else
{
_tcscpy(pingOpt.tszDestIP, adapterInfo.tszDefaultGateWay);
}
pingOpt.dwSendBufSize = 32;
pingOpt.dwTimeOut = 1000;
pingOpt.ucTos = 0;
pingOpt.ucTtl = 32;
NKDbgPrintfW( TEXT("[NETUI] Dest IP(%s) \r\n"), pingOpt.tszDestIP );
if( ping.InitPing(pingOpt, tszLiteralIP) == TRUE)
{
HKEY hKey = NULL;
DWORD dwDisposition = 0;
NKDbgPrintfW( TEXT("[NETUI] Literal IP(%s) \r\n"), tszLiteralIP );
for(DWORD dwLoop=0; dwLoop<g_dwMaxCheckCount; dwLoop++)
{
if( !ping.StartPing(&pingResult) )
{
NKDbgPrintfW( TEXT("[NETUI] Ping Failed!(%d) \r\n"), pingResult.dwErrCode );
dwPingFailCount++;
}
else
{
NKDbgPrintfW( TEXT("[NETUI] Size(%d), Time(%d), TTL(%d) \r\n"), pingResult.dwDataSize, pingResult.dwTime, pingResult.ucTtl );
}
// 1초씩 g_dwBreakInterval 만큼 쉬어준다.
// 1초씩 마다 스레드가 종료 조건이 걸려있는지 확인
for(UINT i=1; i<=g_dwPingInterval; i++)
{
// Ping Interval
Sleep(1000);
if(g_bIsOperating == FALSE)
{
return 0;
}
}
}
ping.DeinitPing();
NKDbgPrintfW( TEXT("[NETUI] Max[%d] / Fail[%d] \r\n"), g_dwMaxCheckCount, dwPingFailCount );
// 최대 Ping 테스트 개수가 모두 Fail 되었을때!
if( dwPingFailCount >= g_dwMaxCheckCount )
{
NKDbgPrintfW( TEXT("[NETUI] Rebind Adapter! \r\n") );
if( DoNdis_RebindAdater(adapterInfo.tszAdapterName) == FALSE )
{
NKDbgPrintfW( TEXT("[NETUI] DoNdis_RebindAdater ERROR!! \r\n") );
}
}
}
else
{
NKDbgPrintfW( TEXT("[NETUI] Init Ping ERROR!! \r\n") );
}
}
else
{
NKDbgPrintfW( TEXT("[NETUI] isn't be connected to any SSID \r\n") );
}
}
return 0;
}
/******************************************************************************
*
* Name: HandleRxReadyEvent()
*
* Description: Rx ready event handler
*
* Arguments: PMRVDRV_ADAPTER Adapter
*
* Return Value:
*
* Notes:
*
*****************************************************************************/
VOID
HandleRxReadyEvent(
IN PMRVDRV_ADAPTER Adapter
)
{
int IsRxOK = 0;
PRxPD pRxPDCurrent;
PNDIS_PACKET pPacket;
NDIS_STATUS pStatus;
DBGPRINT(DBG_RX | DBG_HELP,(L"+HandleRxReadyEvent()\n"));
pRxPDCurrent = (PRxPD)(Adapter->pRxPD1);
//lykao, 060905, begin
if (pRxPDCurrent->Status & MRVDRV_RXPD_STATUS_OK)
{
Adapter->RcvOK++;
Adapter->DirectedFramesRcvOK++;
wlan_compute_rssi(Adapter,pRxPDCurrent);
}
else
{
DBGPRINT(DBG_RX | DBG_WARNING,(L"WARNING: frame received with bad status\n"));
//dralee++ 09212005 for error handling
pPacket = Adapter->pRxCurPkt;
Adapter->pRxCurPkt = NULL;
if ( pPacket )
ReturnRxPacketDesc(Adapter,pPacket);
return;
}
pPacket = Adapter->pRxCurPkt;
Adapter->pRxCurPkt = NULL;
if (Adapter->MediaConnectStatus == NdisMediaStateConnected)
{
Adapter->ulRxByteInLastPeriod += Adapter->ulRxSize;
NDIS_SET_PACKET_STATUS(pPacket, NDIS_STATUS_SUCCESS);
NdisMIndicateReceivePacket(Adapter->MrvDrvAdapterHdl, &pPacket, 1);
pStatus = NDIS_GET_PACKET_STATUS(pPacket);
if ((pStatus == NDIS_STATUS_RESOURCES) || (pStatus == NDIS_STATUS_SUCCESS))
{
// return packet
DBGPRINT(DBG_RX|DBG_HELP, (L"Packet returned success or resources...\n"));
ReturnRxPacketDesc(Adapter,pPacket);
}
else
{
DBGPRINT(DBG_RX|DBG_ERROR, (L"Packet returned pending...\n"));
}
}
else
{
///pmkcache: bug#16956 ++
if (Adapter->bIsReconnectAssociation == TRUE)
{
Adapter->isPktPending = TRUE;
if ( Adapter->pPendedRxPkt )
{
NKDbgPrintfW( L"ERROR, a pended RX packet has not been process!!\r\n" );
}
Adapter->pPendedRxPkt = pPacket;
return;
}
///pmkcache: bug#16956 --
DBGPRINT(DBG_RX|DBG_ERROR, (L"Not connected, packet was dropped...\n"));
ReturnRxPacketDesc(Adapter,pPacket);
}
return;
}
int WINAPI WinMain(HINSTANCE hInstance, // handle to current instance
HINSTANCE hPrevInstance, // handle to previous instance
LPWSTR lpCmdLine, // pointer to command line
int nCmdShow) // show state of window
{
HANDLE tRx, tTx;
BOOL dma_enable = FALSE;
NKDbgPrintfW(L"******************************************\n\r");
NKDbgPrintfW(L"********* Program Start **************\n\r");
NKDbgPrintfW(L"******************************************\n\r");
dma_enable = FALSE;
bufferTx = sbufferTx;
bufferRx = sbufferRx;
if ((bufferRx == NULL) || (bufferTx == NULL))
{
printf("Could not alloc buffers");
return FALSE;
}
//Initialize SSP1 (Master)
//-----------------------------
if (!SPIInit(txSSPport, DATABITS, SPI_CLOCK_812_KHZ, SPI_MASTER, SPI_MODE_3, NULL))
{
printf("Error in InitSPI");
return FALSE;
}
//Initialize SSP2 (Slave)
//-----------------------------
if (!SPIInit(rxSSPport, DATABITS, SPI_CLOCK_812_KHZ, SPI_SLAVE, SPI_MODE_3, NULL))
{
printf("Error in InitSPI");
return FALSE;
}
//Create and start transmit/receive threads
//-----------------------------
tRx = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) RXThread, 0, 0, NULL);
CeSetThreadPriority(tRx,10); //Set receive thread to a high priority to avoid buffer overflows
//Sleep(100);
tTx = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) TXThread, 0, 0, NULL);
printf("\r\nPress ENTER to leave the application.\r\n");
getchar();
TerminateThread(tRx, 0);
TerminateThread(tTx, 0);
Sleep(20);
CloseHandle(tRx);
CloseHandle(tTx);
//Deinit
//Very Important
//if you forget to Deinit a SPI and Init the SPI new the spi interrupts will not work.
//In this case you have to reset the System
DeinitSPI(txSSPport);
DeinitSPI(rxSSPport);
return TRUE;
}
