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; }