/////////////////////////////////////////////////////////////////////////////// // Copyright (c) Winnov L.P., 1996. All rights reserved // irq.cpp: Implementation of CIrq class /////////////////////////////////////////////////////////////////////////////// #include #include #include #include "wnv1632.h" #include "wnverr.h" #include "wnvevent.h" #include "wnvhw.h" #include "debug.h" #include "irq.h" #include "log.h" #define LOCAL_WAIT_INSERTION_TIMEOUT 100 /////////////////////////////////////////////////////////////////////////////// // Constructor/destructor stubs CIrq::CIrq () { m_hEventVideo = NULL; m_hEventStop = NULL; m_hEventEnd = NULL; // handle to client signalled END event m_hEventPollRecord = NULL; // handle to event signalled to client to poll m_hEventPollPlayback = NULL; m_hBoard = NULL; m_dwNotify = (DWORD)-1; m_hThread = NULL; m_dwThreadId = 0; m_hBoardHandle = NULL; m_PnPStatus.hNotifyEvent = NULL; m_fStatusChangeRegistered = FALSE; m_nBoard = (UINT)-1; m_pXfer = NULL; m_pSecurity = NULL; m_pWnvTUtil = NULL; m_pHadWrap = NULL; #ifdef WAITABLE_TIMER m_hEventTimer = NULL; #endif } CIrq::~CIrq () {} HANDLE CIrq::GetThread (void) { return m_hThread; } /////////////////////////////////////////////////////////////////////////////// // Method: Open // // Purpose: Close irq instance // // Parameter descriptions: none // // return: 0 = pass, else error code // /////////////////////////////////////////////////////////////////////////////// #define LOCAL_THREAD_EXIT_TIMEOUT 1000 DWORD CIrq::Close (void) { if (m_fStatusChangeRegistered) { HadCancelNotifyStatusChange (m_hBoardHandle, &m_PnPStatus); m_fStatusChangeRegistered = FALSE; } if (m_pHadWrap) { m_pHadWrap->Close (); delete m_pHadWrap; m_pHadWrap = NULL; } if (m_hBoardHandle) { HadDetachBoard (m_hBoardHandle); m_hBoardHandle = NULL; } if (m_PnPStatus.hNotifyEvent) { CloseHandle (m_PnPStatus.hNotifyEvent); m_PnPStatus.hNotifyEvent = NULL; } if (m_hEventEnd) { SetEvent (m_hEventEnd); // tell poll loop to exit if (m_hThread) WaitForSingleObject (m_hThread, LOCAL_THREAD_EXIT_TIMEOUT); CloseHandle (m_hEventEnd); m_hEventEnd = NULL; } if (m_pSecurity) { m_pSecurity->Close (); delete m_pSecurity; m_pSecurity = NULL; } if (m_pXfer) { m_pXfer->Close (); delete m_pXfer; m_pXfer = NULL; } if (m_hEventPollRecord) { CloseHandle (m_hEventPollRecord); m_hEventPollRecord = NULL; } if (m_hEventPollPlayback) { CloseHandle (m_hEventPollPlayback); m_hEventPollPlayback = NULL; } if (m_hEventVideo) { CloseHandle (m_hEventVideo); m_hEventVideo = NULL; } #ifdef WAITABLE_TIMER if (m_hEventTimer) { CancelWaitableTimer (m_hEventTimer); CloseHandle (m_hEventTimer); m_hEventTimer = NULL; } #endif if (m_pWnvTUtil) { if (m_dwNotify != (DWORD)-1) { TraceString ("\nCIrq::Close: WnvTUtil_DisableNotifyEvent..."); m_pWnvTUtil->WnvTUtil_DisableNotifyEvent (m_dwNotify); TraceString ("\nCIrq::Close: WnvTUtil_DeleteNotifyEvent..."); m_pWnvTUtil->WnvTUtil_DeleteNotifyEvent (m_dwNotify); m_dwNotify = (DWORD)-1; } TraceString ("\nCIrq::Close: WnvTUtil_DisconnectFromTimerProc..."); m_pWnvTUtil->WnvTUtil_DisconnectFromTimerProc (); TraceString ("\nDone.\n"); delete m_pWnvTUtil; m_pWnvTUtil = NULL; } if (m_hThread) { CloseHandle (m_hThread); m_hThread = NULL; } char buf[100]; sprintf (buf, "\nCIrq::Close(0x%x): Exit.", m_nBoard); TraceString (buf); return 0; } /////////////////////////////////////////////////////////////////////////////// ULONG WINAPI LocalThread (LPVOID lpInstance) { CIrq *pIrq = (CIrq *)lpInstance; return pIrq->Thread (); } /////////////////////////////////////////////////////////////////////////////// // Method: Open // // Purpose: open irq instance // // Parameter descriptions: none // // return: 0 = pass, else error code // /////////////////////////////////////////////////////////////////////////////// DWORD CIrq::Open (UINT nBoard, HANDLE hEventStop) { DWORD dwResult; TraceString ("\nCIrq::Open: nBoard="); TraceLong (nBoard); m_hEventStop = hEventStop; m_nBoard = nBoard; // create the thread for this board m_hThread = CreateThread ( m_pSecurity->GetSecurityAttributes (), // pointer to thread security attributes 0x4000, // initial thread stack size, in bytes LocalThread, // pointer to thread function this, // argument for new thread CREATE_SUSPENDED, // creation flags &m_dwThreadId); // pointer to returned thread identifier if (!m_hThread) { DWORD dw = GetLastError (); LogEvent (dw, L"\n********** CIrq::Open: CreateThread failed"); Close (); return dw; } dwResult = ResumeThread (m_hThread); if (dwResult == (DWORD)-1) return 1; // fail return 0; } /////////////////////////////////////////////////////////////////////////////// // Initialize CIrq class from thread /////////////////////////////////////////////////////////////////////////////// DWORD CIrq::Init (void) { DWORD dwResult; DWORD dw; WNVSTATUS status = STATUS_SUCCESS; BYTE bMinorType; BYTE bBoardType; m_pSecurity = new CSecurity; dwResult = m_pSecurity->Open (); if (dwResult) { LogEvent (dwResult, L"\n********** CIrq::Open: CSecurity::Open failed."); delete m_pSecurity; m_pSecurity = NULL; Close (); return dwResult; } m_hEventEnd = CreateEvent( m_pSecurity->GetSecurityAttributes (), // pointer to security attributes TRUE, // manual reset // flag for manual-reset event FALSE, // flag for initial state NULL); // pointer to event-object name if (!m_hEventEnd) { DWORD dw = GetLastError (); LogEvent (dw, L"\n********** Open: CreateEvent END failed, error="); TraceLong (dw); Close (); return dw; // failed } // // Create an event that is signalled during each pass of the video readout // m_hEventVideo = CreateEvent ( m_pSecurity->GetSecurityAttributes (), FALSE, FALSE, EVENT_WAVE_IRQ_READ_OUT_SYNC); if (!m_hEventVideo) { DWORD dw = GetLastError (); LogEvent (dw, L"\n********** Open: CreateEvent VIDEO failed, error="); TraceLong (dw); Close (); return dw; // failed } // // Create kernel linkage for this board // m_pHadWrap = new CHadWrap (m_nBoard); dwResult = m_pHadWrap->Open (); if (dwResult) { delete m_pHadWrap; m_pHadWrap = NULL; Close (); return dwResult; } // // create the hot insertion event // m_PnPStatus.hNotifyEvent = CreateEvent( m_pSecurity->GetSecurityAttributes (), // pointer to security attributes FALSE, // auto reset // flag for manual-reset event FALSE, // flag for initial state NULL); // pointer to event-object name if (!m_PnPStatus.hNotifyEvent) { DWORD dw = GetLastError (); LogEvent (dw, L"\n********** Open: CreateEvent m_PnPStatus.hNotifyEvent failed, error="); TraceLong (dw); Close (); return dw; // failed } // create the HAD instance to register the event with m_hBoardHandle = HadAttachBoard ((DWORD)m_nBoard); if (!m_hBoardHandle) { LogEvent (WNVERR_BOARD_NOT_ACTIVE, L"\n********** CIrq::Open: HadAttachBoard failed."); Close (); return WNVERR_BOARD_NOT_ACTIVE; } // register with the timer service utility, don't want event notifications // this is necessary to get the timer service to clear the // interrupt status register m_pWnvTUtil = new CWnvTUtil; if (!m_pWnvTUtil->WnvTUtil_ConnectToTimerProc (m_nBoard)) { DWORD dw = GetLastError (); char buf [100]; sprintf (buf, "CIrq::Init(0x%x): WnvTUtil_ConnectToTimerProc failed, status=0x%x", m_nBoard, dw); TraceString (buf); LogEvent (dw, L"\n********** CIrq::Init: WnvTUtil_ConnectToTimerProc failed."); delete m_pWnvTUtil; m_pWnvTUtil = NULL; Close (); return dw; } m_dwNotify = m_pWnvTUtil->WnvTUtil_RegisterNotifyEvent (FALSE); if (m_dwNotify == (DWORD)-1) { DWORD dw = GetLastError (); char buf [100]; sprintf (buf, "CIrq::Init(0x%x): WnvTUtil_RegisterNotifyEvent failed, status=0x%x", m_nBoard, dw); TraceString (buf); LogEvent (dw, L"\n********** CIrq::Open: WnvTUtil_RegisterNotifyEvent failed"); Close (); return dw; // fail } TraceString ("\nCIrq::Open: dwNotify="); TraceLong (m_dwNotify); if (!m_pWnvTUtil->WnvTUtil_EnableNotifyEvent (m_dwNotify)) { DWORD dw = GetLastError (); LogEvent (dw, L"\n********** CIrq::Open:: WnvTUtil_EnableNotifyEvent failed, error="); TraceLong (dw); Close (); return dw; } // Register the PnP event m_PnPStatus.currStatus.hwState = HAD_HW_REMOVED; status = HadNotifyStatusChange (m_hBoardHandle, &m_PnPStatus); if (status != STATUS_SUCCESS) { LogEvent (status, L"\n********** CIrq::Open:: HadNotifyStatusChange failed."); Close (); return status; } m_fStatusChangeRegistered = TRUE; if (m_PnPStatus.currStatus.hwState != HAD_HW_INSERTED) { char buf [100]; sprintf (buf, "\nCIrq::Init(0x%x): Waiting for insertion.", m_nBoard); TraceString (buf); while (m_PnPStatus.currStatus.hwState != HAD_HW_INSERTED) { HANDLE hEvents[2]; //!!! not necessary HadGetHWStatus (m_hBoardHandle, &m_PnPStatus.currStatus); hEvents[0] = m_hEventStop; hEvents[1] = m_hEventEnd; dwResult = WaitForMultipleObjects ( 2, // number of handles in the object handle array hEvents, // pointer to the object-handle array FALSE, // wait any event LOCAL_WAIT_INSERTION_TIMEOUT); if (dwResult == (WAIT_OBJECT_0)) { TraceString ("\nCIrq::Init: Exit due to STOP event."); return 0; } if (dwResult == (WAIT_OBJECT_0+1)) { TraceString ("\nCIrq::Init: Exit due to END event."); return 0; } } } char buf [100]; sprintf (buf, "CIrq::Init: Board 0x%x is present...\n", m_nBoard); TraceString (buf); /////////////////////////////////////////////////////////////////////////// // Hardware access is allowed after this point. /////////////////////////////////////////////////////////////////////////// // // make sure that the audio hardware is present // check for VO board type // dwResult = m_pHadWrap->GetMinorType (&bMinorType); if (dwResult) { Close (); return dwResult; } if (bMinorType == MINORTYPE_VO) { LogEvent (0, L"\nWnvIrq32 Service: Videum Video Only (VO) Adaptor or Camera, no audio hardware."); Close (); return WNVERR_WNVIRQ_VO; // exit the service (only one card supported) } // // Turn off the prefetch on port 2. // This prevents audio break up on multiprocessor systems. // Note that the TSTMODE reg in WIMP does not support this. // dwResult = m_pHadWrap->GetBoardType (&bBoardType); if (dwResult) { Close (); return dwResult; } if (bBoardType < TYPE_WIMPCAM1) { dwResult = m_pHadWrap->WriteWaviReg (WNVHW_PORT_TSTMODE, 0xffe7); if (dwResult) { Close (); return dwResult; } } // // create the Xfer object for moving data to/from the card // m_pXfer = new CXfer (); dw = m_pXfer->Open (m_nBoard); if (dw) { delete m_pXfer; m_pXfer = NULL; LogEvent (dw, L"\n********** CIrq::Open: CXfer->Open failed."); Close (); return dw; } TCHAR szEvent [100]; TCHAR szNumber [32]; // create the poll events: EventName + board number szEvent [0] = 0; _tcscat (szEvent, EVENT_WAVE_IRQ_POLL_RECORD); _itot (m_nBoard, szNumber, 10); _tcscat (szEvent, szNumber); m_hEventPollRecord = CreateEvent( m_pSecurity->GetSecurityAttributes (), FALSE, FALSE, szEvent); if (!m_hEventPollRecord) { DWORD dw = GetLastError (); LogEvent (dw, L"\n********** Open: CreateEvent POLL RECORD failed, error="); TraceLong (dw); Close (); return dw; // failed } szEvent [0] = 0; _tcscat (szEvent, EVENT_WAVE_IRQ_POLL_PLAYBACK); _itot (m_nBoard, szNumber, 10); _tcscat (szEvent, szNumber); m_hEventPollPlayback = CreateEvent( m_pSecurity->GetSecurityAttributes (), FALSE, FALSE, szEvent); if (!m_hEventPollPlayback) { DWORD dw = GetLastError (); LogEvent (dw, L"\n********** Open: CreateEvent POLL PLAYBACK failed, error="); TraceLong (dw); Close (); return dw; // failed } return 0; // pass } /////////////////////////////////////////////////////////////////////////////// #ifdef DO_TIME typedef unsigned __int64 UINT64; UINT64 MyTime (void) { UINT64 n; n = 50000; QueryPerformanceCounter ((LARGE_INTEGER *)&n); return n; } UINT64 TicksPerMS (void) { UINT64 n; n = 1000; QueryPerformanceFrequency ((LARGE_INTEGER *)&n); return n / 1000; // convert from ticks/sec to ticks/millisecond } #endif /////////////////////////////////////////////////////////////////////////////// // Method: Thread // // Purpose: This method implements the "run time" portion of the service. // // Parameters: // // hEventStop: event handle which is used to signal a Stop service request. // // returns: 0 if OK, else an error code. /////////////////////////////////////////////////////////////////////////////// #define NEVENTS 2 DWORD CIrq::Thread (void) { BOOL fEnabled; DWORD dwResult; HANDLE hEvents[NEVENTS+1]; TraceString ("\nCIrq::Thread..."); dwResult = Init (); if (dwResult) return dwResult; if (!m_pXfer) { LogEvent (1, L"\nCIrq::Thread: no hardware associated with thread, exiting."); return 1; } // Set thread priority to max possible for process class if (!SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_TIME_CRITICAL)) { // not a critical failure TraceString ("\n>>>>>>>>>> CIrq::Poll: SetThreadPriorty failed (ignored)"); } // // only allow this thread to execute on a single processor // this is necesssary in order for the time stamping to work // dwResult = SetThreadAffinityMask (m_hThread, 1); if (!dwResult) { LogEvent (dwResult, L"\nCIrq::Thread: SetThreadAffinityMask failed."); return 2; } fEnabled = TRUE; while (fEnabled) { hEvents[0] = m_hEventStop; hEvents[1] = m_hEventEnd; dwResult = WaitForMultipleObjects ( NEVENTS, // number of handles in the object handle array hEvents, // pointer to the object-handle array FALSE, // wait any event m_pXfer->GetPollTime ()); // time-out interval in milliseconds if (dwResult == (WAIT_OBJECT_0)) { TraceString ("\nCIrq::Thread: Exit due to STOP event."); return 0; } if (dwResult == (WAIT_OBJECT_0+1)) { TraceString ("\nCIrq::Thread: Exit due to END event."); return 0; } if (m_PnPStatus.currStatus.hwState == HAD_HW_REMOVED) { // // Hardware removed // DWORD dwTime; dwTime = GetCurrentTime (); m_pXfer->HardwareRemoval (); TraceString ("\n**********CIrq::Thread: Hardware Removed at "); TraceLong (dwTime); TraceString ("\n**********CIrq::Thread: Waiting for hardware insertion...\n"); // // Wait for hardware insertion // while (m_PnPStatus.currStatus.hwState != HAD_HW_INSERTED) { hEvents[0] = m_hEventStop; hEvents[1] = m_hEventEnd; hEvents[2] = m_PnPStatus.hNotifyEvent; dwResult = WaitForMultipleObjects ( NEVENTS+1, // number of handles in the object handle array hEvents, // pointer to the object-handle array FALSE, // wait any event LOCAL_WAIT_INSERTION_TIMEOUT); if (dwResult == (WAIT_OBJECT_0)) { TraceString ("\nCIrq::Thread: Exit due to STOP event."); return 0; } if (dwResult == (WAIT_OBJECT_0+1)) { TraceString ("\nCIrq::Thread: Exit due to END event."); return 0; } } // // Hardware inserted // dwTime = GetCurrentTime (); m_pXfer->HardwareInsertion (); TraceString ("\n**********CIrq::Thread: Hardware Inserted at "); TraceLong (dwTime); LogEvent (HAD_HW_INSERTED, L"Videum Hardware Inserted."); } Tick (); // generate a clock SetEvent (m_hEventVideo); // tell video readout to continue } TraceString ("\nCIrq::Thread: normal termination."); return 0; } /////////////////////////////////////////////////////////////////////////////// // Private Method: Tick // // Purpose: Implement per clock tick functions. // // Parameters: none // // return: None /////////////////////////////////////////////////////////////////////////////// void CIrq::Tick (void) { if (m_pXfer) { if (!m_pXfer->Tick ()) { SetEvent (m_hEventPollPlayback); SetEvent (m_hEventPollRecord); } } } /////////////////////////////////////////////////////////////////////////////// // End of File ///////////////////////////////////////////////////////////////////////////////