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

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