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

   1 /*
   2     Copyright © 2004-2014, Davy Wentzler. All rights reserved.
   3     Copyright © 2014-2016, The AROS Development Team. All rights reserved.
   4     $Id$
   5 */
   6
   7 #include <config.h>
   8
   9 #undef __USE_INLINE__
  10 #include <proto/expansion.h>
  11 #include <libraries/ahi_sub.h>
  12 #include <proto/exec.h>
  13 #include <stddef.h>
  14 #include "library.h"
  15 #include "regs.h"
  16 #include "interrupt.h"
  17 #include "pci_wrapper.h"
  18
  19 #define min(a,b) ((a)<(b)?(a):(b))
  20
  21
  22 /******************************************************************************
  23 ** Hardware interrupt handler *************************************************
  24 ******************************************************************************/
  25
  26
  27 AROS_INTH1(CardInterrupt, struct CardData *, card)
  28 {
  29   AROS_INTFUNC_INIT
  30
  31   struct AHIAudioCtrlDrv* AudioCtrl = card->audioctrl;
  32
  33   unsigned char intreq;
  34   LONG  handled = 0;
  35
  36   //DebugPrintF("INT\n");
  37   while ( ( intreq = ( pci_inb(CCS_INTR_STATUS, card) ) ) != 0 )
  38   {
  39     //DebugPrintF("INT %x\n", intreq);
  40
  41     if (intreq & CCS_INTR_PRO_MACRO)
  42     {
  43        unsigned char mtstatus = pci_inb_mt(MT_INTR_MASK_STATUS, card);
  44
  45        //DebugPrintF("CCS_INTR_PRO_MACRO, mtstatus = %x\n", mtstatus);
  46
  47        if( (mtstatus & MT_PLAY_STATUS) && AudioCtrl != NULL )
  48        {
  49          pci_outb_mt(mtstatus | MT_PLAY_STATUS, MT_INTR_MASK_STATUS, card); // clear interrupt
  50
  51          if (card->flip == 0) // just played buf 1
  52          {
  53             card->flip = 1;
  54             card->current_buffer = card->playback_buffer;
  55             }
  56          else  // just played buf 2
  57          {
  58             card->flip = 0;
  59             card->current_buffer = (APTR) ((long) card->playback_buffer + card->current_bytesize);
  60          }
  61
  62          card->playback_interrupt_enabled = FALSE;
  63          Cause( &card->playback_interrupt );
  64        }
  65
  66        if( (mtstatus & MT_REC_STATUS) && AudioCtrl != NULL )
  67        {
  68          pci_outb_mt(mtstatus | MT_REC_STATUS, MT_INTR_MASK_STATUS, card); // clear interrupt
  69          //DebugPrintF("rec\n");
  70
  71          if( card->record_interrupt_enabled )
  72          {
  73             const unsigned long diff = pci_inl_mt(MT_DMA_REC_ADDRESS, card) - (unsigned long) card->record_buffer_32bit_phys;
  74
  75             //DebugPrintF("%lu\n", diff % card->current_record_bytesize_32bit);
  76
  77             /* Invoke softint to convert and feed AHI with the new sample data */
  78
  79             if (diff >= card->current_record_bytesize_32bit) // just played buf 1
  80             {
  81                if (card->recflip == 1)
  82                    DebugPrintF("A: Missed IRQ!\n");
  83
  84                card->recflip = 1;
  85                card->current_record_buffer = card->record_buffer;
  86                card->current_record_buffer_32bit = card->record_buffer_32bit;
  87                }
  88             else  // just played buf 2
  89             {
  90                if (card->recflip == 0)
  91                    DebugPrintF("B: Missed IRQ!\n");
  92
  93                card->recflip = 0;
  94                card->current_record_buffer = (APTR) ((unsigned long) card->record_buffer + card->current_record_bytesize_target);
  95                card->current_record_buffer_32bit = (APTR) ((unsigned long) card->record_buffer_32bit + card->current_record_bytesize_32bit);
  96             }
  97             card->record_interrupt_enabled = FALSE;
  98             Cause( &card->record_interrupt );
  99          }
 100        }
 101
 102     }
 103     else
 104     {
 105        DebugPrintF("Oh dear, it's not CCS_INTR_PLAYREC!\n");
 106     }
 107
 108     handled = 1;
 109   }
 110
 111   return handled;
 112
 113   AROS_INTFUNC_EXIT
 114 }
 115
 116
 117 /******************************************************************************
 118 ** Playback interrupt handler *************************************************
 119 ******************************************************************************/
 120
 121 AROS_INTH1(PlaybackInterrupt, struct CardData *, card)
 122 {
 123   AROS_INTFUNC_INIT
 124
 125   struct AHIAudioCtrlDrv* AudioCtrl = card->audioctrl;
 126   struct DriverBase*  AHIsubBase = (struct DriverBase*) card->ahisubbase;
 127   BOOL stereo = (AudioCtrl->ahiac_Flags & AHIACF_STEREO) != 0;
 128
 129   if( card->mix_buffer != NULL && card->current_buffer != NULL )
 130   {
 131     BOOL   skip_mix;
 132
 133     WORD*  src;
 134     int    i;
 135     LONG *srclong, *dstlong, left, right;
 136     int frames = card->current_frames;
 137
 138     skip_mix = CallHookPkt( AudioCtrl->ahiac_PreTimerFunc, (Object*) AudioCtrl, 0 );
 139     CallHookPkt( AudioCtrl->ahiac_PlayerFunc, (Object*) AudioCtrl, NULL );
 140
 141     //DebugPrintF("skip_mix = %d\n", skip_mix);
 142
 143     if( ! skip_mix )
 144     {
 145       CallHookPkt( AudioCtrl->ahiac_MixerFunc, (Object*) AudioCtrl, card->mix_buffer );
 146     }
 147
 148     /* Now translate and transfer to the DMA buffer */
 149
 150     src     = card->mix_buffer;
 151     srclong = (LONG*) card->mix_buffer;
 152     dstlong = (LONG*) card->current_buffer;
 153
 154     i = frames;
 155
 156       while( i > 0 )
 157       {
 158         if (AudioCtrl->ahiac_Flags & AHIACF_HIFI)
 159         {
 160           left = AROS_LONG2LE(*srclong++);
 161           if (stereo)
 162             right = AROS_LONG2LE(*srclong++);
 163           else
 164             right = left;
 165         }
 166         else
 167         {
 168           left = AROS_LONG2LE(*src++ << 16);
 169           if (stereo)
 170             right = AROS_LONG2LE(*src++ << 16);
 171           else
 172             right = left;
 173         }
 174
 175         *dstlong++ = left;  // out 1 - 2
 176         *dstlong++ = right;
 177
 178         *dstlong++ = left;
 179         *dstlong++ = right;
 180
 181         dstlong+= 4;
 182
 183         // S/PDIF
 184         *dstlong++ = left;
 185         *dstlong++ = right;
 186
 187         --i;
 188       }
 189
 190     CacheClearE(card->current_buffer, (ULONG) dstlong - (ULONG) card->current_buffer, CACRF_ClearD);
 191     CallHookPkt( AudioCtrl->ahiac_PostTimerFunc, (Object*) AudioCtrl, 0 );
 192   }
 193
 194   card->playback_interrupt_enabled = TRUE;
 195
 196   return FALSE;
 197
 198   AROS_INTFUNC_EXIT
 199 }
 200
 201
 202 /******************************************************************************
 203 ** Record interrupt handler ***************************************************
 204 ******************************************************************************/
 205
 206 AROS_INTH1(RecordInterrupt, struct CardData *, card)
 207 {
 208   AROS_INTFUNC_INIT
 209
 210   struct AHIAudioCtrlDrv* AudioCtrl = card->audioctrl;
 211   struct DriverBase*  AHIsubBase = (struct DriverBase*) card->ahisubbase;
 212
 213   struct AHIRecordMessage rm =
 214   {
 215     AHIST_S16S,
 216     card->current_record_buffer,
 217     RECORD_BUFFER_SAMPLES
 218   };
 219
 220      long *src = card->current_record_buffer_32bit;
 221      WORD* dst = card->current_record_buffer;
 222      int i = 0, frames = RECORD_BUFFER_SAMPLES;
 223
 224      CacheClearE( card->current_record_buffer, card->current_record_bytesize_target, CACRF_ClearD);
 225      CacheClearE( card->current_record_buffer_32bit, card->current_record_bytesize_32bit, CACRF_ClearD);
 226
 227      i = frames;
 228
 229      if (card->SubType == PHASE88 || card->SubType == MAUDIO_1010LT)
 230      {
 231         src += card->input * 2;
 232         while( i > 0 )
 233         {
 234           *dst++ = AROS_LE2LONG(*src++) >> 16;
 235           *dst++ = AROS_LE2LONG(*src) >> 16;
 236
 237           src+=11;
 238
 239           i--;
 240         }
 241      }
 242      else
 243      {
 244         if (card->input != 1)
 245         {
 246            while( i > 0 )
 247            {
 248              *dst++ = AROS_LE2LONG(*src++) >> 16;
 249              *dst++ = AROS_LE2LONG(*src) >> 16;
 250
 251              src+=11;
 252
 253              i--;
 254            }
 255         }
 256         else
 257         {
 258            while( i > 0 )
 259            {
 260              src+=2;
 261
 262              *dst++ = AROS_LE2LONG(*src++) >> 16;
 263              *dst++ = AROS_LE2LONG(*src) >> 16;
 264
 265              src+=9;
 266
 267              i--;
 268            }
 269         }
 270      }
 271
 272   CallHookPkt( AudioCtrl->ahiac_SamplerFunc, (Object*) AudioCtrl, &rm );
 273   CacheClearE( card->current_record_buffer, card->current_record_bytesize_target, CACRF_ClearD);
 274   CacheClearE( card->current_record_buffer_32bit, card->current_record_bytesize_32bit, CACRF_ClearD);
 275
 276   card->record_interrupt_enabled = TRUE;
 277
 278   return FALSE;
 279
 280   AROS_INTFUNC_EXIT
 281 }
 282
 283