{께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께�}
{ SB - Unit� gestion SB }
{께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께께�}
Unit SB;

INTERFACE {--Globals--------------------------------------------------------}

Var
  SBPort      : word;      {Port de base SB}
  SBIrq       : byte;      {Num굍o d'irq SB}
  SBDma       : byte;      {Canal dma SB}
  SBDmaDone   : boolean;   {Transfert dma termin� oui/non}

Procedure SBInit;                     {Installe handler d'irq}
Procedure SBDone;                     {UnInstalle handler}
Function  SBReset:BOOLEAN;            {Reset SB}
Function  SBDetect:BOOLEAN;           {Detect SB}
Function  SBVersion:WORD;             {Lit version DSP}
Procedure SBHpOn;                     {Allume HP}
Procedure SBHpOff;                    {Eteint HP}
Function  SBDirectIn:BYTE;            {Direct sample input}
Procedure SBDirectOut(Sample:BYTE);   {Direct sample output}
Procedure SBSetFreq(Freq:WORD);       {R둮le fr굌uence sampling}
Procedure SBDmaIn(Count:WORD;Address:POINTER);  {Lit sample via DMA}
Procedure SBDmaOut(Count:WORD;Address:POINTER); {Sort sample via DMA}
Procedure SBStopDma;                  {Stop transfert DMA}
Procedure SBContinueDma;              {Continue transfert DMA}

IMPLEMENTATION {--Locals----------------------------------------------------}

Uses DOS,DMA;

Const
   DSPReset      = $06;  {Port de reset}
   DSPRead       = $0a;  {Port de lecture}
   DSPWrite      = $0c;  {Port d'괹riture}
   DSPDataState  = $0e;  {Port d'굏at des donn괻s}

Var
  OldHandlerAddr  : pointer; {Ancien handler d'irq}

{께께� Low level routines - Lecture/Ecriture/Reset SB 께께께께께께께께께께께}

{같� SBREAD: Lit un octet sur la SB 같�}
Function SBRead:BYTE; assembler;
Asm
        mov     dx,[SBPort]
        or      dl,DSPDataState
  @SBRead_Wait:
          in      al,dx
          or      al,al
          jns     @SBRead_Wait
        and     dl,0f0h
        or      dl,DSPRead
        in      al,dx
End;

{같� SBWRITE: Ecrit un octet sur la SB 같�}
Procedure SBWrite(Data:BYTE); assembler;
Asm
        mov     dx,[SBPort]
        or      dl,DSPWrite
  @SBWrite_Wait:
          in      al,dx
          or      al,al
          js      @SBWrite_Wait
        mov     al,[Data]
        out     dx,al
End;

{굇� SBRESET: Balance un reset au DSP 굇�}
Function SBReset:BOOLEAN; assembler;
Asm
      {같 Envoie le reset 같}
        mov     dx,[SBPort]
        or      dl,DSPReset
        mov     al,1
        out     dx,al
          in      al,dx
          in      al,dx
          in      al,dx
          in      al,dx
        xor     al,al
        out     dx,al

      {같 Attend une r굋onse de la SB 같}
        and     dl,0f0h
        or      dl,DSPDataState
        mov     cx,256
  @SBReset_Wait:
          in      al,dx
          or      al,al
          js      @SBReset_Test
          loop    @SBReset_Wait
    @SBReset_Failed:
          mov     al,FALSE
          ret

      {같 Teste si on a bien affaire � un DSP 같}
  @SBReset_Test:
        and     dl,0f0h
        or      dl,DSPRead
        in      al,dx
        cmp     al,0aah
        jne     @SBReset_Failed
        mov     al,TRUE
End;

{께께� Autod굏ection de la SB 께께께께께께께께께께께께께께께께께께께께께께께}

{같� SBDetectPORT: D굏ecte le port de base SB 같�}
Function SBDetectPort:BOOLEAN;
Begin
   SBDetectPort:=FALSE;
   SBPort:=$210;
   Repeat
      If SBReset then
        Begin
           SBDetectPort:=TRUE;
           Exit;
        End;
      Inc(SBPort,$10);
   Until SBPort>$280;
End;

{같� SBDetectIRQ: D굏ecte l'irq SB 같�}
Function SBDetectIrq:BOOLEAN;
Const Irqs : array[0..4] of byte = (2,3,5,7,10);
Var
  IrqIndex : byte;
  IrqDelay : word;
Begin
   SBDetectIrq:=FALSE;
   SBHpOff;

   {같 Parcourt toutes les irqs possibles � travers IrqIndex 같}
   IrqIndex:=0;
   Repeat
      SBIrq:=Irqs[IrqIndex];
      SBInit;  {Installe handler}
      SBDmaOut($0002,NIL);  {Envoie un chti bloc}

      {같 Attend pour voir si la SB r굋ond 같}
      For IrqDelay:=0 to $ffff do
        If SBDmaDone then
          Begin
             SBDetectIrq:=TRUE;  {� Oui-> cool on a trouv�! �}
             Exit;
          End;

      {� Non-> alors irq suivante �}
      SBDone; {Uninstall handler}
      Inc(IrqIndex);
   Until IrqIndex > 4;
End;

{굇� SBDetect: Auto-d굏ecte les port,irq,dma SB 굇�}
Function SBDetect:BOOLEAN;
Begin
   SBDetect:=FALSE;
   SBDma:=1;        {Disons que ouais... (en g굈굍al c'est 놹..)}
   If not SBDetectPort then exit;
   If not SBDetectIrq then exit;
   SBDetect:=TRUE;
End;

{굇� SBVersion: Lit le num굍o de version du DSP 굇�}
Function SBVersion:WORD;
Begin
   SBWrite($E1);
   SBVersion:=SBRead+SBRead shl 8;
End;

{께께� Gestion du Haut-Parleur 께께께께께께께께께께께께께께께께께께께께께께�}

{굇� SBHpON: Allume le Haut-Parleur 굇�}
Procedure SBHpOn;
Begin
   SBWrite($D1);
End;

{굇� SBHpOFF: Eteint le Haut-Parleur 굇�}
Procedure SBHpOff;
Begin
   SBWrite($D3);
End;

{께께� Entr괻/Sortie directe de samples 께께께께께께께께께께께께께께께께께께}

{굇� SBDirectIN: Lit un sample direct from SB 굇�}
Function SBDirectIn:BYTE;
Begin
   SBWrite($20);
   SBDirectIn:=SBRead;
End;

{굇� SBDirectOut: Sort un sample direct to SB 굇�}
Procedure SBDirectOut(Sample:BYTE);
Begin
   SBWrite($10);
   SBWrite(Sample);
End;

{께께� Entr괻/Sortie de samples via DMA 께께께께께께께께께께께께께께께께께께}

{굇� SBSetFreq: R둮le la fr굌uence de sampling 굇�}
Procedure SBSetFreq(Freq:WORD);
Begin
   SBWrite($40);
   SBWrite(256-1000000 div Freq);
End;

{굇� SBDmaIn: Enregistre un sample via DMA 굇�}
Procedure SBDmaIn(Count:WORD;Address:POINTER);
Begin
   DMAInit(SBDma,DMARead,Count,Address);
   Dec(Count);
   SBDmaDone:=FALSE;
   SBWrite($24);
   SBWrite(Lo(Count));
   SBWrite(Hi(Count));
End;

{굇� SBDmaOut: Sort un sample via DMA 굇�}
Procedure SBDmaOut(Count:WORD;Address:POINTER);
Begin
   DMAInit(SBDma,DMAWrite,Count,Address);
   Dec(Count);
   SBDmaDone:=FALSE;
   SBWrite($14);
   SBWrite(Lo(Count));
   SBWrite(Hi(Count));
End;

{굇� SBStopDma: Stoppe le transfert DMA 굇�}
Procedure SBStopDma;
Begin
   SBWrite($D0);
End;

{굇� SBContinueDma: Continue un transfert DMA interrompu 굇�}
Procedure SBContinueDma;
Begin
   SBWrite($D4);
End;

{께께� Install/Uninstall handler d'irq 께께께께께께께께께께께께께께께께께께�}

{같� SBIrqHandler: Handler d'irq 같�}
Procedure SBIrqHandler; interrupt; assembler;
Asm
        mov     [SBDmaDone],TRUE

        mov     dx,[SBPort]     {Sert � que dalle mais c'est dans la doc...}
        or      dl,DSPDataState
        in      al,dx

        mov     al,20h
        cmp     [SBIrq],8
        jb      @SBLowIrq
        out     0a0h,al
  @SBLowIrq:
        out     020h,al
End;

{굇� SBInit: Installe le handler d'irq 굇�}
Procedure SBInit;
Begin
   If SBIrq<8 then
     Begin
        GetIntVec(SBIrq+$8,OldHandlerAddr);
        SetIntVec(SBIrq+$8,@SBIrqHandler);
        Port[$21]:=Port[$21] and (not (1 shl SBIrq));
     End
   Else
     Begin
        GetIntVec(SBIrq+$70,OldHandlerAddr);
        SetIntVec(SBIrq+$70,@SBIrqHandler);
        Port[$A1]:=Port[$A1] and (not (1 shl (SBIrq and 7)));
     End;
End;

{굇� SBDone: UnInstalle le handler d'irq 굇�}
Procedure SBDone;
Begin
   If SBIrq<8 then SetIntVec(SBIrq+$8,OldHandlerAddr)
              else SetIntVec(SBIrq+$70,OldHandlerAddr);
End;

End.