workbench/devs/AHI/Drivers/SB128/sb128.c

   1 /*
   2
   3 The contents of this file are subject to the AROS Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
   4 http://www.aros.org/license.html
   5
   6 Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
   7 ANY KIND, either express or implied. See the License for the specific language governing rights and
   8 limitations under the License.
   9
  10 The Original Code is (C) Copyright 2004-2011 Ross Vumbaca.
  11
  12 The Initial Developer of the Original Code is Ross Vumbaca.
  13
  14 All Rights Reserved.
  15
  16 */
  17
  18 #if !defined(__AROS__)
  19 #undef __USE_INLINE__
  20 #include <proto/expansion.h>
  21 extern struct UtilityIFace*        IUtility;
  22 extern struct AHIsubIFace*         IAHIsub;
  23 extern struct MMUIFace*            IMMU;
  24 #endif
  25
  26 #include <devices/ahi.h>
  27 #include <exec/memory.h>
  28 #include <libraries/ahi_sub.h>
  29
  30 #include <proto/ahi_sub.h>
  31 #include <proto/exec.h>
  32 #include <proto/dos.h>
  33 #include <proto/utility.h>
  34
  35 #ifdef __AROS__
  36 #include <aros/debug.h>
  37 #endif
  38 #include <string.h>
  39
  40 #include "library.h"
  41 #include "regs.h"
  42 #include "misc.h"
  43 #include "pci_wrapper.h"
  44
  45 extern void rate_set_dac2(struct SB128_DATA *card, unsigned long rate);
  46 extern void rate_set_adc(struct SB128_DATA *card, unsigned long rate);
  47
  48 /******************************************************************************
  49 ** Globals ********************************************************************
  50 ******************************************************************************/
  51
  52 #define FREQUENCIES 11
  53
  54 static const ULONG Frequencies[ FREQUENCIES ] =
  55 {
  56   5500,
  57   8000,     /* µ- and A-Law */
  58   9600,
  59   11025,    /* CD/4 */
  60   16000,    /* DAT/3 */
  61   19200,
  62   22050,    /* CD/2 */
  63   32000,    /* DAT/1.5 */
  64   38400,
  65   44100,    /* CD */
  66   48000     /* DAT */
  67 };
  68
  69 #define INPUTS 6
  70
  71 static const STRPTR Inputs[ INPUTS ] =
  72 {
  73   "Line in",
  74   "Mic",
  75   "CD",
  76   "Aux",
  77   "Mixer",
  78   "Phone"
  79 };
  80
  81 /* Not static since it's used in misc.c too */
  82 const UWORD InputBits[ INPUTS ] =
  83 {
  84   AC97_RECMUX_LINE,
  85   AC97_RECMUX_MIC,
  86   AC97_RECMUX_CD,
  87   AC97_RECMUX_AUX,
  88   AC97_RECMUX_STEREO_MIX,
  89   AC97_RECMUX_PHONE
  90 };
  91
  92
  93 #define OUTPUTS 1
  94
  95 static const STRPTR Outputs[ OUTPUTS ] =
  96 {
  97   "Front",
  98 };
  99
 100
 101 /******************************************************************************
 102 ** AHIsub_AllocAudio **********************************************************
 103 ******************************************************************************/
 104
 105 ULONG
 106 _AHIsub_AllocAudio( struct TagItem*         taglist,
 107                     struct AHIAudioCtrlDrv* AudioCtrl,
 108                     struct DriverBase*      AHIsubBase )
 109 {
 110   struct SB128Base* SB128Base = (struct SB128Base*) AHIsubBase;
 111
 112   int   card_num;
 113   ULONG ret;
 114   int   i;
 115
 116   card_num = ( GetTagData( AHIDB_AudioID, 0, taglist) & 0x0000f000 ) >> 12;
 117
 118   if( card_num >= SB128Base->cards_found ||
 119       SB128Base->driverdatas[ card_num ] == NULL )
 120   {
 121     Req( "No Card Data for card %ld.", card_num );
 122     return AHISF_ERROR;
 123   }
 124   else
 125   {
 126     struct SB128_DATA* card;
 127     BOOL in_use;
 128
 129     card  = SB128Base->driverdatas[ card_num ];
 130     AudioCtrl->ahiac_DriverData = card;
 131
 132     ObtainSemaphore( &SB128Base->semaphore );
 133     in_use = ( card->audioctrl != NULL );
 134     if( !in_use )
 135     {
 136       card->audioctrl = AudioCtrl;
 137     }
 138     ReleaseSemaphore( &SB128Base->semaphore );
 139
 140     if( in_use )
 141     {
 142       return AHISF_ERROR;
 143     }
 144
 145     card->playback_interrupt_enabled = FALSE;
 146     card->record_interrupt_enabled = FALSE;
 147     /* Clears playback/record interrupts */
 148     pci_outl((pci_inl(SB128_SCON, card)) & SB128_IRQ_MASK, SB128_SCON, card);
 149   }
 150
 151   ret = AHISF_KNOWHIFI | AHISF_KNOWSTEREO | AHISF_MIXING | AHISF_TIMING;
 152
 153
 154   for( i = 0; i < FREQUENCIES; ++i )
 155   {
 156     if( AudioCtrl->ahiac_MixFreq == Frequencies[ i ] )
 157     {
 158       ret |= AHISF_CANRECORD;
 159       break;
 160     }
 161   }
 162
 163   return ret;
 164 }
 165
 166
 167
 168 /******************************************************************************
 169 ** AHIsub_FreeAudio ***********************************************************
 170 ******************************************************************************/
 171
 172 void
 173 _AHIsub_FreeAudio( struct AHIAudioCtrlDrv* AudioCtrl,
 174                    struct DriverBase*      AHIsubBase )
 175 {
 176   struct SB128Base* SB128Base = (struct SB128Base*) AHIsubBase;
 177   struct SB128_DATA* card = (struct SB128_DATA*) AudioCtrl->ahiac_DriverData;
 178
 179   if( card != NULL )
 180   {
 181     ObtainSemaphore( &SB128Base->semaphore );
 182     if( card->audioctrl == AudioCtrl )
 183     {
 184       /* Release it if we own it. */
 185       card->audioctrl = NULL;
 186     }
 187     ReleaseSemaphore( &SB128Base->semaphore );
 188
 189     AudioCtrl->ahiac_DriverData = NULL;
 190   }
 191 }
 192
 193
 194 /******************************************************************************
 195 ** AHIsub_Disable *************************************************************
 196 ******************************************************************************/
 197
 198 void
 199 _AHIsub_Disable( struct AHIAudioCtrlDrv* AudioCtrl,
 200                  struct DriverBase*      AHIsubBase )
 201 {
 202   /* V6 drivers do not have to preserve all registers */
 203
 204   Disable();
 205 }
 206
 207
 208 /******************************************************************************
 209 ** AHIsub_Enable **************************************************************
 210 ******************************************************************************/
 211
 212 void
 213 _AHIsub_Enable( struct AHIAudioCtrlDrv* AudioCtrl,
 214                 struct DriverBase*      AHIsubBase )
 215 {
 216   /* V6 drivers do not have to preserve all registers */
 217
 218   Enable();
 219 }
 220
 221
 222 /******************************************************************************
 223 ** AHIsub_Start ***************************************************************
 224 ******************************************************************************/
 225
 226 ULONG
 227 _AHIsub_Start( ULONG                   flags,
 228                struct AHIAudioCtrlDrv* AudioCtrl,
 229                struct DriverBase*      AHIsubBase )
 230 {
 231   struct SB128_DATA* card = (struct SB128_DATA*) AudioCtrl->ahiac_DriverData;
 232   unsigned long PlayCtrlFlags = 0, RecCtrlFlags = 0;
 233   ULONG dma_buffer_size = 0;
 234   int i, freqbit = 9;
 235   APTR stack;
 236
 237   for( i = 0; i < FREQUENCIES; ++i )
 238   {
 239     if( AudioCtrl->ahiac_MixFreq == Frequencies[ i ] )
 240     {
 241       freqbit = i;
 242       break;
 243     }
 244   }
 245
 246   if( flags & AHISF_PLAY )
 247   {
 248
 249     ULONG dma_sample_frame_size;
 250     unsigned short ChannelsFlag;
 251
 252     ChannelsFlag = 0;
 253
 254     /* Update cached/syncronized variables */
 255
 256     AHIsub_Update( AHISF_PLAY, AudioCtrl );
 257
 258     /* Allocate a new mixing buffer. Note: The buffer must be cleared, since
 259        it might not be filled by the mixer software interrupt because of
 260        pretimer/posttimer! */
 261
 262     card->mix_buffer = AllocVec( AudioCtrl->ahiac_BuffSize,
 263                                MEMF_PUBLIC | MEMF_CLEAR );
 264
 265     if( card->mix_buffer == NULL )
 266     {
 267       Req( "Unable to allocate %ld bytes for mixing buffer.",
 268            AudioCtrl->ahiac_BuffSize );
 269       return AHIE_NOMEM;
 270     }
 271
 272     /* Allocate a buffer large enough for 16-bit double-buffered
 273        playback (mono or stereo) */
 274
 275     if( AudioCtrl->ahiac_Flags & AHIACF_STEREO )
 276     {
 277       dma_sample_frame_size = 4;
 278       dma_buffer_size = AudioCtrl->ahiac_MaxBuffSamples * dma_sample_frame_size;
 279       ChannelsFlag = SB128_STEREO;
 280     }
 281     else
 282     {
 283       dma_sample_frame_size = 2;
 284       dma_buffer_size = AudioCtrl->ahiac_MaxBuffSamples * dma_sample_frame_size;
 285     }
 286
 287     card->playback_buffer = pci_alloc_consistent(dma_buffer_size * 2, &card->playback_buffer_nonaligned, 128);
 288
 289     if (!card->playback_buffer)
 290     {
 291       Req( "Unable to allocate playback buffer." );
 292       return AHIE_NOMEM;
 293     }
 294
 295     /* Enable Playback interrupt */
 296     pci_outl((pci_inl(SB128_SCON, card) | SB128_DAC2_INTEN), SB128_SCON, card);
 297
 298     card->current_bytesize = dma_buffer_size;
 299     card->current_frames = AudioCtrl->ahiac_MaxBuffSamples;
 300     card->current_buffer   = card->playback_buffer + card->current_bytesize;
 301     card->playback_interrupt_enabled = TRUE;
 302
 303     card->flip = 0;
 304
 305     /* Select the DAC2 Memory Page */
 306     pci_outl(SB128_PAGE_DAC, SB128_MEMPAGE, card);
 307
 308     /* Buffer address and length (in longwords) is set */
 309     stack = SuperState();
 310 //    card->playback_buffer_phys = IMMU->GetPhysicalAddress(card->playback_buffer);
 311     card->playback_buffer_phys = card->playback_buffer;
 312     UserState(stack);
 313
 314     pci_outl((unsigned long)(card->playback_buffer_phys), SB128_DAC2_FRAME, card);
 315     pci_outl((((dma_buffer_size * 2) >> 2) - 1) & 0xFFFF, SB128_DAC2_COUNT, card);
 316
 317     /* Playback format is always 16 Bit, Stereo, but checks exist in case of a Mono mode (not possible). */
 318     PlayCtrlFlags = (SB128_16BIT | ChannelsFlag) << 2;
 319
 320     /* Set frequency */
 321     if (card->currentPlayFreq != freqbit)
 322     {
 323       rate_set_dac2(card, Frequencies[freqbit]);
 324       card->currentPlayFreq = freqbit;
 325     }
 326     card->is_playing = TRUE;
 327   }
 328
 329   if( flags & AHISF_RECORD )
 330   {
 331     card->current_record_bytesize = RECORD_BUFFER_SAMPLES * 4;
 332
 333     /* Allocate a new recording buffer (page aligned!) */
 334     card->record_buffer = pci_alloc_consistent(card->current_record_bytesize * 2, &card->record_buffer_nonaligned, 128);
 335
 336     if( card->record_buffer == NULL )
 337     {
 338       Req( "Unable to allocate %ld bytes for the recording buffer.", card->current_record_bytesize);
 339       return AHIE_NOMEM;
 340     }
 341
 342     SaveMixerState( card );
 343     UpdateMonitorMixer( card );
 344
 345     /* Enable record interrupt */
 346     pci_outl((pci_inl(SB128_SCON, card) | SB128_ADC_INTEN), SB128_SCON, card);
 347
 348     card->record_interrupt_enabled = TRUE;
 349
 350     card->recflip = 0;
 351
 352     /* Select the ADC Memory Page */
 353     pci_outl(SB128_PAGE_ADC, SB128_MEMPAGE, card);
 354
 355     /* Buffer address and length (in longwords) is set */
 356     stack = SuperState();
 357 //    card->record_buffer_phys = IMMU->GetPhysicalAddress(card->record_buffer);
 358     card->record_buffer_phys = card->record_buffer;
 359     UserState(stack);
 360
 361     pci_outl((unsigned long) card->record_buffer_phys, SB128_ADC_FRAME, card);
 362     pci_outl((((card->current_record_bytesize * 2) >> 2) - 1) & 0xFFFF, SB128_ADC_COUNT, card);
 363
 364     card->is_recording = TRUE;
 365     card->current_record_buffer = card->record_buffer + card->current_record_bytesize;
 366
 367     /* Record format is always 16 Bit, Stereo */
 368     RecCtrlFlags = (SB128_16BIT | SB128_STEREO) << 4;
 369
 370     /* Set frequency */
 371     if (card->currentRecFreq != freqbit)
 372     {
 373       rate_set_adc(card, Frequencies[freqbit]);
 374       card->currentRecFreq = freqbit;
 375     }
 376   }
 377
 378    if( flags & AHISF_PLAY )
 379    {
 380      /* Set Sample Count per Interrupt */
 381      if (PlayCtrlFlags & 0x04)
 382      {
 383        pci_outl(((dma_buffer_size >> 2) - 1) & 0xFFFF, SB128_DAC2_SCOUNT, card);
 384      }
 385      else
 386      {
 387        pci_outl(((dma_buffer_size >> 1) - 1) & 0xFFFF, SB128_DAC2_SCOUNT, card);
 388      }
 389      /* Set format, ENDINC set to 2 */
 390      pci_outl((pci_inl(SB128_SCON, card) | PlayCtrlFlags | 2 << 19), SB128_SCON, card);
 391      /* Start playback! */
 392      pci_outl((pci_inl(SB128_CONTROL, card) | CTRL_DAC2_EN), SB128_CONTROL, card);
 393    }
 394
 395    if( flags & AHISF_RECORD )
 396    {
 397      /* Set Sample Count per Interrupt */
 398      pci_outl(((card->current_record_bytesize >> 2) - 1) & 0xFFFF, SB128_ADC_SCOUNT, card);
 399      /* Set format */
 400      pci_outl((pci_inl(SB128_SCON, card) | RecCtrlFlags), SB128_SCON, card);
 401      /* Start recording! */
 402      pci_outl((pci_inl(SB128_CONTROL, card) | CTRL_ADC_EN), SB128_CONTROL, card);
 403    }
 404
 405    return AHIE_OK;
 406 }
 407
 408
 409 /******************************************************************************
 410 ** AHIsub_Update **************************************************************
 411 ******************************************************************************/
 412
 413 void
 414 _AHIsub_Update( ULONG                   flags,
 415                 struct AHIAudioCtrlDrv* AudioCtrl,
 416                 struct DriverBase*      AHIsubBase )
 417 {
 418   struct SB128_DATA* card = (struct SB128_DATA*) AudioCtrl->ahiac_DriverData;
 419
 420   card->current_frames = AudioCtrl->ahiac_BuffSamples;
 421
 422   if( AudioCtrl->ahiac_Flags & AHIACF_STEREO )
 423   {
 424     card->current_bytesize = card->current_frames * 4;
 425   }
 426   else
 427   {
 428     card->current_bytesize = card->current_frames * 2;
 429   }
 430 }
 431
 432
 433 /******************************************************************************
 434 ** AHIsub_Stop ****************************************************************
 435 ******************************************************************************/
 436
 437 void
 438 _AHIsub_Stop( ULONG                   flags,
 439               struct AHIAudioCtrlDrv* AudioCtrl,
 440               struct DriverBase*      AHIsubBase )
 441 {
 442   struct SB128_DATA* card = (struct SB128_DATA*) AudioCtrl->ahiac_DriverData;
 443
 444   if( flags & AHISF_PLAY )
 445   {
 446     unsigned long play_ctl;
 447     card->is_playing= FALSE;
 448
 449     play_ctl = pci_inl(SB128_CONTROL, card);
 450     play_ctl &= ~(CTRL_DAC2_EN);
 451     /* Stop */
 452     pci_outl(play_ctl, SB128_CONTROL, card);
 453
 454     /* Clear and mask interrupts */
 455     pci_outl((pci_inl(SB128_SCON, card)) & SB128_IRQ_MASK, SB128_SCON, card);
 456
 457     if (card->current_bytesize > 0)
 458        pci_free_consistent(card->playback_buffer_nonaligned);
 459
 460     card->current_bytesize     = 0;
 461     card->current_frames = 0;
 462     card->current_buffer   = NULL;
 463
 464     if ( card->mix_buffer)
 465        FreeVec( card->mix_buffer );
 466     card->mix_buffer = NULL;
 467     card->playback_interrupt_enabled = FALSE;
 468     card->current_bytesize = 0;
 469   }
 470
 471   if( flags & AHISF_RECORD )
 472   {
 473     unsigned long rec_ctl;
 474
 475     rec_ctl = pci_inl(SB128_CONTROL, card);
 476     rec_ctl &= ~(CTRL_ADC_EN);
 477     /* Stop */
 478     pci_outl(rec_ctl, SB128_CONTROL, card);
 479
 480     /* Clear and mask interrupts */
 481     pci_outl((pci_inl(SB128_SCON, card)) & SB128_IRQ_MASK, SB128_SCON, card);
 482
 483     if( card->is_recording )
 484     {
 485       /* Do not restore mixer unless they have been saved */
 486       RestoreMixerState( card );
 487     }
 488
 489     if( card->record_buffer != NULL )
 490     {
 491       pci_free_consistent( card->record_buffer_nonaligned);
 492     }
 493
 494     card->record_buffer = NULL;
 495     card->current_record_bytesize = 0;
 496
 497     card->is_recording = FALSE;
 498     card->record_interrupt_enabled = FALSE;
 499   }
 500
 501
 502 }
 503
 504
 505 /******************************************************************************
 506 ** AHIsub_GetAttr *************************************************************
 507 ******************************************************************************/
 508
 509 LONG
 510 _AHIsub_GetAttr( ULONG                   attribute,
 511                  LONG                    argument,
 512                  LONG                    def,
 513                  struct TagItem*         taglist,
 514                  struct AHIAudioCtrlDrv* AudioCtrl,
 515                  struct DriverBase*      AHIsubBase )
 516 {
 517   int i;
 518
 519   switch( attribute )
 520   {
 521     case AHIDB_Bits:
 522       return 16;
 523
 524     case AHIDB_Frequencies:
 525       return FREQUENCIES;
 526
 527     case AHIDB_Frequency: /* Index->Frequency */
 528       return (LONG) Frequencies[ argument ];
 529
 530     case AHIDB_Index: /* Frequency->Index */
 531       if( argument <= (LONG) Frequencies[ 0 ] )
 532       {
 533         return 0;
 534       }
 535
 536       if( argument >= (LONG) Frequencies[ FREQUENCIES - 1 ] )
 537       {
 538         return FREQUENCIES-1;
 539       }
 540
 541       for( i = 1; i < FREQUENCIES; i++ )
 542       {
 543         if( (LONG) Frequencies[ i ] > argument )
 544         {
 545           if( ( argument - (LONG) Frequencies[ i - 1 ] ) < ( (LONG) Frequencies[ i ] - argument ) )
 546           {
 547             return i-1;
 548           }
 549           else
 550           {
 551             return i;
 552           }
 553         }
 554       }
 555
 556       return 0;  /* Will not happen */
 557
 558     case AHIDB_Author:
 559       return (LONG) "Ross Vumbaca";
 560
 561     case AHIDB_Copyright:
 562       return (LONG) "(C) Ross Vumbaca";
 563
 564     case AHIDB_Version:
 565       return (LONG) LibIDString;
 566
 567     case AHIDB_Annotation:
 568       return (LONG)
 569         "AROS SB128/ES137x Audio driver";
 570
 571     case AHIDB_Record:
 572       return TRUE;
 573
 574     case AHIDB_FullDuplex:
 575       return TRUE;
 576
 577     case AHIDB_Realtime:
 578       return TRUE;
 579
 580     case AHIDB_MaxRecordSamples:
 581       return RECORD_BUFFER_SAMPLES;
 582
 583     /* formula's:
 584     #include <math.h>
 585
 586     unsigned long res = (unsigned long) (0x10000 * pow (10.0, dB / 20.0));
 587     double dB = 20.0 * log10(0xVALUE / 65536.0);
 588
 589     printf("dB = %f, res = %lx\n", dB, res);*/
 590
 591     case AHIDB_MinMonitorVolume:
 592       return 0x004d2;
 593
 594     case AHIDB_MaxMonitorVolume:
 595       return 0x3fb27;
 596
 597     case AHIDB_MinInputGain:
 598       return 0x10000; /* 0.0 dB gain */
 599
 600     case AHIDB_MaxInputGain:
 601       return 0xD55D0; /* 22.5 dB gain */
 602
 603     case AHIDB_MinOutputVolume:
 604       return 0x004d2; /* -34.5 dB / mute */
 605
 606     case AHIDB_MaxOutputVolume:
 607       return 0x3fb27; /* 12 dB */
 608
 609     case AHIDB_Inputs:
 610       return INPUTS;
 611
 612     case AHIDB_Input:
 613       return (LONG) Inputs[ argument ];
 614
 615     case AHIDB_Outputs:
 616       return OUTPUTS;
 617
 618     case AHIDB_Output:
 619       return (LONG) Outputs[ argument ];
 620
 621     default:
 622       return def;
 623   }
 624 }
 625
 626
 627 /******************************************************************************
 628 ** AHIsub_HardwareControl *****************************************************
 629 ******************************************************************************/
 630
 631 ULONG
 632 _AHIsub_HardwareControl( ULONG                   attribute,
 633                          LONG                    argument,
 634                          struct AHIAudioCtrlDrv* AudioCtrl,
 635                          struct DriverBase*      AHIsubBase )
 636 {
 637   struct SB128_DATA* card = (struct SB128_DATA*) AudioCtrl->ahiac_DriverData;
 638
 639   switch( attribute )
 640   {
 641     case AHIC_MonitorVolume:
 642       card->monitor_volume = Linear2MixerGain( (Fixed) argument, &card->monitor_volume_bits );
 643       if( card->is_recording )
 644       {
 645          UpdateMonitorMixer( card );
 646       }
 647       return TRUE;
 648
 649     case AHIC_MonitorVolume_Query:
 650       return card->monitor_volume;
 651
 652     case AHIC_InputGain:
 653       card->input_gain = Linear2RecordGain( (Fixed) argument, &card->input_gain_bits );
 654       if(card->es1370)
 655       {
 656         /* Not supported on ES1370 */
 657       }
 658       else
 659         codec_write(card, AC97_RECORD_GAIN, card->input_gain_bits );
 660       return TRUE;
 661
 662     case AHIC_InputGain_Query:
 663       return card->input_gain;
 664
 665     case AHIC_OutputVolume:
 666       card->output_volume = Linear2MixerGain( (Fixed) argument, &card->output_volume_bits );
 667       if(card->es1370)
 668       {
 669         ak4531_ac97_write(card, AC97_PCMOUT_VOL, card->output_volume_bits );
 670       }
 671       else
 672         codec_write(card, AC97_PCMOUT_VOL, card->output_volume_bits );
 673       return TRUE;
 674
 675     case AHIC_OutputVolume_Query:
 676       return card->output_volume;
 677
 678     case AHIC_Input:
 679       card->input = argument;
 680       if(card->es1370)
 681       {
 682         ak4531_ac97_write(card, AC97_RECORD_SELECT, InputBits[ card->input ] );
 683       }
 684       else
 685         codec_write(card, AC97_RECORD_SELECT, InputBits[ card->input ] );
 686
 687       if( card->is_recording )
 688       {
 689          UpdateMonitorMixer( card );
 690       }
 691       return TRUE;
 692
 693     case AHIC_Input_Query:
 694       return card->input;
 695
 696     case AHIC_Output:
 697       card->output = argument;
 698
 699       if( card->output == 0 )
 700       {
 701       }
 702       else
 703       {
 704       }
 705       return TRUE;
 706
 707     case AHIC_Output_Query:
 708       return card->output;
 709
 710     default:
 711       return FALSE;
 712   }
 713 }