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

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