// SampDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Samp.h"
#include "SampDlg.h"
#include "AIOWDM.h"
#include "ACCES32.h"

#include "TIRQThread.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDD_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSampDlg dialog

CSampDlg::CSampDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CSampDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CSampDlg)
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CSampDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CSampDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CSampDlg, CDialog)
	//{{AFX_MSG_MAP(CSampDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_CBN_SELCHANGE(IDC_CardCombo, OnSelchangeCardCombo)
	ON_BN_CLICKED(IDC_GENIRQ, OnGenIRQ)
	ON_BN_CLICKED(IDC_ABORT, OnAbort)
	ON_WM_CLOSE()
	ON_BN_CLICKED(IDC_COS, OnCos)
	ON_BN_CLICKED(IDC_WDG_IRQ, OnWdgIrq)
	ON_BN_CLICKED(IDC_WDG_TST, OnWdgTst)
	ON_WM_TIMER()
	ON_BN_CLICKED(IDC_WDG_CAN, OnWdgCan)
	ON_BN_CLICKED(IDC_READTEMP, OnReadtemp)
	ON_BN_CLICKED(IDC_READSTATUS, OnReadstatus)
	ON_BN_CLICKED(IDC_REBOOT, OnReboot)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSampDlg message handlers

BOOL CSampDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Add "About..." menu item to system menu.

	// IDM_ABOUTBOX must be in the system command range.
/*	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	} */

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon

   if (InPortB(0x61) == 0xAA55) {
      MessageBox("ACCESNT.SYS not detected. Please copy ACCESNT.SYS into [NT]/system32/drivers and re-run this sample.", "Warning", MB_OK);
   }
	
	// Setting CardData to 0 as needed
    int count,I;
    for(count = 0; count < 10; count++) {
      CardData[count].Base = 0;
      CardData[count].PPIs = 0;
      CardData[count].IRQCount = 0;
      CardData[count].WDGPets = 0;
	  CardData[count].IsWDG = FALSE;
	  for(I = 0; I < 4; I++) {
	    CardData[count].LastCOSData[I].A = 0;
	    CardData[count].LastCOSData[I].B = 0;
	    CardData[count].LastCOSData[I].C = 0;
	  }
	};

	// Beginning Init for program 

	signed int NumCards, CardNum;
    unsigned long DeviceID, Base;
    unsigned long NameSize;
    UCHAR Name[256];
	char BaseHex[25];
	CButton GenIRQButton;

	CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 
    pCBox->ResetContent();
  	NumCards = GetNumCards();
	ThereCanBeOnlyOne = FALSE;
       

    if (NumCards == 0) {       
	  UpdateButtonUI();   
      GetDlgItem(IDC_LOGMEMO)->SetWindowText(_T("No cards found. The cards may not be installed, or they may be installed using a driver other than AIOWDM.sys."));
	} else {
    for (CardNum = 0; CardNum != NumCards; CardNum++) {
	  CardData[CardNum].IsWDG = FALSE;
      NameSize = 256;
      QueryCardInfo(CardNum, &DeviceID, &Base, &NameSize, Name);
	  sprintf( BaseHex, "%s [%4x]",Name, Base);
      pCBox->AddString(BaseHex);
      CardData[CardNum].Base = Base;
      switch (DeviceID) {
        case 0x0E50: //PCI-DIO-24S
          CardData[CardNum].PPIs = 1;
        break;
        case 0x0E60: //PCI-DIO-48S
          CardData[CardNum].PPIs = 2;
        break;
        case 0x22C0: case 0x25C0: case 0x2FC0: case 0x2FC1: //PCI-WDG-CSM, P104-WDG-E, P104-WDG-CSM, and P104-WDG-CSMA
          CardData[CardNum].IsWDG = TRUE;
          WDGInit(CardNum);
        break;
      }
	  if (CardData[CardNum].PPIs != 0){
        CardData[CardNum].Log =
           ("AIOWDM provides generic IRQ-handling functions for all cards "
            "and special IRQ-handling functions for COS cards like this one. \r\n\r\n"
            "Click 'Detect Generic IRQs' to handle IRQs generically for the card selected above, "
            "or 'Detect COS IRQs' to handle IRQs for the card selected above by updating COS data. \r\n\r\n");
	  }       
	  else {
      if (CardData[CardNum].IsWDG){
        CardData[CardNum].Log =
           ("AIOWDM provides generic IRQ-handling functions for all cards "
            "and special functions for watchdog cards like this one.\r\n\r\n"
            "Click 'Detect Generic IRQs' to handle IRQs generically for the card selected above, "
            "or 'Handle Watchdog IRQ' to handle the next IRQ for the card selected above with the selected action.\r\n\r\n"
            "You can also click 'Test Watchdog Timing' to set the watchdog timer, pet it a few times, then let it time out, "
            "'Read Temp' to read the temperature(if installed),"
            "'Read Status' to read the card''s status byte,"
            "or 'Reboot' to quickly reboot your computer.\r\n\r\n");
      }
      else {
        CardData[CardNum].Log =
            ("AIOWDM provides generic IRQ-handling functions for all cards. \r\n\r\n"
             "Click 'Detect Generic IRQs' to handle IRQs for the card selected above.\r\n\r\n");
      }}
    }
	CButton* pCSoft = (CButton*)GetDlgItem(IDC_S_RESTART);
    pCSoft->SetCheck(1);
    pCBox->SetCurSel(0);
    OnSelchangeCardCombo();
	}

	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CSampDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CSampDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CSampDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

void CSampDlg::OnSelchangeCardCombo() 
{
	unsigned long I;
    char CosHolder[25]; 
	CString FinalHolder;
	CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 
	CEdit* pCEdit = (CEdit*)GetDlgItem(IDC_LOGMEMO); 

    int CardNum = pCBox->GetCurSel();
    GetDlgItem(IDC_LOGMEMO)->SetWindowText(CardData[CardNum].Log);
	pCEdit->SetSel(0, -1, FALSE);
	

	//Generic IRQs
    if (CardData[CardNum].IRQCount == 0){
       GetDlgItem(IDC_GENIRQLABEL)->SetWindowText("");
	}
    else {
	   char Holder[25];
       sprintf(Holder, "%d IRQ(s) detected",CardData[CardNum].IRQCount);
       GetDlgItem(IDC_GENIRQLABEL)->SetWindowText(Holder);
	}
    //COS IRQs
    if (CardData[CardNum].PPIs != 0) {
	   sprintf(CosHolder, " ");
       for (I = 0; I < CardData[CardNum].PPIs; I++) {
          sprintf(CosHolder, "  %2x  %2x  %2x",CardData[CardNum].LastCOSData[I].A, CardData[CardNum].LastCOSData[I].B, CardData[CardNum].LastCOSData[I].C);          
	      FinalHolder = FinalHolder + CosHolder;
          OutPortB(CardData[CardNum].Base+11,0x00);
	   }
	   FinalHolder.MakeUpper();
	   GetDlgItem(IDC_COSIRQLABEL)->SetWindowText(FinalHolder);
       GetDlgItem(IDC_COS)->EnableWindow(TRUE);
	}
    else UpdateCOSUI();
    //Hide watchdog stuff if it's not a watchdog card
    UpdateWDGUI(CardData[CardNum].IsWDG);
    GetDlgItem(IDC_TEMP)->SetWindowText("");
    GetDlgItem(IDC_STATUS)->SetWindowText("");
}


void CSampDlg::UpdateButtonUI()
{
    GetDlgItem(IDC_GENIRQ)->EnableWindow(FALSE);
    GetDlgItem(IDC_ABORT)->EnableWindow(FALSE);
}



void CSampDlg::UpdateCOSUI()
{
    GetDlgItem(IDC_COS)->EnableWindow(FALSE);
	GetDlgItem(IDC_COSIRQLABEL)->SetWindowText("");
}

void CSampDlg::UpdateWDGUI(BOOL EnabWdg)
{
    GetDlgItem(IDC_WDG_IRQ)->EnableWindow(EnabWdg);
    GetDlgItem(IDC_MS_RESTART)->EnableWindow(EnabWdg);
    GetDlgItem(IDC_S_RESTART)->EnableWindow(EnabWdg);
    GetDlgItem(IDC_DN_RESTART)->EnableWindow(EnabWdg);
    GetDlgItem(IDC_DIS_WDG)->EnableWindow(EnabWdg);
    GetDlgItem(IDC_WDG_TST)->EnableWindow(EnabWdg);
    GetDlgItem(IDC_WDG_CAN)->EnableWindow(EnabWdg);
    GetDlgItem(IDC_READTEMP)->EnableWindow(EnabWdg);
    GetDlgItem(IDC_READSTATUS)->EnableWindow(EnabWdg);
	GetDlgItem(IDC_REBOOT)->EnableWindow(EnabWdg);
}

void CSampDlg::OnGenIRQ() 
{   
	CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 

    int CardNum = pCBox->GetCurSel();
    
	if (ThereCanBeOnlyOne == FALSE) {
	  Thrd = (TIRQThread*)AfxBeginThread(RUNTIME_CLASS(TIRQThread),THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
      Thrd->SetOwner(this);
	  Thrd->COSPPIs = 0;
      Thrd->CardNum = CardNum;
      Thrd->ResumeThread();
      AddLine(CardNum, "Detecting generic IRQs; generate IRQs to see this sample count them. Press 'Abort IRQ Detect' to cancel when done.");
	  ThereCanBeOnlyOne = TRUE;
	}
}

void CSampDlg::OnCos() 
{   
	CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 

    int CardNum = pCBox->GetCurSel();
	if (!ThereCanBeOnlyOne) {
	  Thrd = (TIRQThread*)AfxBeginThread(RUNTIME_CLASS(TIRQThread),THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
      Thrd->SetOwner(this);
	  Thrd->COSPPIs = CardData[CardNum].PPIs;
      Thrd->CardNum = CardNum;
      Thrd->ResumeThread();
      AddLine(CardNum, "Detecting COS IRQs; change the input data to see the COS data update. Press 'Abort IRQ Detect' to cancel when done.");
	  ThereCanBeOnlyOne = TRUE;
	}	  
}

void CSampDlg::AddLine(int CardNum, CString Line)
{
	CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 

    CardData[CardNum].Log = (CardData[CardNum].Log + Line + "\r\n\r\n");
    if (CardNum == pCBox->GetCurSel()) OnSelchangeCardCombo();
}

void CSampDlg::ReceiveCOSData(int CardNum, TCOSData COSData[])
{
    unsigned long I;
	CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 

    for (I = 0; I < CardData[CardNum].PPIs; I++) {
       CardData[CardNum].LastCOSData[I].A = COSData[I].A;
       CardData[CardNum].LastCOSData[I].B = COSData[I].B;
       CardData[CardNum].LastCOSData[I].C = COSData[I].C;
	}
    if (CardNum == pCBox->GetCurSel()) OnSelchangeCardCombo();
}

void CSampDlg::ReceiveGenIRQ(int CardNum)
{
	CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 

    CardData[CardNum].IRQCount++;
    if (CardNum == pCBox->GetCurSel()) OnSelchangeCardCombo();
}

void CSampDlg::OnAbort() 
{
	CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 

    int CardNum = pCBox->GetCurSel();

	if (AbortRequest(CardNum) != 0 ) {
       AddLine(CardNum, "Aborting IRQ detection...");
	   ThereCanBeOnlyOne = FALSE;
	}
    else
       AddLine(CardNum, "No IRQ request to abort.");
}

void CSampDlg::OnClose() 
{
  int CardNum; 

  /*
    Abort all pending IRQ requests. If we don't do this before exiting, later
    when an IRQ comes in or somebody else calls AbortRequest the pending IRQ
    request will attempt to unlock a thread that no longer exists, which is bad.

    (We can AbortRequest for a card with no pending requests, it'll just tell us
    that, and it's easier than remembering which cards have pending requests.)
  */
      
  for (CardNum = 0; CardNum < GetNumCards(); CardNum++)
    AbortRequest(CardNum);
	
  CDialog::OnClose();
}


void CSampDlg::OnWdgIrq() 
{
  unsigned long Action;
  CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 
  CButton* pCSoft = (CButton*)GetDlgItem(IDC_S_RESTART);
  CButton* pCMSoft = (CButton*)GetDlgItem(IDC_MS_RESTART);
  CButton* pCDis = (CButton*)GetDlgItem(IDC_DIS_WDG);
  int CardNum = pCBox->GetCurSel();

  if ((pCSoft->GetState() & 0x0003) == 1) 
     Action = WDG_ACTION_SOFT_RESTART;
  else if ((pCMSoft->GetState() & 0x0003) == 1) 
     Action = WDG_ACTION_MOSTLY_SOFT_RESTART;
  else
     Action = WDG_ACTION_IGNORE; 

  if ((pCDis->GetState() & 0x0003) == 1) 
    Action = Action + WDG_ACTION_DISABLE;

  WDGHandleIRQ(CardNum, Action);

  AddLine(CardNum, "Watchdog IRQ handler started, press 'Abort IRQ Detect' to cancel.");	
}

void CSampDlg::OnWdgTst() 
{
  CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 

  int CardNum = pCBox->GetCurSel();
  WDGSetTimeout(CardNum, 2 * 1000, PCI_WDG_CSM_RATE); //2 sec timeout, infinite reset
  //WDGSetResetDuration(CardNum, 31, PCI_WDG_CSM_RATE); //31 ms reset
  WDGStart(CardNum);
  InPortB(CardData[CardNum].Base + 9);

  AddLine(CardNum, "Watchdog timing started...");
  CardData[CardNum].WDGPets = 0;
  WDGCardNum = CardNum;
  WDGPetTimer = SetTimer(1, 1000, 0);
}  
    
void CSampDlg::OnTimer(UINT nIDEvent) 
{
	char CharHolder[50];
    if (nIDEvent == 1) {
	   
       if (InPortB(CardData[WDGCardNum].Base + 4) & 0x01 == 0) {
		  AddLine(WDGCardNum, "Watchdog timed out early!");
		  OnStopTimer();
	   return;
	   }

       CardData[WDGCardNum].WDGPets++;
       if (CardData[WDGCardNum].WDGPets >= 4) {
          AddLine(WDGCardNum, "Waiting for timeout...");
		  OnStopTimer();
          WDGWaitTimer = SetTimer(2, 100, 0);
	   }
       else {
          WDGPet(WDGCardNum);
          sprintf(CharHolder, "Petting watchdog, pet %d of 3...",CardData[WDGCardNum].WDGPets);   
          AddLine(WDGCardNum, CharHolder);
	   }
	} else {
	   if (InPortB(CardData[WDGCardNum].Base + 4) & 0x01 == 0) {
       AddLine(WDGCardNum, "Watchdog timed out.");
       OnStopTimer();
	   }
	}

	CDialog::OnTimer(nIDEvent);
}

void CSampDlg::OnStopTimer()
{
   KillTimer(WDGPetTimer);   
   KillTimer(WDGWaitTimer);   
}

void CSampDlg::OnWdgCan() 
{
  CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 

  int CardNum = pCBox->GetCurSel();
  WDGStop(CardNum);
  OnStopTimer();
  AddLine(CardNum, "Watchdog timing cancelled.");	
}

void CSampDlg::OnReadtemp() 
{
  char Holder[5];
  CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 

  int CardNum = pCBox->GetCurSel();

  sprintf(Holder, "%2.1f",WDGReadTemp(CardNum));  
  GetDlgItem(IDC_TEMP)->SetWindowText(Holder);
  
}

void CSampDlg::OnReadstatus() 
{
  char Holder[5];
  CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 

  int CardNum = pCBox->GetCurSel();

  sprintf(Holder, "%2x",WDGReadStatus(CardNum));  
  GetDlgItem(IDC_STATUS)->SetWindowText(Holder);
}

void CSampDlg::OnReboot() 
{
  CComboBox* pCBox = (CComboBox*)GetDlgItem(IDC_CardCombo); 
 
  int CardNum = pCBox->GetCurSel();
 
 // if (EmergencyReboot != 0)
    AddLine(CardNum, "Rebooting...");
  //else
//    AddLine(CardNum, "Reboot failed.");	
}