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