workbench/devs/AHI/Drivers/EMU10kx/emu10kx-interrupt.c

   1 /*
   2      emu10kx.audio - AHI driver for SoundBlaster Live! series
   3      Copyright (C) 2002-2005 Martin Blom <martin@blom.org>
   4
   5      This program is free software; you can redistribute it and/or
   6      modify it under the terms of the GNU General Public License
   7      as published by the Free Software Foundation; either version 2
   8      of the License, or (at your option) any later version.
   9
  10      This program is distributed in the hope that it will be useful,
  11      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13      GNU General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with this program; if not, write to the Free Software
  17      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18 */
  19
  20 #include <config.h>
  21
  22 #include <libraries/ahi_sub.h>
  23 #include <exec/execbase.h>
  24 #include <clib/alib_protos.h>
  25 #include <proto/exec.h>
  26
  27 #include "library.h"
  28 #include "8010.h"
  29 #include "pci_wrapper.h"
  30
  31 #define min(a,b) ((a)<(b)?(a):(b))
  32
  33 #ifdef __AMIGAOS4__
  34 # define CallHookA CallHookPkt
  35 #endif
  36
  37
  38 static WORD*
  39 copy_mono( WORD* src, WORD* dst, int count, int stride, BOOL src32, BOOL flush_caches );
  40
  41 static WORD*
  42 copy_stereo( WORD* lsrc, WORD* rsrc, WORD* dst, int count, int stride, BOOL src32, BOOL flush_caches );
  43
  44
  45 /******************************************************************************
  46 ** Hardware interrupt handler *************************************************
  47 ******************************************************************************/
  48
  49 #ifdef __AMIGAOS4__
  50 LONG
  51 EMU10kxInterrupt( struct ExceptionContext *pContext, struct ExecBase *SysBase, struct EMU10kxData* dd )
  52 #else
  53 ULONG
  54 EMU10kxInterrupt( struct EMU10kxData* dd )
  55 #endif
  56 {
  57   struct AHIAudioCtrlDrv* AudioCtrl = dd->audioctrl;
  58   struct DriverBase*  AHIsubBase = (struct DriverBase*) dd->ahisubbase;
  59   struct EMU10kxBase* EMU10kxBase = (struct EMU10kxBase*) AHIsubBase;
  60
  61   ULONG intreq;
  62   BOOL  handled = FALSE;
  63
  64   while( ( intreq = ahi_pci_inl( dd->card.iobase + IPR, dd->card.pci_dev ) ) != 0 )
  65   {
  66 //    KPrintF("IRQ: %08lx\n", intreq );
  67     if( intreq & IPR_INTERVALTIMER &&
  68         AudioCtrl != NULL )
  69     {
  70       int hw   = sblive_readptr( &dd->card, CCCA_CURRADDR, dd->voices[0].num );
  71       int diff = dd->current_position - ( hw - dd->voices[0].start );
  72
  73       if( diff < 0 )
  74       {
  75          diff += AudioCtrl->ahiac_MaxBuffSamples * 2;
  76       }
  77
  78 //      KPrintF( ">>> hw_pos = %08lx; current_pos = %08lx; diff=%ld <<<\n",
  79 //             hw, dd->current_position, diff );
  80
  81       if( (ULONG) diff < dd->current_length )
  82       {
  83          if( dd->playback_interrupt_enabled )
  84          {
  85             /* Invoke softint to fetch new sample data */
  86
  87             dd->playback_interrupt_enabled = FALSE;
  88             Cause( &dd->playback_interrupt );
  89 /*          KPrintF("hw[0]=%08lx, hw[1]=%08lx, hw[2]=%08lx, hw[3]=%08lx\n", */
  90 /*                  sblive_readptr( &dd->card, CCCA_CURRADDR, dd->voices[0].num ), */
  91 /*                  sblive_readptr( &dd->card, CCCA_CURRADDR, dd->voices[1].num ), */
  92 /*                  sblive_readptr( &dd->card, CCCA_CURRADDR, dd->voices[2].num ), */
  93 /*                  sblive_readptr( &dd->card, CCCA_CURRADDR, dd->voices[3].num ) ); */
  94          }
  95       }
  96     }
  97
  98     if( intreq & ( IPR_ADCBUFHALFFULL | IPR_ADCBUFFULL ) )
  99     {
 100       if( intreq & IPR_ADCBUFHALFFULL )
 101       {
 102          dd->current_record_buffer = dd->record_buffer;
 103       }
 104       else
 105       {
 106          dd->current_record_buffer = ( dd->record_buffer +
 107                                       RECORD_BUFFER_SAMPLES * 4 / 2 );
 108       }
 109
 110       if( dd->record_interrupt_enabled )
 111       {
 112          /* Invoke softint to convert and feed AHI with the new sample data */
 113
 114          dd->record_interrupt_enabled = FALSE;
 115          Cause( &dd->record_interrupt );
 116       }
 117     }
 118
 119     if( intreq & IPR_MIDIRECVBUFEMPTY )
 120     {
 121       unsigned char b;
 122
 123       while( emu10k1_mpu_read_data( &dd->card, &b ) >= 0 )
 124       {
 125         struct ReceiveMessage msg = { b };
 126
 127         if( dd->camd_receivefunc == NULL )
 128         {
 129           KPrintF( "emu10kx.audio got unexpected IPR_MIDIRECVBUFEMPTY\n" );
 130         }
 131
 132 //      KPrintF( "\t%lx\n", (int) b );
 133         CallHookA( dd->camd_receivefunc, (Object*) EMU10kxBase, &msg );
 134       }
 135     }
 136
 137     if( intreq & IPR_MIDITRANSBUFEMPTY )
 138     {
 139       ULONG b;
 140
 141       if( dd->camd_transmitfunc == NULL )
 142       {
 143         KPrintF( "emu10kx.audio got unexpected IPR_MIDITRANSBUFEMPTY\n" );
 144       }
 145
 146       b = CallHookA( dd->camd_transmitfunc, (Object*) EMU10kxBase, NULL );
 147
 148 //      KPrintF( "%08lx\n", b );
 149
 150       // Check if d0.w is negative (as the V37 did once?) or if bit 8
 151       // is set (as the V40 example does)
 152
 153       if( ( b & 0x00008100 ) == 0x0000 )
 154       {
 155         emu10k1_mpu_write_data( &dd->card, b );
 156       }
 157
 158       if( ( !dd->camd_v40 && ( b & 0x00ff0000 ) != 0 ) ||
 159           ( b & 0x00008100 ) != 0 )
 160       {
 161 //      KPrintF( "Disabling interrupts\n" );
 162         emu10k1_irq_disable( &dd->card, INTE_MIDITXENABLE );
 163       }
 164     }
 165
 166     /* Clear interrupt pending bit(s) */
 167     ahi_pci_outl( intreq, dd->card.iobase + IPR, dd->card.pci_dev );
 168
 169     handled = TRUE;
 170   }
 171
 172   return handled;
 173 }
 174
 175
 176 /******************************************************************************
 177 ** Playback interrupt handler *************************************************
 178 ******************************************************************************/
 179
 180 #ifdef __AMIGAOS4__
 181 void
 182 PlaybackInterrupt( struct ExceptionContext *pContext, struct ExecBase *SysBase, struct EMU10kxData* dd )
 183 #else
 184 void
 185 PlaybackInterrupt( struct EMU10kxData* dd )
 186 #endif
 187 {
 188   struct AHIAudioCtrlDrv* AudioCtrl = dd->audioctrl;
 189   struct DriverBase*  AHIsubBase = (struct DriverBase*) dd->ahisubbase;
 190   struct EMU10kxBase* EMU10kxBase = (struct EMU10kxBase*) AHIsubBase;
 191
 192   if( dd->mix_buffer != NULL && dd->current_buffers[0] != NULL )
 193   {
 194     BOOL   skip_mix;
 195
 196     WORD*  src;
 197     size_t samples;
 198     int    s;
 199
 200     skip_mix = CallHookA( AudioCtrl->ahiac_PreTimerFunc, (Object*) AudioCtrl, 0 );
 201
 202     CallHookA( AudioCtrl->ahiac_PlayerFunc, (Object*) AudioCtrl, NULL );
 203
 204     if( ! skip_mix )
 205     {
 206       CallHookA( AudioCtrl->ahiac_MixerFunc, (Object*) AudioCtrl, dd->mix_buffer );
 207     }
 208
 209     /* Now translate and transfer to the DMA buffer */
 210     samples    = dd->current_length;
 211
 212     s = min( samples,
 213              AudioCtrl->ahiac_MaxBuffSamples * 2 - dd->current_position );
 214
 215     src = dd->mix_buffer;
 216
 217     switch( AudioCtrl->ahiac_BuffType)
 218     {
 219       case AHIST_M16S:
 220         dd->current_buffers[0] = copy_mono( src, dd->current_buffers[0],
 221                                             s, 1, FALSE,
 222                                             EMU10kxBase->flush_caches );
 223         src += s;
 224         break;
 225
 226       case AHIST_S16S:
 227         dd->current_buffers[0] = copy_stereo( src, src + 1, dd->current_buffers[0],
 228                                               s, 2, FALSE,
 229                                               EMU10kxBase->flush_caches );
 230         src += s * 2;
 231         break;
 232
 233       case AHIST_M32S:
 234         dd->current_buffers[0] = copy_mono( src, dd->current_buffers[0],
 235                                             s, 2, TRUE,
 236                                             EMU10kxBase->flush_caches );
 237         src += s * 2;
 238         break;
 239
 240       case AHIST_S32S:
 241         dd->current_buffers[0] = copy_stereo( src, src + 2, dd->current_buffers[0],
 242                                               s, 4, TRUE,
 243                                               EMU10kxBase->flush_caches );
 244         src += s * 4;
 245         break;
 246
 247       case AHIST_L7_1:
 248         dd->current_buffers[0] = copy_stereo( src, src + 2, dd->current_buffers[0],
 249                                               s, 16, TRUE,
 250                                               EMU10kxBase->flush_caches );
 251         dd->current_buffers[1] = copy_stereo( src + 4, src + 6, dd->current_buffers[1],
 252                                               s, 16, TRUE,
 253                                               EMU10kxBase->flush_caches );
 254         dd->current_buffers[2] = copy_stereo( src + 8, src + 10, dd->current_buffers[2],
 255                                               s, 16, TRUE,
 256                                               EMU10kxBase->flush_caches );
 257         dd->current_buffers[3] = copy_stereo( src + 12, src + 14, dd->current_buffers[3],
 258                                               s, 16, TRUE,
 259                                               EMU10kxBase->flush_caches );
 260         src += s * 16;
 261         break;
 262     }
 263
 264     dd->current_position += s;
 265     samples -= s;
 266
 267     if( dd->current_position == AudioCtrl->ahiac_MaxBuffSamples * 2 )
 268     {
 269       dd->current_buffers[0] = dd->voices[0].mem.addr;
 270       dd->current_buffers[1] = dd->voices[1].mem.addr;
 271       dd->current_buffers[2] = dd->voices[2].mem.addr;
 272       dd->current_buffers[3] = dd->voices[3].mem.addr;
 273       dd->current_position = 0;
 274     }
 275
 276     if( samples > 0 )
 277     {
 278       s = samples;
 279
 280       switch( AudioCtrl->ahiac_BuffType)
 281       {
 282         case AHIST_M16S:
 283           dd->current_buffers[0] = copy_mono( src, dd->current_buffers[0],
 284                                               s, 1, FALSE,
 285                                               EMU10kxBase->flush_caches );
 286           break;
 287
 288         case AHIST_S16S:
 289           dd->current_buffers[0] = copy_stereo( src, src + 1, dd->current_buffers[0],
 290                                                 s, 2, FALSE,
 291                                                 EMU10kxBase->flush_caches );
 292           break;
 293
 294         case AHIST_M32S:
 295           dd->current_buffers[0] = copy_mono( src, dd->current_buffers[0],
 296                                               s, 2, TRUE,
 297                                               EMU10kxBase->flush_caches );
 298           break;
 299
 300         case AHIST_S32S:
 301           dd->current_buffers[0] = copy_stereo( src, src + 2, dd->current_buffers[0],
 302                                                 s, 4, TRUE,
 303                                                 EMU10kxBase->flush_caches );
 304           break;
 305
 306         case AHIST_L7_1:
 307           dd->current_buffers[0] = copy_stereo( src, src + 2, dd->current_buffers[0],
 308                                                 s, 16, TRUE,
 309                                                 EMU10kxBase->flush_caches );
 310           dd->current_buffers[1] = copy_stereo( src + 4, src + 6, dd->current_buffers[1],
 311                                                 s, 16, TRUE,
 312                                                 EMU10kxBase->flush_caches );
 313           dd->current_buffers[2] = copy_stereo( src + 8, src + 10, dd->current_buffers[2],
 314                                                 s, 16, TRUE,
 315                                                 EMU10kxBase->flush_caches );
 316           dd->current_buffers[3] = copy_stereo( src + 12, src + 14, dd->current_buffers[3],
 317                                                 s, 16, TRUE,
 318                                                 EMU10kxBase->flush_caches );
 319           break;
 320       }
 321
 322       dd->current_position += s;
 323     }
 324
 325     CallHookA( AudioCtrl->ahiac_PostTimerFunc, (Object*) AudioCtrl, 0 );
 326   }
 327
 328   dd->playback_interrupt_enabled = TRUE;
 329 }
 330
 331
 332 static WORD*
 333 copy_mono( WORD* src, WORD* dst, int count, int stride, BOOL src32, BOOL flush_caches )
 334 {
 335   WORD* first = dst;
 336   WORD* last  = dst + count;
 337   int x, y;
 338
 339 #ifndef WORDS_BIGENDIAN
 340   if( src32 )
 341   {
 342     // Move to high 16 bits
 343     ++src;
 344   }
 345 #endif
 346
 347   for( x = 0, y = 0; y < count; x += stride, ++y )
 348   {
 349 #ifndef WORDS_BIGENDIAN
 350     dst[y] = src[x];
 351 #else
 352     dst[y] = ( ( src[x] & 0xff ) << 8 ) | ( ( src[x] & 0xff00 ) >> 8 );
 353 #endif
 354   }
 355
 356   if( flush_caches )
 357   {
 358     CacheClearE( first, (ULONG) last - (ULONG) first, CACRF_ClearD );
 359   }
 360
 361   return last;
 362 }
 363
 364
 365 static WORD*
 366 copy_stereo( WORD* lsrc, WORD* rsrc, WORD* dst, int count, int stride, BOOL src32, BOOL flush_caches )
 367 {
 368   WORD* first = dst;
 369   WORD* last  = dst + count * 2;
 370   int x, y;
 371
 372 #ifndef WORDS_BIGENDIAN
 373   if( src32 )
 374   {
 375     // Move to high 16 bits
 376     ++lsrc;
 377     ++rsrc;
 378   }
 379 #endif
 380
 381   for( x = 0, y = 0; y < count * 2; x += stride, y += 2 )
 382   {
 383 #ifndef WORDS_BIGENDIAN
 384     dst[y+0] = lsrc[x];
 385     dst[y+1] = rsrc[x];
 386 #else
 387     dst[y+0] = ( ( lsrc[x] & 0xff ) << 8 ) | ( ( lsrc[x] & 0xff00 ) >> 8 );
 388     dst[y+1] = ( ( rsrc[x] & 0xff ) << 8 ) | ( ( rsrc[x] & 0xff00 ) >> 8 );
 389 #endif
 390   }
 391
 392   if( flush_caches )
 393   {
 394     CacheClearE( first, (ULONG) last - (ULONG) first, CACRF_ClearD );
 395   }
 396
 397   return last;
 398 }
 399
 400
 401 /******************************************************************************
 402 ** Record interrupt handler ***************************************************
 403 ******************************************************************************/
 404
 405 #ifdef __AMIGAOS4__
 406 void
 407 RecordInterrupt( struct ExceptionContext *pContext, struct ExecBase *SysBase, struct EMU10kxData* dd )
 408 #else
 409 void
 410 RecordInterrupt( struct EMU10kxData* dd )
 411 #endif
 412 {
 413   struct AHIAudioCtrlDrv* AudioCtrl = dd->audioctrl;
 414   struct DriverBase*  AHIsubBase = (struct DriverBase*) dd->ahisubbase;
 415   struct EMU10kxBase* EMU10kxBase = (struct EMU10kxBase*) AHIsubBase;
 416 #ifdef __AMIGAOS4__
 417   ULONG  CacheCommand = CACRF_InvalidateD;
 418 #else
 419   ULONG  CacheCommand = CACRF_ClearD;
 420 #endif
 421
 422
 423   struct AHIRecordMessage rm =
 424   {
 425     AHIST_S16S,
 426     dd->current_record_buffer,
 427     RECORD_BUFFER_SAMPLES / 2
 428   };
 429
 430 #ifdef WORDS_BIGENDIAN
 431   int   i   = 0;
 432   WORD* ptr = dd->current_record_buffer;
 433 #endif
 434
 435 #ifndef __AMIGAOS4__
 436   // As OS4 can do invalidate only, we don't need to do flushing here.
 437   // Between the invalidate at the end, DMA and entering this interrupt code,
 438   // nobody should have touched this half of the record buffer.
 439
 440   if( EMU10kxBase->flush_caches )
 441   {
 442     // This is used to invalidate the cache
 443
 444     CacheClearE( dd->current_record_buffer,
 445                  RECORD_BUFFER_SAMPLES / 2 * 4,
 446                  CacheCommand );
 447   }
 448 #endif
 449
 450 #ifdef WORDS_BIGENDIAN
 451   while( i < RECORD_BUFFER_SAMPLES / 2 * 2 )
 452   {
 453     *ptr = ( ( *ptr & 0xff ) << 8 ) | ( ( *ptr & 0xff00 ) >> 8 );
 454
 455     ++i;
 456     ++ptr;
 457   }
 458 #endif
 459
 460   CallHookA( AudioCtrl->ahiac_SamplerFunc, (Object*) AudioCtrl, &rm );
 461
 462   if( EMU10kxBase->flush_caches )
 463   {
 464     // This is used to make sure the call above doesn't push dirty data
 465     // the next time it's called. God help us if dd->current_record_buffer
 466     // is not a the beginning of a cache line and there are dirty data
 467     // in the DMA buffer before or after the current buffer.
 468
 469     CacheClearE( dd->current_record_buffer,
 470                  RECORD_BUFFER_SAMPLES / 2 * 4,
 471                  CacheCommand );
 472   }
 473
 474   dd->record_interrupt_enabled = TRUE;
 475 }
 476
 477