workbench/devs/AHI/Device/warpup.c

   1 /*
   2      AHI - Hardware independent audio subsystem
   3      Copyright (C) 1996-2005 Martin Blom <martin@blom.org>
   4
   5      This library is free software; you can redistribute it and/or
   6      modify it under the terms of the GNU Library General Public
   7      License as published by the Free Software Foundation; either
   8      version 2 of the License, or (at your option) any later version.
   9
  10      This library 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 GNU
  13      Library General Public License for more details.
  14
  15      You should have received a copy of the GNU Library General Public
  16      License along with this library; if not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330, Cambridge,
  18      MA 02139, USA.
  19 */
  20
  21 #include <config.h>
  22
  23 #include "ahi_def.h"
  24
  25 # include <hardware/intbits.h>
  26
  27 #ifdef __PPC__
  28 # include "mixer.h"
  29 # include "sound.h"
  30 # include <powerpc/powerpc.h>
  31 #else
  32 # include <exec/memory.h>
  33 # include <powerpc/powerpc.h>
  34 # include <proto/exec.h>
  35 # include <proto/powerpc.h>
  36 # include <proto/utility.h>
  37 # define __NOLIBBASE__
  38 # define __NOGLOBALIFACE__
  39 # include <proto/ahi.h>
  40 # undef  __NOLIBBASE__
  41 # undef  __NOGLOBALIFACE__
  42 #endif
  43
  44 #include "misc.h"
  45 #include "warpup.h"
  46
  47 #ifdef __PPC__
  48
  49 /******************************************************************************
  50 ** WarpUp/PPC prototypes ******************************************************
  51 ******************************************************************************/
  52
  53 static int
  54 CallMixroutine( struct PowerPCContext*   context );
  55
  56 void
  57 FlushCache( void* address, unsigned long length );
  58
  59 void
  60 FlushCacheAll( void  );
  61
  62 void
  63 InvalidateCache( void* address, unsigned long length );
  64
  65
  66 /******************************************************************************
  67 ** WarpUp/PPC function used to call the actual mixing routine *****************
  68 ******************************************************************************/
  69
  70 static int
  71 CallMixroutine( struct PowerPCContext* context )
  72 {
  73   struct AHIPrivAudioCtrl* audioctrl;
  74   struct AHISoundData*     sd;
  75   int                      i;
  76
  77   audioctrl = context->AudioCtrl;
  78
  79 //  *((ULONG*) 0x100000) = 1;
  80
  81   // Wait for start signal...
  82
  83   while( audioctrl->ahiac_PowerPCContext->Command != PPCC_COM_START );
  84
  85 //  *((ULONG*) 0x100000) = 4;
  86
  87   // Start m68k interrupt handler
  88
  89   audioctrl->ahiac_PowerPCContext->Command = PPCC_COM_INIT;
  90   *((WORD*) 0xdff09C)  = INTF_SETCLR | INTF_PORTS;
  91
  92 //  *((ULONG*) 0x100000) = 5;
  93
  94 #if 0
  95
  96   // Invalidate dynamic sample sounds (which is faster than flushing).
  97   // Currently, the PPC is assumed not to modify dynamic samples.
  98   // It makes sense as long as no PPC hooks can be called from AHI.
  99   // Anyway, each dynamic sample is flushed on the m68k side before
 100   // this routine is called, and invalidated here on the PPC side.
 101   // However, should a dynamic sample start at address 0, which
 102   // probably means that the whole address space is used for that
 103   // sample, all of the data caches are instead flushed.
 104
 105   sd = audioctrl->ahiac_SoundDatas;
 106
 107   for( i = 0; i < audioctrl->ac.ahiac_Sounds; i++)
 108   {
 109     if( sd->sd_Type == AHIST_DYNAMICSAMPLE )
 110     {
 111       if( sd->sd_Addr == NULL )
 112       {
 113         // *Flush* all and exit (add an L2 cache and watch this code break!)
 114
 115         FlushCacheAll();
 116         break;
 117       }
 118       else
 119       {
 120         // *Invalidate* block
 121
 122         InvalidateCache( sd->sd_Addr,
 123                          sd->sd_Length * SampleFrameSize( sd->sd_Type, AHIBase ) );
 124       }
 125     }
 126     sd++;
 127   }
 128
 129 #endif
 130
 131   // Wait for m68k interrupt handler to go active
 132
 133   while( audioctrl->ahiac_PowerPCContext->Command != PPCC_COM_ACK );
 134
 135 //  *((ULONG*) 0x100000) = 6;
 136
 137 #if 0
 138
 139   // Mix
 140
 141   Mix( context->Hook, context->Dst, audioctrl );
 142   DoMasterVolume( context->Dst, audioctrl );
 143
 144   // Flush mixed samples to memory
 145
 146   FlushCache( context->Dst, audioctrl->ahiac_BuffSizeNow );
 147
 148 #endif
 149
 150 //  *((ULONG*) 0x100000) = 7;
 151
 152   // Kill the m68k interrupt handler
 153
 154   audioctrl->ahiac_PowerPCContext->Command = PPCC_COM_QUIT;
 155   *((WORD*) 0xdff09C)  = INTF_SETCLR | INTF_PORTS;
 156
 157 //  *((ULONG*) 0x100000) = 8;
 158
 159   // Wait for it
 160
 161   while( audioctrl->ahiac_PowerPCContext->Command != PPCC_COM_ACK );
 162
 163 //  *((ULONG*) 0x100000) = 9;
 164
 165   audioctrl->ahiac_PowerPCContext->Command = PPCC_COM_FINISHED;
 166
 167 //  *((ULONG*) 0x100000) = 10;
 168
 169   return 0;
 170 }
 171
 172
 173 /******************************************************************************
 174 ** WarpUp/PPC cache manipulation routines *************************************
 175 ******************************************************************************/
 176
 177 asm( "
 178         .text
 179
 180 /* FlushCache ****************************************************************/
 181
 182 /*     r3 = beginning address of data block to flush
 183  *     r4 = size of data block to flush (in bytes)
 184  *     assumes cache block granule is 32 bytes
 185  */
 186
 187         .align  2
 188         .globl  FlushCache
 189         .type   FlushCache,@function
 190
 191 FlushCache:
 192         addi    4,4,31
 193         srwi    4,4,5           /* convert to cache blocks to flush */
 194         mtctr   4
 195         li      4,0
 196 1:
 197         dcbf    3,4             /* flush data cache block to mem */
 198         addi    4,4,32
 199         bdnz    1b
 200
 201         sync                    /* force mem transactions to complete */
 202         blr                     /* return to calling routine */
 203
 204
 205 /* FlushCacheAll *************************************************************/
 206
 207         .align  2
 208         .globl  FlushCacheAll
 209         .type   FlushCacheAll,@function
 210
 211 FlushCacheAll:
 212
 213 /* Load the entire data cache with known contents. */
 214         li      3,-16           /* Start at address 0 */
 215         li      4,2*256         /* 2 ways, 256 sets per way */
 216         mtctr   4               /* (use CTR register to save an instruction) */
 217 1:
 218         lwzu    5,16(3)         /* load a cache line if it's not already present */
 219         bdnz    1b
 220
 221 /* Flush those known contents from the cache. */
 222         li      3,0             /* Read 2*128*16 bytes at address 0 */
 223         mtctr   4               /* (use CTR register to save an instruction) */
 224 2:
 225         dcbf    0,3             /* flush a cache line */
 226         addi    3,3,16          /* next line: assumes cache lines are 16 bytes */
 227         bdnz    2b
 228         sync
 229         blr
 230
 231 /* InvalidateCache ***********************************************************/
 232
 233 /*     r3 = beginning address of data block to flush
 234  *     r4 = size of data block to flush (in bytes)
 235  *     assumes cache block granule is 32 bytes
 236  */
 237         .align  2
 238         .globl  InvalidateCache
 239         .type   InvalidateCache,@function
 240
 241 InvalidateCache:
 242         addi    4,4,31
 243         srwi    4,4,5           /* convert to cache blocks to invalidate */
 244         mtctr   4
 245         li      4,0
 246 1:
 247         dcbi    3,4             /* invalidate data cache block */
 248         addi    4,4,32
 249         bdnz    1b
 250
 251         sync                    /* force mem transactions to complete */
 252         blr                     /* return to calling routine */
 253
 254 ");
 255
 256
 257 /******************************************************************************
 258 ** WarpUp/PPC handling ********************************************************
 259 ******************************************************************************/
 260
 261 void WarpUpInterrupt( void );
 262
 263 struct TagItem InitTags[] =
 264 {
 265   { EXCATTR_CODE,  (ULONG) &WarpUpInterrupt,              },
 266   { EXCATTR_DATA,  0,                                     },
 267   { EXCATTR_NAME,  (ULONG) AHINAME " Exception Handler"   },
 268   { EXCATTR_PRI,   32,                                    },
 269   { EXCATTR_EXCID, EXCF_INTERRUPT,                        },
 270   { EXCATTR_FLAGS, EXCF_GLOBAL | EXCF_LARGECONTEXT,       },
 271   { TAG_DONE,      0                                      }
 272 };
 273
 274 asm( "
 275           .text
 276
 277 _LVOSetExcHandler = -516
 278 _LVORemExcHandler = -522
 279 _LVOSetExcMMU     = -576
 280 _LVOClearExcMMU   = -582
 281
 282 EXCRETURN_ABORT   = 1
 283
 284 # struct PowerPCContext
 285
 286 ppcc_Command          = 0*4
 287 ppcc_Argument         = 1*4
 288 ppcc_Active           = 2*4
 289 ppcc_Hook             = 3*4
 290 ppcc_Dst              = 4*4
 291 ppcc_XLock            = 5*4
 292 ppcc_AudioCtrl        = 6*4
 293 ppcc_PowerPCBase      = 7*4
 294 ppcc_MixInterrupt     = 8*4
 295 ppcc_MixBuffer        = 9*4
 296
 297 /* WarpUpRegisterExcHandler **************************************************/
 298
 299         .align  2
 300         .globl  WarpUpRegisterExcHandler
 301         .type   WarpUpRegisterExcHandler,@function
 302
 303 /*     r3 = struct PowerPCContext*
 304  */
 305
 306 WarpUpRegisterExcHandler:
 307         mflr    0
 308         stw     0,8(1)
 309         mfcr    0
 310         stw     0,4(1)
 311         stw     13,-4(1)
 312         subi    13,1,4
 313         stwu    1,-(28+14*4+1*4)(1)
 314
 315         stw     14,-4(13)
 316
 317         mr      14,3                        # Save PowerPCContext in r14
 318
 319 # Build the tag list on the stack
 320
 321         lis     4,(InitTags-4)@ha
 322         addi    4,4,InitTags-4@l
 323
 324         addi    5,1,28-4
 325
 326 1:
 327         lwzu    6,4(4)
 328         stwu    6,4(5)
 329         cmpwi   0,6,0
 330         lwzu    6,4(4)
 331         stwu    6,4(5)
 332         bne     1b
 333
 334         stw     14,28+3*4(1)                # Store PowerPCContext in tag list
 335
 336 # Register the exception handler
 337
 338         lwz     3,ppcc_PowerPCBase(14)
 339         addi    4,1,28
 340         lwz     0,_LVOSetExcHandler+2(3)
 341         mtlr    0
 342         blrl
 343
 344         stw     3,ppcc_XLock(14)
 345
 346         lwz     14,-4(13)
 347
 348         lwz     1,0(1)
 349         lwz     13,-4(1)
 350         lwz     0,4(1)
 351         mtcr    0
 352         lwz     0,8(1)
 353         mtlr    0
 354         blr
 355
 356
 357 /* WarpUpInterrupt ***********************************************************/
 358
 359         .align  2
 360         .globl  WarpUpInterrupt
 361         .type   WarpUpInterrupt,@function
 362
 363 WarpUpInterrupt:
 364         mflr    0
 365         stw     0,8(1)
 366         mfcr    0
 367         stw     0,4(1)
 368         stw     13,-4(1)
 369         subi    13,1,4
 370         stwu    1,-(28+1*4)(1)
 371
 372         stw     14,-4(13)
 373
 374         mr      14,2
 375
 376 # Set up MMU
 377
 378         lwz     3,ppcc_PowerPCBase(14)
 379         lwz     0,_LVOSetExcMMU+2(3)
 380         mtlr    0
 381         blrl
 382
 383 # Test and clear activation flag (is this our interrupt or somebody elses?)
 384
 385         addi    3,14,ppcc_Active
 386         li      4,0
 387 1:
 388         lwarx   5,0,3
 389         stwcx.  4,0,3
 390         bne-    1b
 391
 392         cmpwi   0,5,0
 393         beq     2f
 394
 395 # Call the CallMixroutine (V.4 ABI)
 396
 397         stwu    1,-16(1)
 398         stw     2,8(1)
 399         stw     13,12(1)
 400
 401         mr      3,14
 402         bl      CallMixroutine
 403
 404         lwz     2,8(1)
 405         lwz     13,12(1)
 406         addi    1,1,16
 407 2:
 408
 409 # Restore MMU
 410
 411         lwz     3,ppcc_PowerPCBase(14)
 412         lwz     0,_LVOClearExcMMU+2(3)
 413         mtlr    0
 414         blrl
 415
 416         li      3,EXCRETURN_ABORT
 417
 418         lwz     14,-4(13)
 419
 420         lwz     1,0(1)
 421         lwz     13,-4(1)
 422         lwz     0,4(1)
 423         mtcr    0
 424         lwz     0,8(1)
 425         mtlr    0
 426         blr
 427
 428 /* WarpUpRemoveExcHandler ****************************************************/
 429
 430         .align  2
 431         .globl  WarpUpRemoveExcHandler
 432         .type   WarpUpRemoveExcHandler,@function
 433
 434 /*     r3 = struct PowerPCContext*
 435  */
 436
 437 WarpUpRemoveExcHandler:
 438         mflr    0
 439         stw     0,8(1)
 440         mfcr    0
 441         stw     0,4(1)
 442         stw     13,-4(1)
 443         subi    13,1,4
 444         stwu    1,-28(1)
 445
 446 # Unregister the exception handler
 447
 448         lwz     4,ppcc_XLock(3)
 449         lwz     3,ppcc_PowerPCBase(3)
 450         lwz     0,_LVORemExcHandler+2(3)
 451         mtlr    0
 452         blrl
 453
 454         lwz     1,0(1)
 455         lwz     13,-4(1)
 456         lwz     0,4(1)
 457         mtcr    0
 458         lwz     0,8(1)
 459         mtlr    0
 460         blr
 461 ");
 462
 463 #endif /* __PPC__ */
 464
 465 /* WarpUpCallSoundHook *******************************************************/
 466
 467 void
 468 WarpUpCallSoundHook( struct AHIPrivAudioCtrl *audioctrl,
 469                      void* arg )
 470 {
 471
 472 #ifdef __PPC__
 473
 474   audioctrl->ahiac_PowerPCContext->Command  = PPCC_COM_SOUNDFUNC;
 475   audioctrl->ahiac_PowerPCContext->Argument = arg;
 476   *((WORD*) 0xdff09C)  = INTF_SETCLR | INTF_PORTS;
 477   while( audioctrl->ahiac_PowerPCContext->Command != PPCC_COM_ACK );
 478
 479 #else
 480
 481   // Crash and burn! We shouldn't be here!
 482   KPrintF( "WarpUpCallSoundHook() called from non-PPC code!\n" );
 483
 484 #endif /* __PPC__ */
 485 }
 486
 487
 488 /******************************************************************************
 489 ** m68k client code ***********************************************************
 490 ******************************************************************************/
 491
 492 #ifndef __PPC__
 493
 494 /* Interrupt *****************************************************************/
 495
 496 static INTERRUPT SAVEDS int
 497 Interrupt( struct AHIPrivAudioCtrl* audioctrl __asm( "a1" ) )
 498 {
 499
 500   if( audioctrl->ahiac_PowerPCContext->Command != PPCC_COM_INIT )
 501   {
 502     /* Not for us, continue */
 503     return 0;
 504   }
 505   else
 506   {
 507     BOOL running = TRUE;
 508 //kprintf("I");
 509     while( running )
 510     {
 511 //kprintf("0");
 512       switch( audioctrl->ahiac_PowerPCContext->Command )
 513       {
 514         case PPCC_COM_INIT:
 515 //kprintf("1");
 516           // Keep looping
 517           audioctrl->ahiac_PowerPCContext->Command = PPCC_COM_ACK;
 518           break;
 519
 520         case PPCC_COM_ACK:
 521 //kprintf("2");
 522           // Keep looping, try not to waste to much memory bandwidth...
 523           asm( "stop #(1<<13) | (2<<8)" : );
 524           break;
 525
 526         case PPCC_COM_SOUNDFUNC:
 527 //kprintf("3");
 528           CallHookPkt( audioctrl->ac.ahiac_SoundFunc,
 529                        audioctrl,
 530                        (APTR) audioctrl->ahiac_PowerPCContext->Argument );
 531           audioctrl->ahiac_PowerPCContext->Command = PPCC_COM_ACK;
 532           break;
 533
 534         case PPCC_COM_DEBUG:
 535 //kprintf("4");
 536           KPrintF( "%lx ", (ULONG) audioctrl->ahiac_PowerPCContext->Argument );
 537           audioctrl->ahiac_PowerPCContext->Command = PPCC_COM_ACK;
 538           break;
 539
 540         case PPCC_COM_QUIT:
 541 //kprintf("5");
 542           running = FALSE;
 543           audioctrl->ahiac_PowerPCContext->Command = PPCC_COM_ACK;
 544           break;
 545
 546         case PPCC_COM_NONE:
 547         default:
 548 //kprintf("6");
 549           // Error
 550           running  = FALSE;
 551           audioctrl->ahiac_PowerPCContext->Command = PPCC_COM_ACK;
 552           break;
 553       }
 554     }
 555 //kprintf("i");
 556
 557     /* End chain! */
 558     return 1;
 559   }
 560 };
 561
 562 #endif /* __PPC__ */
 563
 564 /* WarpUpInit ****************************************************************/
 565
 566 BOOL
 567 WarpUpInit( struct AHIPrivAudioCtrl* audioctrl )
 568 {
 569
 570 #ifdef __PPC__
 571
 572   // Crash and burn! We shouldn't be here!
 573   Req( "Internal error: WarpUpInit() called from PPC code!" );
 574   return FALSE;
 575
 576 #else
 577
 578   BOOL rc = FALSE;
 579
 580 //KPrintF( "WarpUpInit( 0x%08lx )", audioctrl );
 581
 582   audioctrl->ahiac_PowerPCContext =
 583     AllocVec32( sizeof( struct PowerPCContext ),
 584                         MEMF_PUBLIC | MEMF_CHIP | MEMF_CLEAR );
 585
 586   if( audioctrl->ahiac_PowerPCContext == NULL )
 587   {
 588     Req( "Out of memory." );
 589   }
 590   else
 591   {
 592     audioctrl->ahiac_PowerPCContext->Command      = PPCC_COM_NONE;
 593     audioctrl->ahiac_PowerPCContext->Active       = FALSE;
 594
 595     audioctrl->ahiac_PowerPCContext->AudioCtrl    = audioctrl;
 596     audioctrl->ahiac_PowerPCContext->PowerPCBase  = PowerPCBase;
 597
 598     audioctrl->ahiac_PowerPCContext->MixBuffer =
 599         AllocVec32( audioctrl->ac.ahiac_BuffSize,
 600                     MEMF_PUBLIC | MEMF_CLEAR );
 601
 602     if( audioctrl->ahiac_PowerPCContext->MixBuffer == NULL )
 603     {
 604       Req( "Out of memory." );
 605     }
 606     else
 607     {
 608       // Initialize the WarpUp side
 609
 610       struct PPCArgs args =
 611       {
 612         NULL,
 613         0,
 614         0,
 615         NULL,
 616         0,
 617         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 618         { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }
 619       };
 620
 621       args.PP_Regs[ 0 ] = (ULONG) audioctrl->ahiac_PowerPCContext;
 622
 623       if( ! AHIGetELFSymbol( "WarpUpRegisterExcHandler", &args.PP_Code ) )
 624       {
 625         Req( "Unable to fetch symbol 'WarpUpRegisterExcHandler'." );
 626       }
 627       else
 628       {
 629         if( RunPPC( &args ) != PPERR_SUCCESS )
 630         {
 631           Req( "Call to WarpUpRegisterExcHandler() failed." );
 632         }
 633         else
 634         {
 635           audioctrl->ahiac_PowerPCContext->MixInterrupt =
 636               AllocVec( sizeof( struct Interrupt ),
 637                                 MEMF_PUBLIC | MEMF_CLEAR );
 638
 639           if( audioctrl->ahiac_PowerPCContext->MixInterrupt == NULL )
 640           {
 641             Req( "Out of memory." );
 642           }
 643           else
 644           {
 645             struct Interrupt* mi = audioctrl->ahiac_PowerPCContext->MixInterrupt;
 646
 647             mi->is_Node.ln_Type = NT_INTERRUPT;
 648             mi->is_Node.ln_Pri  = 127;
 649             mi->is_Node.ln_Name = AHINAME " PPC Handler Interrupt";
 650             mi->is_Data         = audioctrl;
 651             mi->is_Code         = (void(*)(void)) Interrupt;
 652
 653             AddIntServer( INTB_PORTS, mi );
 654
 655             rc = TRUE;
 656           }
 657         }
 658       }
 659     }
 660   }
 661
 662 //KPrintF( "=> %ld\n", rc );
 663   return rc;
 664
 665 #endif /* __PPC__ */
 666
 667 }
 668
 669
 670 /* WarpUpCallMixer ***********************************************************/
 671
 672 void
 673 WarpUpCallMixer( struct AHIPrivAudioCtrl* audioctrl,
 674                  void* dst )
 675 {
 676
 677 #ifdef __PPC__
 678
 679   // Crash and burn! We shouldn't be here!
 680   KPrintF( "WarpUpCallMixer() called from PPC code!\n" );
 681
 682 #else
 683
 684   // Calls the PPC mixing code to fill a buffer with mixed samples
 685
 686   struct AHISoundData *sd;
 687   int                  i;
 688   BOOL                 flushed = FALSE;
 689
 690 //kprintf("M");
 691   // Flush all DYNAMICSAMPLE's
 692
 693   sd = audioctrl->ahiac_SoundDatas;
 694
 695   for( i = 0; i < audioctrl->ac.ahiac_Sounds; i++)
 696   {
 697     if( sd->sd_Type == AHIST_DYNAMICSAMPLE )
 698     {
 699       if( sd->sd_Addr == NULL )
 700       {
 701 //kprintf("a");
 702         // Flush all and exit
 703         CacheClearU();
 704         flushed = TRUE;
 705         break;
 706       }
 707       else
 708       {
 709 //kprintf("b");
 710         SetCache68K( CACHE_DCACHEFLUSH,
 711                      sd->sd_Addr,
 712                      sd->sd_Length * AHI_SampleFrameSize( sd->sd_Type ) );
 713       }
 714 //kprintf("c");
 715     }
 716     sd++;
 717   }
 718
 719 //kprintf("d");
 720   if( ! flushed )
 721   {
 722     /* Since the PPC mix buffer is m68k cacheable in WarpUp, we have to
 723        flush, or better, *invalidate* the cache before mixing starts. */
 724
 725     SetCache68K( CACHE_DCACHEFLUSH,
 726                  audioctrl->ahiac_PowerPCContext->MixBuffer,
 727                  audioctrl->ahiac_BuffSizeNow );
 728   }
 729 //kprintf("e");
 730
 731   audioctrl->ahiac_PowerPCContext->Hook         = audioctrl->ac.ahiac_MixerFunc;
 732   audioctrl->ahiac_PowerPCContext->Dst          = audioctrl->ahiac_PowerPCContext->MixBuffer;
 733   audioctrl->ahiac_PowerPCContext->Active       = TRUE;
 734   audioctrl->ahiac_PowerPCContext->Command      = PPCC_COM_START;
 735
 736   CausePPCInterrupt();
 737
 738 //kprintf("h");
 739   while( audioctrl->ahiac_PowerPCContext->Command != PPCC_COM_FINISHED );
 740 //kprintf("i");
 741
 742 #endif /* __PPC__ */
 743
 744 }
 745
 746
 747 /* WarpUpCleanUp *************************************************************/
 748
 749 void
 750 WarpUpCleanUp( struct AHIPrivAudioCtrl* audioctrl )
 751 {
 752
 753 #ifdef __PPC__
 754
 755   // Crash and burn! We shouldn't be here!
 756   Req( "Internal error: WarpUpCleanUp() called from PPC code!" );
 757
 758 #else
 759
 760   if( audioctrl->ahiac_PowerPCContext != NULL )
 761   {
 762     struct PPCArgs args =
 763     {
 764       NULL,
 765       0,
 766       0,
 767       NULL,
 768       0,
 769       { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 770       { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }
 771     };
 772
 773     if( audioctrl->ahiac_PowerPCContext->MixInterrupt != NULL )
 774     {
 775       RemIntServer( INTB_PORTS, audioctrl->ahiac_PowerPCContext->MixInterrupt );
 776     }
 777
 778     // Clean up the WarpUp side
 779
 780     args.PP_Regs[ 0 ] = (ULONG) audioctrl->ahiac_PowerPCContext;
 781
 782     if( ! AHIGetELFSymbol( "WarpUpRemoveExcHandler", &args.PP_Code ) )
 783     {
 784       Req( "Unable to fetch symbol 'WarpUpRemoveExcHandler'." );
 785     }
 786     else
 787     {
 788       RunPPC( &args );
 789     }
 790
 791     FreeVec( audioctrl->ahiac_PowerPCContext->MixInterrupt );
 792
 793     AHIFreeVec( audioctrl->ahiac_PowerPCContext->MixBuffer );
 794   }
 795
 796   AHIFreeVec( audioctrl->ahiac_PowerPCContext );
 797   audioctrl->ahiac_PowerPCContext = NULL;
 798
 799 #endif /* __PPC__ */
 800
 801 }