workbench/devs/AHI/Drivers/Envy24HT/interrupt.c

   1 /*
   2     Copyright © 2005-2013, Davy Wentzler. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <config.h>
   7
   8 #undef __USE_INLINE__
   9 #include <proto/expansion.h>
  10 #include <libraries/ahi_sub.h>
  11 #include <proto/exec.h>
  12 #include <stddef.h>
  13 //#include "library.h"
  14 #include "regs.h"
  15 #include "interrupt.h"
  16 #include "misc.h"
  17 #include "pci_wrapper.h"
  18
  19 #define min(a,b) ((a)<(b)?(a):(b))
  20
  21 #ifdef __MORPHOS__
  22 #undef CALLHOOK
  23 #define CALLHOOK CallHookA
  24 #endif
  25 #include <clib/alib_protos.h>
  26
  27 //int z = 0;
  28
  29 /******************************************************************************
  30 ** Hardware interrupt handler *************************************************
  31 ******************************************************************************/
  32
  33 #ifdef __AMIGAOS4__
  34 LONG
  35 CardInterrupt( struct ExceptionContext *pContext, struct ExecBase *SysBase, struct CardData* card )
  36 #else
  37 ULONG
  38 CardInterrupt( struct CardData* card )
  39 #endif
  40 {
  41   struct AHIAudioCtrlDrv* AudioCtrl = card->audioctrl;
  42
  43   unsigned char intreq;
  44   LONG  handled = 0;
  45
  46   if ( ( intreq = INBYTE(card->iobase + CCS_INTR_STATUS ) ) != 0 )
  47   {
  48     //DEBUGPRINTF("INT %x\n", intreq);
  49
  50     if (intreq & CCS_INTR_PLAYREC)
  51     {
  52        unsigned char mtstatus = INBYTE(card->mtbase + MT_INTR_STATUS);
  53
  54        if( (mtstatus & MT_PDMA0) && AudioCtrl != NULL && card->is_playing)
  55        {
  56          unsigned long diff = INLONG(card->mtbase + MT_DMAI_PB_ADDRESS) - (unsigned long) card->playback_buffer_phys;
  57
  58          OUTBYTE(card->mtbase + MT_INTR_STATUS, mtstatus | MT_PDMA0); // clear interrupt
  59
  60          /*if (z == 0)
  61             DEBUGPRINTF("MT_PDMA0, diff = %lu, %lu\n", diff, card->current_frames);
  62          z++;
  63          if (z == 5)
  64             z = 0;*/
  65
  66          if (diff >= card->current_bytesize) //card->flip == 0) // just played buf 1
  67          {
  68             card->flip = 1;
  69             card->current_buffer = card->playback_buffer;
  70             card->spdif_out_current_buffer = card->spdif_out_buffer;
  71             }
  72          else  // just played buf 2
  73          {
  74             card->flip = 0;
  75             card->current_buffer = (APTR) ((long) card->playback_buffer + card->current_bytesize);
  76             card->spdif_out_current_buffer = (APTR) ((long) card->spdif_out_buffer + card->current_bytesize / 2);
  77          }
  78
  79          card->playback_interrupt_enabled = FALSE;
  80          CAUSE( &card->playback_interrupt );
  81        }
  82
  83        if( ((mtstatus & MT_RDMA0) || (mtstatus & MT_RDMA1)) && AudioCtrl != NULL  && card->is_recording)
  84        {
  85          OUTBYTE(card->mtbase + MT_INTR_STATUS, mtstatus | MT_RDMA0 | MT_RDMA1); // clear interrupt
  86
  87          /*if (z == 0)
  88             DEBUGPRINTF("MT_RDMA%d\n", mtstatus);
  89          z++;
  90          if (z == 50)
  91             z = 0;*/
  92
  93          if( card->record_interrupt_enabled )
  94          {
  95             /* Invoke softint to convert and feed AHI with the new sample data */
  96
  97             if (card->recflip == 0) // just played buf 1
  98             {
  99                card->recflip = 1;
 100                card->current_record_buffer = card->record_buffer;
 101                card->current_record_buffer_32bit = card->record_buffer_32bit;
 102                }
 103             else  // just played buf 2
 104             {
 105                card->recflip = 0;
 106                card->current_record_buffer = (APTR) ((long) card->record_buffer + card->current_record_bytesize_32bit / 2);
 107                card->current_record_buffer_32bit = (APTR) ((long) card->record_buffer_32bit + card->current_record_bytesize_32bit);
 108             }
 109
 110             card->record_interrupt_enabled = FALSE;
 111             CAUSE( &card->record_interrupt );
 112          }
 113        }
 114
 115        if( (mtstatus & MT_DMA_FIFO) && AudioCtrl != NULL )
 116        {
 117             unsigned char status = INBYTE(card->mtbase + MT_DMA_UNDERRUN);
 118
 119             //DEBUGPRINTF("FIFO %x\n", status);
 120             WriteMask8(card, card->mtbase, MT_INTR_STATUS, MT_DMA_FIFO); // clear it
 121
 122             OUTBYTE(card->mtbase + MT_DMA_UNDERRUN, status);
 123             WriteMask8(card, card->mtbase, MT_INTR_MASK, MT_DMA_FIFO);
 124        }
 125
 126
 127        OUTBYTE(card->mtbase + MT_INTR_STATUS, mtstatus); // clear interrupt
 128        handled = 1;
 129     }
 130   }
 131
 132   return handled;
 133 }
 134
 135
 136 /******************************************************************************
 137 ** Playback interrupt handler *************************************************
 138 ******************************************************************************/
 139
 140 #ifdef __AMIGAOS4__
 141 void
 142 PlaybackInterrupt( struct ExceptionContext *pContext, struct ExecBase *SysBase, struct CardData* card )
 143 #else
 144 void
 145 PlaybackInterrupt( struct CardData* card )
 146 #endif
 147 {
 148   struct AHIAudioCtrlDrv* AudioCtrl = card->audioctrl;
 149
 150   if( card->mix_buffer != NULL && card->current_buffer != NULL && card->is_playing)
 151   {
 152     BOOL   skip_mix;
 153
 154     WORD*  src;
 155     int    i;
 156     LONG* srclong, *dstlong, *spdif_dstlong, left, right;
 157     int frames = card->current_frames;
 158
 159     skip_mix = CALLHOOK( AudioCtrl->ahiac_PreTimerFunc, (Object*) AudioCtrl, 0 );
 160     CALLHOOK( AudioCtrl->ahiac_PlayerFunc, (Object*) AudioCtrl, NULL );
 161
 162     //DEBUGPRINTF("skip_mix = %d\n", skip_mix);
 163
 164     if( ! skip_mix )
 165     {
 166       CALLHOOK( AudioCtrl->ahiac_MixerFunc, (Object*) AudioCtrl, card->mix_buffer );
 167     }
 168
 169     /* Now translate and transfer to the DMA buffer */
 170
 171     src     = card->mix_buffer;
 172
 173     srclong = (LONG*) card->mix_buffer;
 174     dstlong = (LONG*) card->current_buffer;
 175     spdif_dstlong = card->spdif_out_current_buffer;
 176
 177     i = frames;
 178 #if defined(__amigaos4__) || defined(__MORPHOS__)
 179     if (AudioCtrl->ahiac_Flags & AHIACF_HIFI)
 180     {
 181        while( i > 0 )
 182        {
 183          left = ((*srclong & 0xFF000000) >> 24) | ((*srclong & 0x00FF0000) >> 8) | ((*srclong & 0x0000FF00) << 8);
 184          *dstlong++ = *spdif_dstlong++ = left;
 185          srclong++;
 186
 187          right = ((*srclong & 0xFF000000) >> 24) | ((*srclong & 0x00FF0000) >> 8) | ((*srclong & 0x0000FF00) << 8);
 188          *dstlong++ = *spdif_dstlong++ = right;
 189          srclong++;
 190
 191          *dstlong++ = left; // L & R of 2nd stereo channel that is unused
 192          *dstlong++ = right;
 193
 194          --i;
 195        }
 196     }
 197     else
 198     {
 199       while( i > 0 )
 200        {
 201          *dstlong++ = *spdif_dstlong++ = (*src & 0xFF00) >> 16; srclong++;
 202          *dstlong++ = *spdif_dstlong++ = (*srclong & 0xFF000000) >> 16; srclong++;
 203
 204          *dstlong++ = 0; // L & R of 2nd stereo channel that is unused
 205          *dstlong++ = 0;
 206          --i;
 207        }
 208     }
 209 #ifdef __AMIGAOS4__
 210     IExec->CacheClearE(card->current_buffer, (ULONG) dstlong - (ULONG) card->current_buffer, CACRF_ClearD);
 211     IExec->CacheClearE(card->spdif_out_current_buffer, (ULONG) spdif_dstlong - (ULONG) card->spdif_out_current_buffer, CACRF_ClearD);
 212 #endif
 213 #else
 214     if (AudioCtrl->ahiac_Flags & AHIACF_HIFI)
 215     {
 216        while( i > 0 )
 217        {
 218          left = *srclong;
 219          *dstlong++ = *spdif_dstlong++ = left;
 220          srclong++;
 221
 222          right = *srclong;
 223          *dstlong++ = *spdif_dstlong++ = right;
 224          srclong++;
 225
 226          *dstlong++ = left; // L & R of 2nd stereo channel that is unused
 227          *dstlong++ = right;
 228
 229          --i;
 230        }
 231     }
 232     else
 233     {
 234       while( i > 0 )
 235        {
 236          *dstlong++ = *spdif_dstlong++ = (*src); src++;
 237          *dstlong++ = *spdif_dstlong++ = (*src); src++;
 238
 239          *dstlong++ = 0; // L & R of 2nd stereo channel that is unused
 240          *dstlong++ = 0;
 241          --i;
 242        }
 243     }
 244 #endif
 245
 246     CALLHOOK( AudioCtrl->ahiac_PostTimerFunc, (Object*) AudioCtrl, 0 );
 247   }
 248
 249   card->playback_interrupt_enabled = TRUE;
 250 }
 251
 252
 253 /******************************************************************************
 254 ** Record interrupt handler ***************************************************
 255 ******************************************************************************/
 256
 257 #ifdef __AMIGAOS4__
 258 void
 259 RecordInterrupt( struct ExceptionContext *pContext, struct ExecBase *SysBase, struct CardData* card )
 260 #else
 261 void
 262 RecordInterrupt( struct CardData* card )
 263 #endif
 264 {
 265   struct AHIAudioCtrlDrv* AudioCtrl = card->audioctrl;
 266   int   i   = 0, frames = card->current_record_bytesize_32bit / 4;
 267
 268   if (card->input_is_24bits)
 269   {
 270      struct AHIRecordMessage rm =
 271      {
 272        AHIST_S32S,
 273        card->current_record_buffer_32bit,
 274        RECORD_BUFFER_SAMPLES
 275      };
 276
 277 #if defined(__amigaos4__) || defined(__MORPHOS__)
 278      long *srclong = card->current_record_buffer_32bit;
 279
 280      while( i < frames )
 281      {
 282        *srclong =  ((*srclong & 0x00FF0000) >> 8) | ((*srclong & 0x0000FF00) << 8) | ((*srclong & 0x000000FF) << 24);
 283
 284        ++i;
 285        ++srclong;
 286      }
 287 #endif
 288
 289      CALLHOOK( AudioCtrl->ahiac_SamplerFunc, (Object*) AudioCtrl, &rm );
 290   }
 291   else
 292   {
 293      struct AHIRecordMessage rm =
 294      {
 295        AHIST_S16S,
 296        card->current_record_buffer,
 297        RECORD_BUFFER_SAMPLES
 298      };
 299
 300      long *src = card->current_record_buffer_32bit;
 301      WORD* dst = card->current_record_buffer;
 302
 303 #if defined(__amigaos4__) || defined(__MORPHOS__)
 304      while( i < frames )
 305      {
 306        *dst = ( ( *src & 0x000000FF ) << 8 ) | ( ( *src & 0x0000FF00 ) >> 8 );
 307
 308        ++i;
 309        ++src;
 310        ++dst;
 311      }
 312 #else
 313      while( i < frames )
 314      {
 315        *dst = (*src) >> 16;
 316
 317        ++i;
 318        ++src;
 319        ++dst;
 320      }
 321 #endif
 322
 323      CALLHOOK( AudioCtrl->ahiac_SamplerFunc, (Object*) AudioCtrl, &rm );
 324   }
 325
 326   card->record_interrupt_enabled = TRUE;
 327 }
 328
 329