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

   1 #include <config.h>
   2
   3 #include <proto/expansion.h>
   4 #include <libraries/ahi_sub.h>
   5 #include <proto/exec.h>
   6 #include <stddef.h>
   7 #include "library.h"
   8 #include "regs.h"
   9 #include "interrupt.h"
  10 #include "misc.h"
  11 #include "pci_wrapper.h"
  12 #ifdef __AROS__
  13 #include <aros/debug.h>
  14 #endif
  15
  16 #define min(a,b) ((a)<(b)?(a):(b))
  17
  18 int z = 0;
  19 ULONG timer = 0; // for demo/test
  20
  21 #define TIME_LIMIT 150 // 150 irq's
  22
  23 /******************************************************************************
  24 ** Hardware interrupt handler *************************************************
  25 ******************************************************************************/
  26
  27
  28 #ifdef __AMIGAOS4__
  29 ULONG
  30 CardInterrupt( struct ExceptionContext *pContext, struct ExecBase *SysBase, struct HDAudioChip* card )
  31 #else
  32 ULONG
  33 CardInterrupt( struct HDAudioChip* card )
  34 #endif
  35 {
  36     struct AHIAudioCtrlDrv* AudioCtrl = card->audioctrl;
  37     struct DriverBase*  AHIsubBase = (struct DriverBase*) card->ahisubbase;
  38     struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
  39
  40     ULONG intreq, status;
  41     LONG  handled = 0;
  42     UBYTE rirb_status;
  43     int i;
  44
  45     intreq = pci_inl(HD_INTSTS, card);
  46
  47     if (intreq & HD_INTCTL_GLOBAL)
  48     {
  49         if (intreq & 0x3fffffff) // stream interrupt
  50         {
  51             ULONG position;
  52             BOOL playback = FALSE;
  53             BOOL recording = FALSE;
  54
  55             //bug("Stream irq\n");
  56             for (i = 0; i < card->nr_of_streams; i++)
  57             {
  58                 if (intreq & (1 << card->streams[i].index))
  59                 {
  60                     // acknowledge stream interrupt
  61                     pci_outb(0x1C, card->streams[i].sd_reg_offset + HD_SD_OFFSET_STATUS, card);
  62
  63                     if (i < card->nr_of_input_streams)
  64                     {
  65                         recording = TRUE;
  66                     }
  67                     else
  68                     {
  69                         playback = TRUE;
  70                     }
  71                 }
  72             }
  73
  74             pci_outb(0xFF, HD_INTSTS, card);
  75
  76             z++;
  77 #ifdef TIME_LIMITED
  78             timer++;
  79
  80             if (timer > TIME_LIMIT) // stop playback
  81             {
  82                 outb_clearbits(HD_SD_CONTROL_STREAM_RUN, card->streams[card->nr_of_input_streams].sd_reg_offset + HD_SD_OFFSET_CONTROL, card);
  83             }
  84 #endif
  85
  86             //bug("SIRQ\n");
  87
  88             if (playback)
  89             {
  90               //  bug("PB\n");
  91                 position = pci_inl(card->streams[card->nr_of_input_streams].sd_reg_offset + HD_SD_OFFSET_LINKPOS, card);
  92
  93                 if (card->flip == 1) //position <= card->current_bytesize + 64)
  94                 {
  95                    if (card->flip == 0)
  96                    {
  97                       bug("Lost IRQ!\n");
  98                    }
  99                    card->flip = 0;
 100                    card->current_buffer = card->playback_buffer1;
 101                 }
 102                 else
 103                 {
 104                    if (card->flip == 1)
 105                    {
 106                       bug("Lost IRQ!\n");
 107                    }
 108
 109                    card->flip = 1;
 110                    card->current_buffer = card->playback_buffer2;
 111                 }
 112
 113                 Cause(&card->playback_interrupt);
 114             }
 115
 116             if (recording)
 117             {
 118                 position = pci_inl(card->streams[0].sd_reg_offset + HD_SD_OFFSET_LINKPOS, card);
 119
 120                 if (card->recflip == 1) //position <= card->current_record_bytesize + 64)
 121                 {
 122                    if (card->recflip == 0)
 123                    {
 124                       bug("Lost rec IRQ!\n");
 125                    }
 126                    card->recflip = 0;
 127                    card->current_record_buffer = card->record_buffer1;
 128                 }
 129                 else
 130                 {
 131                    if (card->recflip == 1)
 132                    {
 133                       bug("Lost rec IRQ!\n");
 134                    }
 135
 136                    card->recflip = 1;
 137                    card->current_record_buffer = card->record_buffer2;
 138                 }
 139
 140                 Cause(&card->record_interrupt);
 141             }
 142         }
 143
 144         if (intreq & HD_INTCTL_CIE)
 145         {
 146             //bug("CIE\n");
 147             pci_outb(0x4, HD_INTSTS + 3, card); // only byte access allowed
 148
 149   //          if (card->is_playing)
 150     //            bug("CIE irq! rirb is %x, STATESTS = %x\n", pci_inb(HD_RIRBSTS, card), pci_inw(HD_STATESTS, card));
 151
 152             // check for RIRB status
 153             rirb_status = pci_inb(HD_RIRBSTS, card);
 154             if (rirb_status & 0x5)
 155             {
 156                 if (rirb_status & 0x4) // RIRBOIS
 157                 {
 158 //                    bug("RIRB overrun!\n");
 159                 }
 160
 161                 if (rirb_status & 0x1) // RINTFL
 162                 {
 163                     card->rirb_irq++;
 164
 165                     /*if (card->rirb_irq > 1)
 166                     {
 167                        bug("IRQ: rirb_irq = %d\n", card->rirb_irq);
 168                     }*/
 169                     //bug("RIRB IRQ!\n");
 170                 }
 171
 172                 pci_outb(0x5, HD_RIRBSTS, card);
 173             }
 174         }
 175
 176         handled = 1;
 177     }
 178
 179     return handled;
 180 }
 181
 182
 183 /******************************************************************************
 184 ** Playback interrupt handler *************************************************
 185 ******************************************************************************/
 186
 187 #ifdef __AMIGAOS4__
 188 void
 189 PlaybackInterrupt( struct ExceptionContext *pContext, struct ExecBase *SysBase, struct HDAudioChip* card )
 190 #else
 191 void
 192 PlaybackInterrupt( struct HDAudioChip* card )
 193 #endif
 194 {
 195     struct AHIAudioCtrlDrv* AudioCtrl = card->audioctrl;
 196     struct DriverBase*  AHIsubBase = (struct DriverBase*) card->ahisubbase;
 197
 198     if (card->mix_buffer != NULL && card->current_buffer != NULL && card->is_playing)
 199     {
 200         BOOL   skip_mix;
 201
 202         WORD*  src;
 203         int    i;
 204         LONG* srclong, *dstlong, left, right;
 205         int frames = card->current_frames;
 206
 207         skip_mix = CallHookPkt(AudioCtrl->ahiac_PreTimerFunc, (Object*) AudioCtrl, 0);
 208         CallHookPkt(AudioCtrl->ahiac_PlayerFunc, (Object*) AudioCtrl, NULL);
 209
 210         if (! skip_mix)
 211         {
 212             CallHookPkt(AudioCtrl->ahiac_MixerFunc, (Object*) AudioCtrl, card->mix_buffer);
 213         }
 214
 215         /* Now translate and transfer to the DMA buffer */
 216         srclong = (LONG*) card->mix_buffer;
 217         dstlong = (LONG*) card->current_buffer;
 218
 219         i = frames;
 220
 221         if (AudioCtrl->ahiac_Flags & AHIACF_HIFI)
 222         {
 223             while(i > 0)
 224             {
 225                 *dstlong++ = *srclong++;
 226                 *dstlong++ = *srclong++;
 227
 228                 --i;
 229             }
 230         }
 231         else
 232         {
 233             while(i > 0)
 234             {
 235                 *dstlong++ = (*srclong & 0xFF00) >> 16; srclong++; // tbd
 236                 *dstlong++ = (*srclong & 0xFF000000) >> 16; srclong++;
 237
 238                 --i;
 239             }
 240         }
 241
 242         CallHookPkt(AudioCtrl->ahiac_PostTimerFunc, (Object*) AudioCtrl, 0);
 243     }
 244 }
 245
 246
 247 /******************************************************************************
 248 ** Record interrupt handler ***************************************************
 249 ******************************************************************************/
 250
 251 #ifdef __AMIGAOS4__
 252 void
 253 RecordInterrupt( struct ExceptionContext *pContext, struct ExecBase *SysBase, struct HDAudioChip* card )
 254 #else
 255 void
 256 RecordInterrupt( struct HDAudioChip* card )
 257 #endif
 258 {
 259     struct AHIAudioCtrlDrv* AudioCtrl = card->audioctrl;
 260     struct DriverBase*  AHIsubBase = (struct DriverBase*) card->ahisubbase;
 261     int i = 0;
 262     int frames = card->current_record_bytesize / 2;
 263
 264     struct AHIRecordMessage rm =
 265     {
 266         AHIST_S16S,
 267         card->current_record_buffer,
 268         RECORD_BUFFER_SAMPLES
 269     };
 270
 271      WORD *src = card->current_record_buffer;
 272      WORD* dst = card->current_record_buffer;
 273
 274 #ifdef __AMIGAOS4__
 275      while( i < frames )
 276      {
 277        *dst = ( ( *src & 0x00FF ) << 8 ) | ( ( *src & 0xFF00 ) >> 8 );
 278
 279        ++i;
 280        ++src;
 281        ++dst;
 282      }
 283 #else
 284      /*while( i < frames )
 285      {
 286        *dst = (*src);
 287
 288        ++i;
 289        ++src;
 290        ++dst;
 291      }*/
 292 #endif
 293
 294     CallHookPkt(AudioCtrl->ahiac_SamplerFunc, (Object*) AudioCtrl, &rm);
 295 }
 296
 297