workbench/devs/AHI/Drivers/Aura/aura.c

   1 /*
   2 ** Because of the massive number of interrupts the Aura "soundcard" needs,
   3 ** this driver does some *very* ugly things:
   4 **  1) It requires both CIA-B timers.
   5 **  2) It takes complete control over the level 6 interrupt. Make sure
   6 **     nobody else is using it!
   7 **
   8 **  We use Timer A of CIA-B.
   9 **
  10 */
  11
  12
  13 #include <exec/exec.h>
  14 #include <dos/dos.h>
  15 #include <exec/interrupts.h>
  16 #include <hardware/cia.h>
  17 #include <resources/cia.h>
  18
  19 #include <proto/cia.h>
  20 #include <proto/exec.h>
  21 #include <proto/utility.h>
  22 #include <proto/ahi_sub.h>
  23
  24 #include <devices/ahi.h>
  25 #include <libraries/ahi_sub.h>
  26
  27 #include "aura.h"
  28
  29 #define EQ ==
  30 #define dd ((struct aura *) AudioCtrl->ahiac_DriverData)
  31
  32 #define RECBUFFERSIZE  2048   // in samples
  33
  34 #define STARTA_OR  CIACRAF_START
  35 #define STOPA_AND  CIACRAF_TODIN | CIACRAF_PBON | CIACRAF_OUTMODE | CIACRAF_SPMODE
  36 #define STOPB_AND  CIACRBF_ALARM | CIACRBF_PBON | CIACRBF_OUTMODE
  37
  38 extern void KPrintF(char *fmt,...);
  39
  40 extern char __far _LibID[];
  41 extern char __far _LibName[];
  42
  43 extern void __asm InstallUglyInterruptHack(register __a1 void (* )(), register __a2 struct aura *);
  44 extern void __asm UninstallUglyInterruptHack(register __a3 struct aura *);
  45 extern void __asm DummyFunc(void);
  46 extern void __asm DummyInt(void);
  47 extern void __asm PlayIntMono(void);
  48 extern void __asm RecordIntMono(void);
  49 extern void __asm PlayAndRecordIntMono(void);
  50 extern void __asm PlayIntStereo(void);
  51 extern void __asm RecordIntStereo(void);
  52 extern void __asm PlayAndRecordIntStereo(void);
  53 extern void __asm SoftFunc(void);
  54
  55 struct ExecBase *SysBase;
  56
  57 const static void *IntCodeTable[] =
  58 {
  59   DummyInt,
  60   PlayIntMono,
  61   RecordIntMono,
  62   PlayAndRecordIntMono,
  63
  64   DummyInt,
  65   PlayIntStereo,
  66   RecordIntStereo,
  67   PlayAndRecordIntStereo
  68
  69 };
  70
  71 #define FREQUENCIES 23
  72 const static ULONG frequency[FREQUENCIES] =
  73 {
  74   4410,         // CD/10
  75   4800,         // DAT/10
  76   5513,         // CD/8
  77   6000,         // DAT/8
  78   7350,         // CD/6
  79   8000,         // µ- and A-Law, DAT/6
  80   9600,         // DAT/5
  81         11025,        // CD/4
  82   12000,        // DAT/4
  83         14700,        // CD/3
  84   16000,        // DAT/3
  85         17640,        // CD/2.5
  86   18900,
  87         19200,        // DAT/2.5
  88   22050,        // CD/2
  89         24000,        // DAT/2
  90   27429,
  91         29400,        // CD/1.5
  92   32000,        // DAT/1.5
  93         33075,
  94   37800,
  95         44100,        // CD
  96   48000         // DAT
  97 };
  98
  99 struct Library        *UtilityBase = NULL;
 100 struct Library        *AHIsubBase = NULL;
 101 struct CIA            *ciab = (struct CIA *)0xbfd000;
 102 struct CIABase        *ciabbase = NULL;
 103
 104 BOOL InUse = FALSE;
 105
 106 int  __saveds __asm __UserLibInit (register __a6 struct Library *libbase)
 107 {
 108   SysBase = *(struct ExecBase **)4;
 109   AHIsubBase=libbase;
 110
 111   if( ! (UtilityBase=OpenLibrary("utility.library",37)))
 112   {
 113     Alert(AN_Unknown|AG_OpenLib|AO_UtilityLib);
 114     return 1;
 115   }
 116
 117   if( ! (ciabbase = OpenResource(CIABNAME)))
 118   {
 119     return 1;
 120   }
 121
 122   return 0;
 123 }
 124
 125 void __saveds __asm __UserLibCleanup (register __a6 struct Library *libbase)
 126 {
 127   if(UtilityBase)   { CloseLibrary(UtilityBase); UtilityBase=NULL; }
 128 }
 129
 130 ULONG __asm __saveds intAHIsub_AllocAudio(
 131     register __a1 struct TagItem *tagList,
 132     register __a2 struct AHIAudioCtrlDrv *AudioCtrl )
 133 {
 134
 135   // Only one user at the time!
 136
 137   Forbid();
 138   if(InUse)
 139   {
 140     Permit();
 141     return AHISF_ERROR;
 142   }
 143   InUse = TRUE;
 144   Permit();
 145
 146
 147   if(AudioCtrl->ahiac_DriverData=AllocVec(sizeof(struct aura),MEMF_PUBLIC|MEMF_CLEAR))
 148   {
 149
 150     dd->a_CIAperiod=SysBase->ex_EClockFrequency*2/AudioCtrl->ahiac_MixFreq;
 151     AudioCtrl->ahiac_MixFreq=SysBase->ex_EClockFrequency/dd->a_CIAperiod/2;
 152
 153     if(dd->a_AuraInt=AllocVec(sizeof(struct Interrupt),MEMF_PUBLIC|MEMF_ANY|MEMF_CLEAR))
 154     {
 155       dd->a_AuraInt->is_Node.ln_Type=NT_INTERRUPT;
 156       dd->a_AuraInt->is_Node.ln_Name=_LibName;
 157       dd->a_AuraInt->is_Data=AudioCtrl;
 158       // It will never be called anyway...
 159       dd->a_AuraInt->is_Code=(void (* )()) DummyFunc;
 160
 161       // Allocate Timer A
 162       if( ! (AddICRVector((struct Library *) ciabbase,CIAICRB_TA,dd->a_AuraInt)))
 163       {
 164         dd->a_GotTimerA = TRUE;
 165
 166         // Allocate Timer B
 167         if ( ! (AddICRVector((struct Library *)ciabbase,CIAICRB_TB,dd->a_AuraInt)))
 168         {
 169           dd->a_GotTimerB = TRUE;
 170
 171           // Stop both timers, set 02 pulse count-down mode, set continuous mode
 172           Disable();
 173           ciab->ciacra &= STOPA_AND;
 174           ciab->ciacrb &= STOPB_AND;
 175           Enable();
 176
 177           InstallUglyInterruptHack(DummyInt, (struct aura *)AudioCtrl->ahiac_DriverData);
 178
 179           if(dd->a_SoftInt = AllocVec(
 180               sizeof(struct Interrupt),MEMF_PUBLIC|MEMF_ANY|MEMF_CLEAR))
 181           {
 182             dd->a_SoftInt->is_Node.ln_Type=NT_INTERRUPT;
 183             dd->a_SoftInt->is_Node.ln_Name=_LibName;
 184             dd->a_SoftInt->is_Data=AudioCtrl;
 185             dd->a_SoftInt->is_Code=(void (* )()) SoftFunc;
 186
 187             if(TRUE)         // FIXIT: Check if hardware is present...
 188             {
 189               return AHISF_KNOWSTEREO|AHISF_CANRECORD|AHISF_MIXING|AHISF_TIMING;
 190             }
 191           }
 192         }
 193       }
 194     }
 195   }
 196   return AHISF_ERROR;
 197 }
 198
 199 void __asm __saveds intAHIsub_FreeAudio(
 200     register __a2 struct AHIAudioCtrlDrv *AudioCtrl )
 201 {
 202   if(AudioCtrl->ahiac_DriverData)
 203   {
 204     if(dd->a_GotTimerA && dd->a_GotTimerB)
 205     {
 206       UninstallUglyInterruptHack((struct aura *)AudioCtrl->ahiac_DriverData);
 207
 208       if(dd->a_GotTimerA)
 209       {
 210         RemICRVector((struct Library *)ciabbase,CIAICRB_TA,dd->a_AuraInt);
 211       }
 212       if(dd->a_GotTimerB)
 213       {
 214         RemICRVector((struct Library *)ciabbase,CIAICRB_TB,dd->a_AuraInt);
 215       }
 216     }
 217     FreeVec(dd->a_SoftInt);
 218     FreeVec(dd->a_AuraInt);
 219     FreeVec(AudioCtrl->ahiac_DriverData);
 220     AudioCtrl->ahiac_DriverData=NULL;
 221   }
 222
 223   InUse = FALSE;
 224 }
 225
 226
 227
 228 ULONG __asm __saveds intAHIsub_Start(
 229     register __d0 ULONG Flags,
 230     register __a2 struct AHIAudioCtrlDrv *AudioCtrl )
 231 {
 232
 233   if(Flags & AHISF_PLAY)
 234   {
 235     AHIsub_Stop(AHISF_PLAY,AudioCtrl);
 236
 237     if(!(dd->a_MixBuffer1=AllocVec(AudioCtrl->ahiac_BuffSize,MEMF_PUBLIC|MEMF_CLEAR|MEMF_ANY)))
 238       return AHIE_NOMEM;
 239
 240     if(!(dd->a_MixBuffer2=AllocVec(AudioCtrl->ahiac_BuffSize,MEMF_PUBLIC|MEMF_CLEAR|MEMF_ANY)))
 241       return AHIE_NOMEM;
 242
 243     dd->a_Status |= STATUS_PLAY;
 244
 245     switch(AudioCtrl->ahiac_BuffType)
 246     {
 247       case AHIST_M16S:
 248         dd->a_Status &= ~STATUS_STEREO;
 249         break;
 250       case AHIST_S16S:
 251         dd->a_Status |= STATUS_STEREO;
 252         break;
 253       default:
 254         return AHIE_BADSAMPLETYPE;
 255     }
 256     InstallUglyInterruptHack((void (* )())IntCodeTable[dd->a_Status],
 257         (struct aura *)AudioCtrl->ahiac_DriverData);
 258
 259 /*
 260     KPrintF("DummyInt: 0x%08lx\n",DummyInt);
 261     KPrintF("PlayIntMono: 0x%08lx\n",PlayIntMono);
 262     KPrintF("RecordIntMono: 0x%08lx\n",RecordIntMono);
 263     KPrintF("PlayAndRecordIntMono: 0x%08lx\n",PlayAndRecordIntMono);
 264
 265     KPrintF("DummyInt: 0x%08lx\n",DummyInt);
 266     KPrintF("PlayIntStereo: 0x%08lx\n",PlayIntStereo);
 267     KPrintF("RecordIntStereo: 0x%08lx\n",RecordIntStereo);
 268     KPrintF("PlayAndRecordIntStereo: 0x%08lx\n",PlayAndRecordIntStereo);
 269
 270     KPrintF("Code: 0x%08lx\n",IntCodeTable[dd->a_Status]);
 271 */
 272 // Start the interval timer - we will start the counter after
 273 // writing the low, and high byte counter values
 274
 275     ciab->ciatalo = dd->a_CIAperiod & 0xff;
 276     ciab->ciatahi = dd->a_CIAperiod>>8;
 277
 278 // Turn on start bit
 279
 280     Disable();
 281     ciab->ciacra |= STARTA_OR;
 282     Enable();
 283   }
 284
 285   if(Flags & AHISF_RECORD)
 286   {
 287     if(!(dd->a_RecBuffer1=AllocVec(RECBUFFERSIZE<<2,MEMF_ANY)))
 288       return AHIE_NOMEM;
 289     if(!(dd->a_RecBuffer2=AllocVec(RECBUFFERSIZE<<2,MEMF_ANY)))
 290       return AHIE_NOMEM;
 291     if(!(dd->a_RecMessage=AllocVec(sizeof(struct AHIRecordMessage),MEMF_ANY|MEMF_CLEAR)))
 292       return AHIE_NOMEM;
 293
 294     dd->a_RecMessage->ahirm_Type=AHIST_S16S;
 295
 296     dd->a_Status |= STATUS_RECORD;
 297     InstallUglyInterruptHack((void (* )())IntCodeTable[dd->a_Status],
 298         (struct aura *)AudioCtrl->ahiac_DriverData);
 299
 300 // Start the interval timer - we will start the counter after
 301 // writing the low, and high byte counter values
 302
 303     ciab->ciatalo = dd->a_CIAperiod & 0xff;
 304     ciab->ciatahi = dd->a_CIAperiod>>8;
 305
 306 // Turn on start bit
 307
 308     Disable();
 309     ciab->ciacra |= STARTA_OR;
 310     Enable();
 311   }
 312
 313   return AHIE_OK;
 314 }
 315
 316 void __asm __saveds __interrupt intAHIsub_Update(
 317     register __d0 ULONG Flags,
 318     register __a2 struct AHIAudioCtrlDrv *AudioCtrl )
 319 {
 320 }
 321
 322
 323 void __asm __saveds intAHIsub_Stop(
 324     register __d0 ULONG Flags,
 325     register __a2 struct AHIAudioCtrlDrv *AudioCtrl )
 326 {
 327   if(Flags & AHISF_PLAY)
 328   {
 329     dd->a_Status &= ~STATUS_PLAY;
 330     InstallUglyInterruptHack((void (* )())IntCodeTable[dd->a_Status],
 331         (struct aura *)AudioCtrl->ahiac_DriverData);
 332
 333     FreeVec(dd->a_MixBuffer1);
 334     dd->a_MixBuffer1=NULL;
 335     FreeVec(dd->a_MixBuffer2);
 336     dd->a_MixBuffer2=NULL;
 337   }
 338
 339   if(Flags & AHISF_RECORD)
 340   {
 341     dd->a_Status &= ~STATUS_RECORD;
 342     InstallUglyInterruptHack((void (* )())IntCodeTable[dd->a_Status],
 343         (struct aura *)AudioCtrl->ahiac_DriverData);
 344
 345     FreeVec(dd->a_RecBuffer1);
 346     dd->a_RecBuffer1=NULL;
 347     FreeVec(dd->a_RecBuffer2);
 348     dd->a_RecBuffer2=NULL;
 349     FreeVec(dd->a_RecMessage);
 350     dd->a_RecMessage=NULL;
 351   }
 352
 353   if(!(dd->a_Status & (STATUS_PLAY | STATUS_RECORD)))
 354   {
 355     // Stop timer, set 02 pulse count-down mode, set continuous mode
 356     Disable();
 357     ciab->ciacra &= STOPA_AND;
 358     Enable();
 359   }
 360 }
 361
 362
 363
 364 IPTR __asm __saveds intAHIsub_GetAttr(
 365     register __d0 ULONG Attribute,
 366     register __d1 LONG Argument,
 367     register __d2 IPTR Default,
 368     register __a1 struct TagItem *tagList,
 369     register __a2 struct AHIAudioCtrlDrv *AudioCtrl)
 370 {
 371   switch(Attribute)
 372   {
 373     case AHIDB_Bits:
 374       return 12;
 375     case AHIDB_Frequencies:
 376       return FREQUENCIES;
 377     case AHIDB_Frequency: // Index->Frequency
 378       return (LONG) frequency[Argument];
 379     case AHIDB_Index: // Frequency->Index
 380     {
 381       int i;
 382
 383       if(Argument<=frequency[0])
 384         return 0;
 385       if(Argument>=frequency[FREQUENCIES-1])
 386         return FREQUENCIES-1;
 387       for(i=1;i<FREQUENCIES;i++)
 388         if(frequency[i]>Argument)
 389         {
 390           if( (Argument-frequency[i-1]) < (frequency[i]-Argument) )
 391             return i-1;
 392           else
 393             return i;
 394         }
 395       return 0;  // Will not happen
 396     }
 397     case AHIDB_Author:
 398       return (IPTR) "Martin 'Leviticus' Blom";
 399     case AHIDB_Copyright:
 400       return (IPTR) "Public Domain";
 401     case AHIDB_Version:
 402       return (IPTR) _LibID;
 403     case AHIDB_Annotation:
 404       return (IPTR) "This driver plays some very nasty tricks with the\n"
 405                     "Level 6 interrupt, and will not work unless it can\n"
 406                     "get full control over both timer A and B.";
 407       break;
 408     case AHIDB_Record:
 409       return TRUE;
 410     case AHIDB_FullDuplex:
 411       return TRUE;
 412     case AHIDB_Realtime:
 413       return TRUE;
 414     case AHIDB_MaxRecordSamples:
 415       return RECBUFFERSIZE;
 416     case AHIDB_MinMonitorVolume:
 417     case AHIDB_MaxMonitorVolume:
 418       return 0x00000;
 419     case AHIDB_MinInputGain:
 420     case AHIDB_MaxInputGain:
 421     case AHIDB_MinOutputVolume:
 422     case AHIDB_MaxOutputVolume:
 423       return 0x10000;
 424     case AHIDB_Inputs:
 425     case AHIDB_Outputs:
 426       return 1;
 427     case AHIDB_Input:
 428     case AHIDB_Output:
 429       return (IPTR) "Line";
 430     default:
 431       return Default;
 432   }
 433 }
 434
 435 LONG __asm __saveds __interrupt intAHIsub_HardwareControl(
 436     register __d0 ULONG attribute,
 437     register __d1 LONG argument,
 438     register __a2 struct AHIAudioCtrlDrv *AudioCtrl )
 439 {
 440   switch (attribute)
 441   {
 442     case AHIC_MonitorVolume_Query:
 443       return 0;
 444     case AHIC_InputGain_Query:
 445     case AHIC_OutputVolume_Query:
 446       return 0x10000;
 447     case AHIC_Input_Query:
 448       return 0;                       // There is only one input
 449     case AHIC_Output_Query:
 450       return 0;                       // There is only one output
 451   }
 452   return FALSE;
 453 }