workbench/devs/AHI/Drivers/ac97/ac97-main.c

   1
   2 #define DEBUG 1
   3 #include <aros/debug.h>
   4
   5 #include <devices/ahi.h>
   6 #include <dos/dostags.h>
   7 #include <exec/memory.h>
   8 #include <libraries/ahi_sub.h>
   9 #include <utility/tagitem.h>
  10
  11 #include <proto/ahi_sub.h>
  12 #include <proto/exec.h>
  13 #include <proto/dos.h>
  14 #include <proto/utility.h>
  15 #include <stddef.h>
  16
  17 #include <asm/io.h>
  18
  19 #include "library.h"
  20 #include "DriverData.h"
  21
  22 void
  23 SlaveEntry( void );
  24
  25 PROCGW( static, void,  slaveentry, SlaveEntry );
  26
  27
  28 /*  There is probably no reason to support all these frequencies. If,
  29  *  for example, your hardware is locked at 48 kHz, it's ok to only
  30  *  present one single mixing/recording frequency to the user. If your
  31  *  hardware has internal resamples and accepts any frequency, select a
  32  *  few common ones.
  33  */
  34
  35 static const LONG frequencies[] =
  36 {
  37   48000,    // DAT
  38 };
  39
  40 #define FREQUENCIES (sizeof frequencies / sizeof frequencies[ 0 ])
  41
  42 static const ULONG table_5bit[] = {
  43     0xb53c,
  44     0x804e,
  45     0x5ad5,
  46     0x404e,
  47     0x2d86,
  48     0x203a,
  49     0x16d1,
  50     0x1027,
  51     0x0b6f,
  52     0x0818,
  53     0x05bb,
  54     0x040f,
  55     0x02df,
  56     0x0209,
  57     0x0171,
  58     0x0105,
  59     0x00b9,
  60     0x0083,
  61     0x005d,
  62     0x0042,
  63     0x002e,
  64     0x0021,
  65     0x0017,
  66     0x0010,
  67     0x000c,
  68     0x0008,
  69     0x0006,
  70     0x0004,
  71     0x0003,
  72     0x0002,
  73     0x0001,
  74     0x0000
  75 };
  76
  77 static UWORD LinToLog(ULONG vol)
  78 {
  79     int i;
  80
  81     if (!vol) return 0x20;
  82
  83     for (i=0; i < 32; i++)
  84     {
  85         if (vol > table_5bit[i])
  86         {
  87             return i;
  88         }
  89     }
  90     return 0x1f;
  91 }
  92
  93 static AROS_INTP(play_int);
  94
  95
  96 /******************************************************************************
  97 ** AHIsub_AllocAudio **********************************************************
  98 ******************************************************************************/
  99
 100 ULONG
 101 _AHIsub_AllocAudio( struct TagItem*         taglist,
 102                     struct AHIAudioCtrlDrv* AudioCtrl,
 103                     struct DriverBase*      AHIsubBase )
 104 {
 105   struct ac97Base* ac97Base = (struct ac97Base*) AHIsubBase;
 106
 107   AudioCtrl->ahiac_DriverData = AllocVec( sizeof( struct AC97Data ),
 108                  MEMF_CLEAR | MEMF_PUBLIC );
 109
 110 #define dd ((struct AC97Data *) AudioCtrl->ahiac_DriverData)
 111
 112 D(bug("AHI: AllocAudio: dd=%08x\n", dd));
 113
 114   if( dd != NULL )
 115   {
 116     dd->slavesignal      = -1;
 117     dd->mastersignal     = AllocSignal( -1 );
 118     dd->mastertask       = (struct Process*) FindTask( NULL );
 119     dd->ahisubbase       = ac97Base;
 120     dd->out_volume       = 0x10000;
 121   }
 122   else
 123   {
 124     return AHISF_ERROR;
 125   }
 126
 127   {
 128         dd->irq.is_Node.ln_Type = NT_INTERRUPT;
 129         dd->irq.is_Node.ln_Pri = 0;
 130         dd->irq.is_Node.ln_Name = "AHI Int";
 131         dd->irq.is_Code = (APTR)play_int;
 132         dd->irq.is_Data = AudioCtrl;
 133
 134         AddIntServer(INTB_KERNEL + ac97Base->irq_num, &dd->irq);
 135   }
 136
 137 D(bug("AHI: AllocAudio: Everything OK\n"));
 138
 139   if( dd->mastersignal == -1 )
 140   {
 141     return AHISF_ERROR;
 142   }
 143
 144   /* Setting the only working frequency for AC97 */
 145   AudioCtrl->ahiac_MixFreq = 48000;
 146
 147   return ( AHISF_KNOWSTEREO |
 148            AHISF_MIXING |
 149            AHISF_TIMING );
 150 }
 151
 152
 153 /******************************************************************************
 154 ** AHIsub_FreeAudio ***********************************************************
 155 ******************************************************************************/
 156
 157 void
 158 _AHIsub_FreeAudio( struct AHIAudioCtrlDrv* AudioCtrl,
 159                    struct DriverBase*      AHIsubBase )
 160 {
 161   struct ac97Base* ac97Base = (struct ac97Base*) AHIsubBase;
 162
 163 D(bug("AHI: FreeAudio\n"));
 164
 165   RemIntServer(INTB_KERNEL + ac97Base->irq_num, &dd->irq);
 166
 167 D(bug("AHI: FreeAudio: IRQ removed\n"));
 168
 169   if( AudioCtrl->ahiac_DriverData != NULL )
 170   {
 171     FreeSignal( dd->mastersignal );
 172
 173 D(bug("AHI: FreeAudio: Signal freed\n"));
 174
 175     FreeVec( AudioCtrl->ahiac_DriverData );
 176
 177 D(bug("AHI: FreeAudio: DriverData freed\n"));
 178
 179     AudioCtrl->ahiac_DriverData = NULL;
 180   }
 181 }
 182
 183
 184 /******************************************************************************
 185 ** AHIsub_Disable *************************************************************
 186 ******************************************************************************/
 187
 188 void
 189 _AHIsub_Disable( struct AHIAudioCtrlDrv* AudioCtrl,
 190                  struct DriverBase*      AHIsubBase )
 191 {
 192   // V6 drivers do not have to preserve all registers
 193
 194   Disable();
 195 }
 196
 197
 198 /******************************************************************************
 199 ** AHIsub_Enable **************************************************************
 200 ******************************************************************************/
 201
 202 void
 203 _AHIsub_Enable( struct AHIAudioCtrlDrv* AudioCtrl,
 204                 struct DriverBase*      AHIsubBase )
 205 {
 206   // V6 drivers do not have to preserve all registers
 207
 208   Enable();
 209 }
 210
 211
 212 /******************************************************************************
 213 ** AHIsub_Start ***************************************************************
 214 ******************************************************************************/
 215
 216 ULONG
 217 _AHIsub_Start( ULONG                   flags,
 218                struct AHIAudioCtrlDrv* AudioCtrl,
 219                struct DriverBase*      AHIsubBase )
 220 {
 221   struct ac97Base* ac97Base = (struct ac97Base*) AHIsubBase;
 222
 223 D(bug("AHI: Start\n"));
 224
 225   AHIsub_Stop( flags, AudioCtrl );
 226
 227 D(bug("AHI: Start: Stop called\n"));
 228
 229   if(flags & AHISF_PLAY)
 230   {
 231     struct TagItem proctags[] =
 232     {
 233       { NP_Entry,     (IPTR) &slaveentry },
 234       { NP_Name,      (IPTR) LibName     },
 235       { NP_Priority,  -1                  },
 236       { TAG_DONE,     0                   }
 237     };
 238
 239     dd->mixbuffer = AllocVec( AudioCtrl->ahiac_BuffSize,
 240                                 MEMF_ANY | MEMF_PUBLIC );
 241
 242 D(bug("AHI: Start: Mixing buffer = %08x\n",dd->mixbuffer));
 243
 244     if( dd->mixbuffer == NULL ) return AHIE_NOMEM;
 245
 246     Forbid();
 247
 248     dd->slavetask = CreateNewProc( proctags );
 249
 250 D(bug("AHI: Start: Slave task = %08x\n",dd->slavetask));
 251
 252     if( dd->slavetask != NULL )
 253     {
 254       dd->slavetask->pr_Task.tc_UserData = AudioCtrl;
 255     }
 256
 257 D(bug("AHI: Start: Slave task UserData set\n"));
 258
 259     Permit();
 260
 261     if( dd->slavetask != NULL )
 262     {
 263       Wait( 1L << dd->mastersignal );  // Wait for slave to come alive
 264
 265 D(bug("AHI: Start: Slave task UP and running\n"));
 266
 267       if( dd->slavetask == NULL )      // Is slave alive or dead?
 268       {
 269         return AHIE_UNKNOWN;
 270       }
 271     }
 272     else
 273     {
 274       return AHIE_NOMEM;                 // Well, out of memory or whatever...
 275     }
 276   }
 277
 278   if( flags & AHISF_RECORD )
 279   {
 280     return AHIE_UNKNOWN;
 281   }
 282
 283 D(bug("AHI: Start: Everything OK\n"));
 284
 285   return AHIE_OK;
 286 }
 287
 288
 289 /******************************************************************************
 290 ** AHIsub_Update **************************************************************
 291 ******************************************************************************/
 292
 293 void
 294 _AHIsub_Update( ULONG                   flags,
 295                 struct AHIAudioCtrlDrv* AudioCtrl,
 296                 struct DriverBase*      AHIsubBase )
 297 {
 298   // Empty function
 299 }
 300
 301
 302 /******************************************************************************
 303 ** AHIsub_Stop ****************************************************************
 304 ******************************************************************************/
 305
 306 void
 307 _AHIsub_Stop( ULONG                   flags,
 308               struct AHIAudioCtrlDrv* AudioCtrl,
 309               struct DriverBase*      AHIsubBase )
 310 {
 311   if( flags & AHISF_PLAY )
 312   {
 313     if( dd->slavetask != NULL )
 314     {
 315       if( dd->slavesignal != -1 )
 316       {
 317         Signal( (struct Task*) dd->slavetask,
 318                 1L << dd->slavesignal );         // Kill him!
 319       }
 320
 321       Wait( 1L << dd->mastersignal );            // Wait for slave to die
 322     }
 323
 324     FreeVec( dd->mixbuffer );
 325     dd->mixbuffer = NULL;
 326   }
 327
 328   if(flags & AHISF_RECORD)
 329   {
 330     // Do nothing
 331   }
 332 }
 333
 334
 335 /******************************************************************************
 336 ** AHIsub_GetAttr *************************************************************
 337 ******************************************************************************/
 338
 339 IPTR
 340 _AHIsub_GetAttr( ULONG                   attribute,
 341                  LONG                    argument,
 342                  IPTR                    def,
 343                  struct TagItem*         taglist,
 344                  struct AHIAudioCtrlDrv* AudioCtrl,
 345                  struct DriverBase*      AHIsubBase )
 346 {
 347   size_t i;
 348
 349   switch( attribute )
 350   {
 351     case AHIDB_Bits:
 352       return 16;
 353
 354     case AHIDB_Frequencies:
 355       return FREQUENCIES;
 356
 357     case AHIDB_Frequency: // Index->Frequency
 358       return (LONG) frequencies[ argument ];
 359
 360     case AHIDB_Index: // Frequency->Index
 361       if( argument <= frequencies[ 0 ] )
 362       {
 363         return 0;
 364       }
 365
 366       if( argument >= frequencies[ FREQUENCIES - 1 ] )
 367       {
 368         return FREQUENCIES - 1;
 369       }
 370
 371       for( i = 1; i < FREQUENCIES; i++ )
 372       {
 373         if( frequencies[ i ] > argument )
 374         {
 375           if( ( argument - frequencies[ i - 1 ] ) <
 376               ( frequencies[ i ] - argument ) )
 377           {
 378             return i-1;
 379           }
 380           else
 381           {
 382             return i;
 383           }
 384         }
 385       }
 386
 387       return 0;  // Will not happen
 388
 389     case AHIDB_Author:
 390       return (IPTR) "Michal Schulz";
 391
 392     case AHIDB_Copyright:
 393       return (IPTR) "APL";
 394
 395     case AHIDB_Version:
 396       return (IPTR) LibIDString;
 397
 398     case AHIDB_Record:
 399       return FALSE;
 400
 401     case AHIDB_Realtime:
 402       return TRUE;
 403
 404     case AHIDB_Outputs:
 405       return 1;
 406
 407 /*
 408     case AHIDB_MinMonitorVolume:
 409       return 0x00000;
 410
 411     case AHIDB_MaxMonitorVolume:
 412       return 0x10000;
 413 */
 414     case AHIDB_MinOutputVolume:
 415       return 0x00000;
 416
 417     case AHIDB_MaxOutputVolume:
 418       return 0x10000;
 419
 420     case AHIDB_Output:
 421       return (IPTR) "Default";    // We have only one "output"!
 422
 423     default:
 424       return def;
 425   }
 426 }
 427
 428
 429 /******************************************************************************
 430 ** AHIsub_HardwareControl *****************************************************
 431 ******************************************************************************/
 432
 433 ULONG
 434 _AHIsub_HardwareControl( ULONG                   attribute,
 435                          LONG                    argument,
 436                          struct AHIAudioCtrlDrv* AudioCtrl,
 437                          struct DriverBase*      AHIsubBase )
 438 {
 439     struct ac97Base* ac97Base = (struct ac97Base*) AHIsubBase;
 440     UWORD vol;
 441
 442     switch(attribute)
 443     {
 444         case AHIC_OutputVolume:
 445             vol = LinToLog(argument);
 446
 447             if (vol == 0x20) vol = 0x8000;
 448             else vol = vol | vol << 8;
 449
 450             D(bug("SetVol %05x translated to %04x\n", argument, vol));
 451             dd->out_volume = argument;
 452             if (ac97Base->mixer_set_reg)
 453                 ac97Base->mixer_set_reg(ac97Base, AC97_PCM_VOL, vol);
 454             return TRUE;
 455
 456         case AHIC_OutputVolume_Query:
 457             return dd->out_volume;
 458     }
 459
 460     return 0;
 461 }
 462
 463 #undef SysBase
 464
 465 static AROS_INTH1(play_int, struct AHIAudioCtrlDrv *, AudioCtrl)
 466 {
 467     AROS_INTFUNC_INIT
 468
 469     struct DriverBase*      AHIsubBase;
 470     struct ac97Base*        ac97Base;
 471
 472     AHIsubBase = (struct DriverBase*) dd->ahisubbase;
 473     ac97Base   = (struct ac97Base*) AHIsubBase;
 474
 475     dd->old_SR = inw((IPTR)ac97Base->dmabase + ac97Base->off_po_sr);
 476     outw(dd->old_SR & 0x1c, (IPTR)ac97Base->dmabase + ac97Base->off_po_sr);
 477
 478     if ((dd->old_SR & 0x1c) && dd->slavetask)
 479     {
 480         /* Signaling the slave task */
 481         Signal((struct Task *)dd->slavetask, SIGBREAKF_CTRL_E);
 482     }
 483
 484     return FALSE;
 485
 486     AROS_INTFUNC_EXIT
 487 }