workbench/devs/AHI/Drivers/VIA-AC97/interrupt.c

   1 /*
   2     Copyright © 2005-2013, Davy Wentzler. All rights reserved.
   3     Copyright © 2010-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 "misc.h"
  18 #include "hwaccess.h"
  19 #include "pci_wrapper.h"
  20
  21 #define min(a,b) ((a)<(b)?(a):(b))
  22
  23 /******************************************************************************
  24 ** Hardware interrupt handler *************************************************
  25 ******************************************************************************/
  26
  27
  28 #ifdef __amigaos4__
  29 LONG CardInterrupt(struct ExceptionContext *pContext,
  30   struct ExecBase *SysBase, struct CardData* card)
  31 #else
  32 LONG CardInterrupt(struct CardData* card)
  33 #endif
  34 {
  35 #ifdef __amigaos4__
  36   struct PCIDevice *dev = (struct PCIDevice * ) card->pci_dev;
  37 #endif
  38
  39   ULONG intreq;
  40   LONG  handled = 0;
  41
  42   intreq = pci_inl(VIA_REG_SGD_SHADOW, card);
  43
  44     //DebugPrintF("INT %lx\n", intreq);
  45     if( intreq & 0x33 )
  46     {
  47       unsigned char play_status = pci_inb(VIA_REG_OFFSET_STATUS, card),
  48                     rec_status = pci_inb(VIA_REG_OFFSET_STATUS + RECORD, card);
  49
  50       play_status &= (VIA_REG_STAT_EOL|VIA_REG_STAT_FLAG|VIA_REG_STAT_STOPPED);
  51
  52       if (play_status)
  53       {
  54             pci_outb(play_status, VIA_REG_OFFSET_STATUS, card);
  55
  56             if (play_status & VIA_REG_STAT_FLAG)
  57             {
  58                card->flip = 0;
  59                card->current_buffer = card->playback_buffer1;
  60                }
  61             else if (play_status & VIA_REG_STAT_EOL)
  62             {
  63                card->flip = 1;
  64                card->current_buffer = card->playback_buffer2;
  65             }
  66
  67             card->playback_interrupt_enabled = FALSE;
  68             Cause( &card->playback_interrupt );
  69       }
  70
  71       rec_status &= (VIA_REG_STAT_EOL|VIA_REG_STAT_FLAG|VIA_REG_STAT_STOPPED);
  72       if (rec_status)
  73       {
  74             //DebugPrintF("REC!\n");
  75             pci_outb(rec_status, VIA_REG_OFFSET_STATUS + RECORD, card);
  76
  77             if (rec_status & VIA_REG_STAT_FLAG)
  78             {
  79                card->flip = 0;
  80                card->current_record_buffer = card->record_buffer1;
  81                }
  82             else if (rec_status & VIA_REG_STAT_EOL)
  83             {
  84                card->flip = 1;
  85                card->current_record_buffer = card->record_buffer2;
  86             }
  87
  88             card->record_interrupt_enabled = FALSE;
  89             Cause( &card->record_interrupt );
  90       }
  91
  92       handled = 1;
  93     }
  94
  95   return handled;
  96 }
  97
  98
  99 /******************************************************************************
 100 ** Playback interrupt handler *************************************************
 101 ******************************************************************************/
 102
 103 #ifdef __amigaos4__
 104 void PlaybackInterrupt(struct ExceptionContext *pContext,
 105   struct ExecBase *SysBase, struct CardData* card)
 106 #else
 107 void PlaybackInterrupt(struct CardData* card)
 108 #endif
 109 {
 110   struct AHIAudioCtrlDrv* AudioCtrl;
 111   struct DriverBase*  AHIsubBase;
 112
 113   if (card == NULL)
 114     return;
 115
 116   AudioCtrl = card->audioctrl;
 117   AHIsubBase = (struct DriverBase*) card->ahisubbase;
 118
 119   if( card->mix_buffer != NULL && card->current_buffer != NULL)
 120   {
 121     BOOL   skip_mix;
 122
 123     WORD*  src;
 124     WORD*  dst;
 125     size_t skip;
 126     size_t samples;
 127     int    i;
 128
 129     skip_mix = CallHookPkt( AudioCtrl->ahiac_PreTimerFunc, (Object*) AudioCtrl, 0 );
 130     CallHookPkt( AudioCtrl->ahiac_PlayerFunc, (Object*) AudioCtrl, NULL );
 131
 132     //DebugPrintF("skip_mix = %d\n", skip_mix);
 133
 134     if( ! skip_mix )
 135     {
 136       CallHookPkt( AudioCtrl->ahiac_MixerFunc, (Object*) AudioCtrl, card->mix_buffer );
 137     }
 138
 139     /* Now translate and transfer to the DMA buffer */
 140
 141
 142     skip    = ( AudioCtrl->ahiac_Flags & AHIACF_HIFI ) ? 2 : 1;
 143     samples = card->current_bytesize >> 1;
 144
 145     src     = card->mix_buffer;
 146 #if !defined(__amigaos4__) && !AROS_BIG_ENDIAN
 147     if(skip == 2)
 148         src++;
 149 #endif
 150     dst     = card->current_buffer;
 151
 152     i = samples;
 153
 154     while( i > 0 )
 155     {
 156 #ifdef __amigaos4__
 157       *dst = ( ( *src & 0xff ) << 8 ) | ( ( *src & 0xff00 ) >> 8 );
 158 #else
 159       *dst = AROS_WORD2LE(*src);
 160 #endif
 161       src += skip;
 162       dst += 1;
 163
 164       --i;
 165     }
 166
 167     CacheClearE( card->current_buffer, (ULONG) dst - (ULONG) card->current_buffer, CACRF_ClearD );
 168     CallHookPkt( AudioCtrl->ahiac_PostTimerFunc, (Object*) AudioCtrl, 0 );
 169   }
 170
 171   card->playback_interrupt_enabled = TRUE;
 172 }
 173
 174
 175 /******************************************************************************
 176 ** Record interrupt handler ***************************************************
 177 ******************************************************************************/
 178
 179 #ifdef __amigaos4__
 180 void RecordInterrupt(struct ExceptionContext *pContext,
 181   struct ExecBase *SysBase, struct CardData* card)
 182 #else
 183 void RecordInterrupt(struct CardData* card)
 184 #endif
 185 {
 186   struct AHIAudioCtrlDrv* AudioCtrl = card->audioctrl;
 187   struct DriverBase*  AHIsubBase = (struct DriverBase*) card->ahisubbase;
 188
 189   struct AHIRecordMessage rm =
 190   {
 191     AHIST_S16S,
 192     card->current_record_buffer,
 193     RECORD_BUFFER_SAMPLES
 194   };
 195
 196   int   i   = 0, shorts = card->current_record_bytesize / 2;
 197   WORD* ptr = card->current_record_buffer;
 198
 199
 200   while( i < shorts )
 201   {
 202 #if defined(__AMIGAOS4__) || AROS_BIG_ENDIAN
 203     *ptr = ( ( *ptr & 0xff ) << 8 ) | ( ( *ptr & 0xff00 ) >> 8 );
 204 #endif
 205     ++i;
 206     ++ptr;
 207   }
 208
 209   CallHookPkt( AudioCtrl->ahiac_SamplerFunc, (Object*) AudioCtrl, &rm );
 210
 211   card->record_interrupt_enabled = TRUE;
 212 }
 213
 214