#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <time.h>
#include <dos.h>

void OutPortL(unsigned Port, unsigned long Value);

typedef char* PChar;
const PChar VM = (PChar)MK_FP(0xB800, 0);



typedef struct
{
  unsigned short VID;
  unsigned short DID;
  unsigned short Base[4];
  unsigned char IRQ;
} TCard;

typedef union
{
  struct
  {
    unsigned char Addr;
    unsigned char Function: 3;
    unsigned char Device: 5;
    unsigned char Bus;
    unsigned char Header;
  } P;
  unsigned long Trans;
} TCardTrans;



TCard DetectedCard[20];
unsigned DetectedCards = 0;



void Put12Spaces(void)
{
  cputs("            ");
}

void PutWordPadded(unsigned short Data)
{
  char HexChar[16] = "0123456789ABCDEF";

  putch(HexChar[(Data >> 12) & 0xF]);
  putch(HexChar[(Data >>  8) & 0xF]);
  putch(HexChar[(Data >>  4) & 0xF]);
  putch(HexChar[(Data      ) & 0xF]);
  cputs("        ");
}

void PutWord(unsigned short Data)
{
  char HexChar[16] = "0123456789ABCDEF";
  int Set = 0;

  if ( Data & 0xF000        ) { putch(HexChar[(Data >> 12) & 0xF]); Set = -1; }
  if ( Data & 0x0F00 || Set ) { putch(HexChar[(Data >>  8) & 0xF]); Set = -1; }
  if ( Data & 0x00F0 || Set )   putch(HexChar[(Data >>  4) & 0xF]);
                                putch(HexChar[(Data      ) & 0xF]);
}

void SetLineColor(unsigned dLine, unsigned char Color)
{
  PChar mSel = VM + 160 * dLine + 1;
  for ( int I = 0; I < 11 * 6; ++I )
    mSel[I * 2] = Color
  ;
}

void SetCellColor(unsigned dLine, unsigned Col, unsigned char Color)
{
  PChar mSel = VM + 160 * dLine + 16 * Col + 1;
  for ( int I = 0; I < 4; ++I )
    mSel[I * 2] = Color
  ;
}

unsigned short ValBase(unsigned short Base)
{
  if ( Base & 1 )
    return Base & 0xFFFE;
  else
    return 0
  ;
}

signed short AskForCard(void)
{
  textattr(0x07);

  {
    for ( int I = 0; I < sizeof(DetectedCard); ++I )
    {
      //*(PChar(DetectedCard) + I) = 0xDC;
      (PChar(DetectedCard))[I] = 0xDC;
    }
  }

  {
    int Bus, Device;
    TCardTrans Trans;

    cputs("Loading card data...\r\n");

    Trans.P.Header = 0x80;
    Trans.P.Addr = 0;
    Trans.P.Function = 0;
    for ( Bus = 0; Bus < 256; ++Bus )
    {
      Trans.P.Bus = Bus;
      int FoundOnBus = 0;
      for ( Device = 0; Device < 32; ++Device )
      {
        Trans.P.Device = Device;
        OutPortL(0xCF8, Trans.Trans);
        DetectedCard[DetectedCards].VID = inport(0xCFC);
        if ( DetectedCard[DetectedCards].VID == 0xFFFF )
        {
          //if ( Device == 0 ) break;
          continue;
        }
        FoundOnBus = -1;
        //cprintf("%04X\r\n", DetectedCard[DetectedCards].VID);
        if ( DetectedCard[DetectedCards].VID != 0x494F ) continue;

        DetectedCard[DetectedCards].DID = inport(0xCFE);
        //Retrieve base addresses 2-5, which become 0-3
        OutPortL(0xCF8, Trans.Trans | 0x18);
        DetectedCard[DetectedCards].Base[0] = ValBase(inport(0xCFC));
        OutPortL(0xCF8, Trans.Trans | 0x1C);
        DetectedCard[DetectedCards].Base[1] = ValBase(inport(0xCFC));
        OutPortL(0xCF8, Trans.Trans | 0x20);
        DetectedCard[DetectedCards].Base[2] = ValBase(inport(0xCFC));
        OutPortL(0xCF8, Trans.Trans | 0x24);
        DetectedCard[DetectedCards].Base[3] = ValBase(inport(0xCFC));
        OutPortL(0xCF8, Trans.Trans | 0x3C);
        DetectedCard[DetectedCards].IRQ = inportb(0xCFC);
        ++DetectedCards;
        if ( DetectedCards == 20 ) goto Dun;
      }
      if ( !FoundOnBus ) break;
    }
    Dun: ;
  }

  clrscr();

  {
    if ( DetectedCards == 0 )
    {
      cputs("No cards were found! Exiting.\r\n\r\n");
      exit(1);
    }

    cputs("Select a card from this list, or hit Escape to exit.\r\n\r\n");
    cputs("DevID       Base[2]     Base[3]     Base[4]     Base[5]     IRQ\r\n");

    for ( int I = 0; I < DetectedCards; ++I )
    {
      PutWordPadded(DetectedCard[I].DID);
      if ( DetectedCard[I].Base[0] )
        PutWordPadded(DetectedCard[I].Base[0]);
      else
        Put12Spaces()
      ;
      if ( DetectedCard[I].Base[1] )
        PutWordPadded(DetectedCard[I].Base[1]);
      else
        Put12Spaces()
      ;
      if ( DetectedCard[I].Base[2] )
        PutWordPadded(DetectedCard[I].Base[2]);
      else
        Put12Spaces()
      ;
      if ( DetectedCard[I].Base[3] )
        PutWordPadded(DetectedCard[I].Base[3]);
      else
        Put12Spaces()
      ;
      if ( DetectedCard[I].IRQ != 0xFF )
        PutWord(DetectedCard[I].IRQ)
      ;
      cputs("\r\n");
    }
  }

  int CurSel = 0;//, XSel = 1;
  while(-1)
  {
    //SetCellColor(2 + CurSel, XSel, 0x1F);
    SetLineColor(3 + CurSel, 0x1F);
    char Key = getch();
    //SetCellColor(2 + CurSel, XSel, 0x07);
    SetLineColor(3 + CurSel, 0x07);
    switch(Key)
    {
      case 0:
        switch(getch())
        {
          case 'H':
            if ( CurSel > 0 ) --CurSel;
          break;

          case 'P':
            if ( CurSel < DetectedCards - 1 ) ++CurSel;
          break;

          //case 'K':
          //  if ( XSel > 1 ) --XSel;
          //break;
          //
          //case 'M':
          //  if ( XSel < 4 ) ++XSel;
          //break;

          case 'G':
            CurSel = 0;
          break;

          case 'O':
            CurSel = DetectedCards - 1;
          break;
        }
      break;

      case 32: case 13:
        return CurSel;
        //if ( (XSel == 1) && DetectedCard[CurSel].Base0 ) return DetectedCard[CurSel].Base0;
        //if ( (XSel == 2) && DetectedCard[CurSel].Base1 ) return DetectedCard[CurSel].Base1;
        //if ( (XSel == 3) && DetectedCard[CurSel].Base2 ) return DetectedCard[CurSel].Base2;
        //if ( (XSel == 4) && DetectedCard[CurSel].Base3 ) return DetectedCard[CurSel].Base3;
        //sound(1000);
        //delay(100);
        //nosound();
      //break;

      case 27:
        //exit(0);
        return -1;
      //break;
    }
  }
}



#pragma inline
unsigned long InPortL(unsigned Port)
{
  register unsigned long Value;
  asm {
    mov dx,[Port]
    in eax,dx
    mov [Value],eax
  }
  return Value;
}

void OutPortL(unsigned Port, unsigned long Value)
{
  asm {
    mov dx,[Port]
    mov eax,[Value]
    out dx,eax
  }
}



unsigned short DoDetect(signed short Startoff, unsigned short* BaseA)
{
  signed short Result = AskForCard();
  if ( Result == -1 ) return 0;
  *BaseA = DetectedCard[Result].Base[Startoff];
  return 1;
}

unsigned short DoDetect(signed short Startoff, unsigned short* BaseA, unsigned char* IRQLine)
{
  signed short Result = AskForCard();
  if ( Result == -1 ) return 0;
  *BaseA = DetectedCard[Result].Base[Startoff];
  *IRQLine = DetectedCard[Result].IRQ;
  return 1;
}

unsigned short DoDetect(signed short Startoff, unsigned short* BaseA, unsigned short* BaseB)
{
  signed short Result = AskForCard();
  if ( Result == -1 ) return 0;
  *BaseA = DetectedCard[Result].Base[Startoff];
  *BaseB = DetectedCard[Result].Base[Startoff + 1];
  return 1;
}

unsigned short DoDetect(signed short Startoff, unsigned short* BaseA, unsigned short* BaseB, unsigned char* IRQLine)
{
  signed short Result = AskForCard();
  if ( Result == -1 ) return 0;
  *BaseA = DetectedCard[Result].Base[Startoff];
  *BaseB = DetectedCard[Result].Base[Startoff + 1];
  *IRQLine = DetectedCard[Result].IRQ;
  return 1;
}

unsigned short DoDetect(signed short Startoff, unsigned short* BaseA, unsigned short* BaseB, unsigned short* BaseC)
{
  signed short Result = AskForCard();
  if ( Result == -1 ) return 0;
  *BaseA = DetectedCard[Result].Base[Startoff];
  *BaseB = DetectedCard[Result].Base[Startoff + 1];
  *BaseC = DetectedCard[Result].Base[Startoff + 2];
  return 1;
}

unsigned short DoDetect(signed short Startoff, unsigned short* BaseA, unsigned short* BaseB, unsigned short* BaseC, unsigned char* IRQLine)
{
  signed short Result = AskForCard();
  if ( Result == -1 ) return 0;
  *BaseA = DetectedCard[Result].Base[Startoff];
  *BaseB = DetectedCard[Result].Base[Startoff + 1];
  *BaseC = DetectedCard[Result].Base[Startoff + 2];
  *IRQLine = DetectedCard[Result].IRQ;
  return 1;
}

unsigned short DoDetect(signed short Startoff, unsigned short* BaseA, unsigned short* BaseB, unsigned short* BaseC, unsigned short* BaseD)
{
  signed short Result = AskForCard();
  if ( Result == -1 ) return 0;
  *BaseA = DetectedCard[Result].Base[Startoff];
  *BaseB = DetectedCard[Result].Base[Startoff + 1];
  *BaseC = DetectedCard[Result].Base[Startoff + 2];
  *BaseD = DetectedCard[Result].Base[Startoff + 3];
  return 1;
}

unsigned short DoDetect(signed short Startoff, unsigned short* BaseA, unsigned short* BaseB, unsigned short* BaseC, unsigned short* BaseD, unsigned char* IRQLine)
{
  signed short Result = AskForCard();
  if ( Result == -1 ) return 0;
  *BaseA = DetectedCard[Result].Base[Startoff];
  *BaseB = DetectedCard[Result].Base[Startoff + 1];
  *BaseC = DetectedCard[Result].Base[Startoff + 2];
  *BaseD = DetectedCard[Result].Base[Startoff + 3];
  *IRQLine = DetectedCard[Result].IRQ;
  return 1;
}