workbench/devs/AHI/Drivers/VIA-AC97/via.c

   1 /*
   2     Copyright © 2005-2013, Davy Wentzler. All rights reserved.
   3     Copyright © 2010-2016, The AROS Development Team. All rights reserved.
   4     $Id$
   5 */
   6
   7 #include <config.h>
   8
   9 #undef __USE_INLINE__
  10 #include <proto/expansion.h>
  11 #ifdef __amigaos4__
  12 extern struct UtilityIFace*        IUtility;
  13 extern struct AHIsubIFace*         IAHIsub;
  14 extern struct MMUIFace*            IMMU;
  15 #endif
  16
  17 #include <devices/ahi.h>
  18 #include <exec/memory.h>
  19 #include <libraries/ahi_sub.h>
  20
  21 #include <proto/ahi_sub.h>
  22 #include <proto/exec.h>
  23 #include <proto/dos.h>
  24 #include <proto/utility.h>
  25
  26 #include <string.h>
  27
  28 #include "library.h"
  29 #include "regs.h"
  30 #include "misc.h"
  31 #include "pci_wrapper.h"
  32
  33 #ifdef __AROS__
  34 #include <aros/debug.h>
  35 #define DebugPrintF bug
  36 #endif
  37
  38 /******************************************************************************
  39 ** Globals ********************************************************************
  40 ******************************************************************************/
  41
  42 #define FREQUENCIES 11
  43
  44 static const ULONG Frequencies[ FREQUENCIES ] =
  45 {
  46   5500,
  47   8000,     // µ- and A-Law
  48   9600,
  49   11025,    // CD/4
  50   16000,    // DAT/3
  51   19200,
  52   22050,    // CD/2
  53   32000,    // DAT/1.5
  54   38400,
  55   44100,    // CD
  56   48000     // DAT
  57 };
  58
  59 #define INPUTS 8
  60
  61 static const STRPTR Inputs[ INPUTS ] =
  62 {
  63   "Line in",
  64   "Mic",
  65   "CD",
  66   "Video",
  67   "Aux",
  68   "Mixer",
  69   "Mixer (mono)",
  70   "Phone"
  71 };
  72
  73 /* Not static since it's used in misc.c too */
  74 const UWORD InputBits[ INPUTS ] =
  75 {
  76   AC97_RECMUX_LINE,
  77   AC97_RECMUX_MIC,
  78   AC97_RECMUX_CD,
  79   AC97_RECMUX_VIDEO,
  80   AC97_RECMUX_AUX,
  81   AC97_RECMUX_STEREO_MIX,
  82   AC97_RECMUX_MONO_MIX,
  83   AC97_RECMUX_PHONE
  84 };
  85
  86
  87 #define OUTPUTS 1
  88
  89
  90 BOOL ac97_wait_idle2(struct CardData *card);
  91
  92 static const STRPTR Outputs[ OUTPUTS ] =
  93 {
  94   "Line",
  95 };
  96
  97 inline unsigned int codec_xread(struct CardData *card)
  98 {
  99     return pci_inl(VIA_REG_AC97, card);
 100 }
 101
 102
 103 inline void codec_xwrite(struct CardData *card, unsigned int val)
 104 {
 105     pci_outl(val, VIA_REG_AC97, card);
 106 }
 107
 108 int codec_ready(struct CardData *card)
 109 {
 110         unsigned int timeout = 100;    /* 1ms */
 111         unsigned int val;
 112
 113         while ( --timeout )
 114         {
 115                 val = codec_xread(card);
 116                 if (! (val & VIA_REG_AC97_BUSY))
 117                     return val & 0xffff;
 118                                 udelay( 1000 );
 119         }
 120
 121         snd_printk("(codec_ready()) AC97 codec not ready!\n");
 122         return -1;
 123 }
 124
 125 int codec_valid(struct CardData *card)
 126 {
 127         unsigned int timeout = 1000;    /* 1ms */
 128         unsigned int val, val1;
 129         unsigned int stat = VIA_REG_AC97_PRIMARY_VALID;
 130
 131         while (timeout-- > 0) {
 132                 val = codec_xread(card);
 133                 val1 = val & (VIA_REG_AC97_BUSY | stat);
 134                 if (val1 == stat)
 135                         return val & 0xffff;
 136                 udelay(1);
 137         }
 138         return -1;
 139 }
 140
 141 void codec_wait(struct CardData *card)
 142 {
 143         codec_ready(card);
 144         udelay(500);
 145 }
 146
 147 void codec_write(struct CardData *card,
 148                                     unsigned short reg,
 149                                     unsigned short val)
 150 {
 151         unsigned int xval;
 152
 153         xval = VIA_REG_AC97_CODEC_ID_PRIMARY;
 154         xval <<= VIA_REG_AC97_CODEC_ID_SHIFT;
 155         xval |= reg << VIA_REG_AC97_CMD_SHIFT;
 156         xval |= val << VIA_REG_AC97_DATA_SHIFT;
 157         codec_ready(card);
 158         codec_xwrite(card, xval);
 159         codec_ready(card);
 160 }
 161
 162
 163 BOOL ac97_wait_idle(struct CardData *card)
 164 {
 165         unsigned long   tul = 0;
 166         int                         cnt = 10000;
 167
 168         while( --cnt )
 169         {
 170                 if( !( ( tul = pci_inl(VIA_REG_AC97, card )) & VIA_REG_AC97_BUSY ) )
 171             return TRUE;
 172                 MicroDelay(100);
 173         }
 174
 175         DebugPrintF("Timed out waiting for AC97 controller!\n");
 176         return FALSE;
 177 }
 178
 179 unsigned short codec_read(struct CardData *card, unsigned char reg)
 180 {
 181         unsigned long xval;
 182         unsigned short data;
 183
 184         xval = 0;
 185         xval |= VIA_REG_AC97_PRIMARY_VALID;
 186         xval |= VIA_REG_AC97_READ;
 187         xval |= (reg & 0x7f) << VIA_REG_AC97_CMD_SHIFT;
 188
 189         ac97_wait_idle2(card);
 190         codec_xwrite(card, xval);
 191
 192         ac97_wait_idle2(card);
 193         xval = codec_xread(card);
 194
 195         data = (xval & 0xFFFF);
 196
 197         if ( !( xval & VIA_REG_AC97_PRIMARY_VALID) )
 198         {
 199             DebugPrintF("Codec read failed!\n");
 200         }
 201
 202         return data;
 203 }
 204
 205
 206 //IO base 0 registers
 207 static const unsigned char VIA_AC97_RX                                          = 0x80;                 //ac97 register
 208 //static const unsigned long            VIA_AC97_RX_PRIMARY_ID          = 0x00;                 //primamry codec ID (RW)
 209 //static const unsigned long            VIA_AC97_RX_SECODARY_ID         = 0x40000000;   //secondary codec ID (RW)
 210 //static const unsigned long            VIA_AC97_RX_SECODARY_VALID      = 0x08000000;   //secondary valid data/status/index (RWC)
 211 static const unsigned long              VIA_AC97_RX_PRIMARY_VALID       = 0x02000000;   //primary valid data etc. (RWC)
 212 static const unsigned long      VIA_AC97_RX_BUSY                        = 0x01000000;   //controller busy (R)
 213 static const unsigned long              VIA_AC97_RX_READ                        = 0x00800000;   //read/write select (RW)
 214
 215 static const unsigned char              VIA_AC97_RX_SHIFT                       = 0x10;                 //register shift
 216 static const unsigned long              VIA_AC97_RX_DATA_MASK           = 0xffff;               //data mask
 217
 218 BOOL ac97_wait_idle2(struct CardData *card)
 219 {
 220         unsigned long   tul = 0;
 221         int                         cnt = 26;   //..about half a second, for no good reason
 222
 223         while( --cnt )
 224         {
 225                 if( !( ( tul = pci_inl(VIA_AC97_RX, card) ) & VIA_AC97_RX_BUSY ) )
 226             return TRUE;
 227                 MicroDelay(1000);
 228         }
 229
 230         DebugPrintF("Timed out waiting for AC97 controller! VIA_AC97_RX = %lx\n", tul);
 231         return FALSE;
 232 }
 233
 234
 235 //note: this only reads the primary codec
 236 BOOL ac97_read_reg(struct CardData *card, unsigned char reg, unsigned short *data )
 237 {
 238         //set up with required codec register, read mode, and clear the primary codec valid flag
 239         unsigned long tul = ( ( reg << VIA_AC97_RX_SHIFT ) | VIA_AC97_RX_READ | VIA_AC97_RX_PRIMARY_VALID );
 240
 241         //wait for the controller to become free, and write the command
 242         ac97_wait_idle2(card);
 243         pci_outl(tul, VIA_AC97_RX, card);
 244
 245         //wait for the controller to become free, and read the result
 246         ac97_wait_idle2(card);
 247         tul = pci_inl(VIA_AC97_RX, card);
 248         *data = ( tul & VIA_AC97_RX_DATA_MASK );
 249
 250         //complain if the data/register etc. is invalid...
 251         if( !( tul & VIA_AC97_RX_PRIMARY_VALID ) )
 252         {
 253                 DebugPrintF("Info: (ac97_read_reg) Primary codec operation failed!\n");
 254                 return( FALSE );
 255         }
 256
 257         return( TRUE );
 258 }
 259
 260
 261
 262
 263
 264
 265 static void set_table_ptr(struct CardData *card, BOOL Play)
 266 {
 267     ULONG phys_addr;
 268 #ifdef __amigaos4__
 269     APTR stack;
 270 #endif
 271
 272     codec_ready(card);
 273     if (Play)
 274     {
 275 #ifdef __amigaos4__
 276         stack = IExec->SuperState();
 277         phys_addr = IMMU->GetPhysicalAddress(card->play_idx_table);
 278         IExec->UserState(stack);
 279 #else
 280         phys_addr = (ULONG)card->play_idx_table;
 281 #endif
 282
 283         pci_outl(phys_addr, 4, card);
 284     }
 285     else
 286     {
 287 #ifdef __amigaos4__
 288         stack = IExec->SuperState();
 289         phys_addr = IMMU->GetPhysicalAddress(card->rec_idx_table);
 290         IExec->UserState(stack);
 291 #else
 292         phys_addr = (ULONG)card->rec_idx_table;
 293 #endif
 294
 295         pci_outl(phys_addr, 4 + RECORD, card);
 296     }
 297
 298     udelay(20);
 299     codec_ready(card);
 300 }
 301
 302
 303
 304 #ifdef __amigaos4__
 305 #define tolittle(a) ((((ULONG) (a) & 0xFF000000) >> 24) | \
 306                      (((ULONG) (a) & 0x00FF0000) >> 8)  | \
 307                      (((ULONG) (a) & 0x0000FF00) << 8)  | \
 308                      (((ULONG) (a) & 0x000000FF) << 24))
 309 #else
 310 #define tolittle(a) AROS_LONG2LE(a)
 311 #endif
 312
 313 static int build_via_table(struct CardData *card, APTR sgbuf1, APTR sgbuf2, int OneBufferSize, struct snd_via_sg_table **idx,
 314                            APTR *idx_nonaligned)
 315 {
 316     ULONG phys_addr;
 317 #ifdef __amigaos4__
 318     APTR stack;
 319 #endif
 320
 321     *idx = pci_alloc_consistent(sizeof(**idx) * 4, idx_nonaligned);
 322
 323 #ifdef __amigaos4__
 324     stack = IExec->SuperState();
 325     phys_addr = IMMU->GetPhysicalAddress(sgbuf1);
 326     IExec->UserState(stack);
 327 #else
 328     phys_addr = (ULONG)sgbuf1;
 329 #endif
 330
 331     (*idx)[0].offset = (APTR) tolittle(phys_addr);
 332     (*idx)[0].size = tolittle( (OneBufferSize) | VIA_TBL_BIT_FLAG);
 333
 334 #ifdef __amigaos4__
 335     stack = IExec->SuperState();
 336     phys_addr = IMMU->GetPhysicalAddress(sgbuf2);
 337     IExec->UserState(stack);
 338 #else
 339     phys_addr = (ULONG)sgbuf2;
 340 #endif
 341
 342     (*idx)[1].offset = (APTR) tolittle(phys_addr);
 343     (*idx)[1].size = tolittle( (OneBufferSize) | VIA_TBL_BIT_EOL );
 344
 345     CacheClearE(*idx, sizeof(**idx) * 4, CACRF_ClearD);
 346     //DebugPrintF("===> play_idx_table at %lx, %lx\n", *idx, *idx_nonaligned);
 347
 348     return 0;
 349 }
 350
 351
 352 /******************************************************************************
 353 ** AHIsub_AllocAudio **********************************************************
 354 ******************************************************************************/
 355
 356 ULONG
 357 _AHIsub_AllocAudio( struct TagItem*         taglist,
 358                     struct AHIAudioCtrlDrv* AudioCtrl,
 359                     struct DriverBase*      AHIsubBase )
 360 {
 361   struct CardBase* CardBase = (struct CardBase*) AHIsubBase;
 362
 363   int   card_num;
 364   ULONG ret;
 365   int   i;
 366
 367
 368
 369   card_num = (GetTagData( AHIDB_AudioID, 0, taglist) & 0x0000f000 ) >> 12;
 370
 371   if( card_num >= CardBase->cards_found ||
 372       CardBase->driverdatas[ card_num ] == NULL )
 373   {
 374     DebugPrintF("no date for card = %ld\n", card_num);
 375     Req( "No CardData for card %ld.", card_num );
 376     return AHISF_ERROR;
 377   }
 378   else
 379   {
 380     BOOL                in_use;
 381     struct CardData *card;
 382
 383     card  = CardBase->driverdatas[ card_num ];
 384     AudioCtrl->ahiac_DriverData = card;
 385
 386     ObtainSemaphore( &CardBase->semaphore );
 387     in_use = ( card->audioctrl != NULL );
 388     if( !in_use )
 389     {
 390       card->audioctrl = AudioCtrl;
 391     }
 392     ReleaseSemaphore( &CardBase->semaphore );
 393
 394     if( in_use )
 395     {
 396       return AHISF_ERROR;
 397     }
 398
 399     card->playback_interrupt_enabled = FALSE;
 400     card->record_interrupt_enabled = FALSE;
 401   }
 402
 403   ret = AHISF_KNOWHIFI | AHISF_KNOWSTEREO | AHISF_MIXING | AHISF_TIMING;
 404
 405
 406   for( i = 0; i < FREQUENCIES; ++i )
 407   {
 408     if( AudioCtrl->ahiac_MixFreq == Frequencies[ i ] )
 409     {
 410       ret |= AHISF_CANRECORD;
 411       break;
 412     }
 413   }
 414
 415   return ret;
 416 }
 417
 418
 419
 420 /******************************************************************************
 421 ** AHIsub_FreeAudio ***********************************************************
 422 ******************************************************************************/
 423
 424 void
 425 _AHIsub_FreeAudio( struct AHIAudioCtrlDrv* AudioCtrl,
 426                    struct DriverBase*      AHIsubBase )
 427 {
 428   struct CardBase* CardBase = (struct CardBase*) AHIsubBase;
 429   struct CardData* card = (struct CardData*) AudioCtrl->ahiac_DriverData;
 430
 431   if( card != NULL )
 432   {
 433     ObtainSemaphore( &CardBase->semaphore );
 434     if( card->audioctrl == AudioCtrl )
 435     {
 436       // Release it if we own it.
 437       card->audioctrl = NULL;
 438     }
 439     ReleaseSemaphore( &CardBase->semaphore );
 440
 441     AudioCtrl->ahiac_DriverData = NULL;
 442   }
 443 }
 444
 445
 446 /******************************************************************************
 447 ** AHIsub_Disable *************************************************************
 448 ******************************************************************************/
 449
 450 void
 451 _AHIsub_Disable( struct AHIAudioCtrlDrv* AudioCtrl,
 452                  struct DriverBase*      AHIsubBase )
 453 {
 454   // V6 drivers do not have to preserve all registers
 455
 456   Disable();
 457 }
 458
 459
 460 /******************************************************************************
 461 ** AHIsub_Enable **************************************************************
 462 ******************************************************************************/
 463
 464 void
 465 _AHIsub_Enable( struct AHIAudioCtrlDrv* AudioCtrl,
 466                 struct DriverBase*      AHIsubBase )
 467 {
 468   // V6 drivers do not have to preserve all registers
 469
 470   Enable();
 471 }
 472
 473
 474 /******************************************************************************
 475 ** AHIsub_Start ***************************************************************
 476 ******************************************************************************/
 477
 478 ULONG
 479 _AHIsub_Start( ULONG                   flags,
 480                struct AHIAudioCtrlDrv* AudioCtrl,
 481                struct DriverBase*      AHIsubBase )
 482 {
 483   struct CardData* card = (struct CardData*) AudioCtrl->ahiac_DriverData;
 484   ULONG dma_buffer_size = 0;
 485   unsigned short uval;
 486
 487   //channel_reset(card);
 488   codec_write(card, 0x2, 0);
 489   codec_write(card, 0x08, 0x0F0F);
 490   codec_write(card, 0x0A, 0x8000);
 491   codec_write(card, 0x18, 0x0808);
 492
 493   uval = codec_read(card, 0x2A);
 494   codec_write(card, 0x2A, uval | 0x1); // enable VRA
 495   codec_write(card, 0x2C, AudioCtrl->ahiac_MixFreq);
 496
 497
 498   if( flags & AHISF_PLAY )
 499   {
 500
 501     ULONG dma_sample_frame_size;
 502
 503     card->mix_buffer = AllocVec( AudioCtrl->ahiac_BuffSize, MEMF_PUBLIC | MEMF_CLEAR );
 504
 505     if( card->mix_buffer == NULL )
 506     {
 507       Req( "Unable to allocate %ld bytes for mixing buffer.",
 508            AudioCtrl->ahiac_BuffSize );
 509       return AHIE_NOMEM;
 510     }
 511
 512     /* Allocate a buffer large enough for 16-bit double-buffered
 513        playback (mono or stereo) */
 514
 515
 516     if( AudioCtrl->ahiac_Flags & AHIACF_STEREO )
 517     {
 518       dma_sample_frame_size = 4;
 519       dma_buffer_size = AudioCtrl->ahiac_MaxBuffSamples * dma_sample_frame_size;
 520     }
 521     else
 522     {
 523       dma_sample_frame_size = 2;
 524       dma_buffer_size = AudioCtrl->ahiac_MaxBuffSamples * dma_sample_frame_size;
 525     }
 526
 527     //DebugPrintF("dma_buffer_size = %ld, %lx\n", dma_buffer_size, dma_buffer_size);
 528
 529     card->playback_buffer1 = pci_alloc_consistent(dma_buffer_size, &card->playback_buffer1_nonaligned);
 530     card->playback_buffer2 = pci_alloc_consistent(dma_buffer_size, &card->playback_buffer2_nonaligned);
 531
 532     if (!card->playback_buffer1)
 533     {
 534       Req( "Unable to allocate playback buffer." );
 535       return AHIE_NOMEM;
 536     }
 537
 538     CacheClearE(card->playback_buffer1, dma_buffer_size, CACRF_ClearD);
 539     CacheClearE(card->playback_buffer2, dma_buffer_size, CACRF_ClearD);
 540
 541     card->current_bytesize = dma_buffer_size;
 542     card->current_frames = AudioCtrl->ahiac_MaxBuffSamples;
 543     card->current_buffer   = card->playback_buffer1;
 544     card->playback_interrupt_enabled = TRUE;
 545
 546     build_via_table(card, card->playback_buffer1, card->playback_buffer2, dma_buffer_size, &card->play_idx_table, &card->play_idx_table_nonaligned);
 547     set_table_ptr(card, TRUE);
 548
 549     pci_outb(VIA_REG_TYPE_AUTOSTART | 0x40 |
 550              VIA_REG_TYPE_16BIT |
 551              VIA_REG_TYPE_STEREO |
 552              VIA_REG_TYPE_INT_LSAMPLE |
 553              VIA_REG_TYPE_INT_EOL |
 554              VIA_REG_TYPE_INT_FLAG,
 555              VIA_REG_OFFSET_TYPE, card);
 556
 557     card->flip = 0;
 558
 559     card->is_playing = TRUE;
 560   }
 561
 562   if( flags & AHISF_RECORD )
 563   {
 564     card->current_record_bytesize = RECORD_BUFFER_SAMPLES * 4;
 565
 566     /* Allocate a new recording buffer (page aligned!) */
 567     card->record_buffer1 = pci_alloc_consistent(card->current_record_bytesize, &card->record_buffer1_nonaligned);
 568     card->record_buffer2 = pci_alloc_consistent(card->current_record_bytesize, &card->record_buffer2_nonaligned);
 569
 570     if( card->record_buffer1 == NULL )
 571     {
 572       Req( "Unable to allocate %ld bytes for the recording buffer.", card->current_record_bytesize);
 573       return AHIE_NOMEM;
 574     }
 575
 576     SaveMixerState( card );
 577     UpdateMonitorMixer( card );
 578
 579     card->record_interrupt_enabled = TRUE;
 580
 581     card->recflip = 0;
 582
 583     build_via_table(card, card->record_buffer1, card->record_buffer2, card->current_record_bytesize, &card->rec_idx_table, &card->rec_idx_table_nonaligned);
 584     set_table_ptr(card, FALSE);
 585
 586     pci_outb(VIA_REG_TYPE_AUTOSTART | 0x40 |
 587              VIA_REG_TYPE_16BIT |
 588              VIA_REG_TYPE_STEREO |
 589              VIA_REG_TYPE_INT_EOL |
 590              VIA_REG_TYPE_INT_FLAG,
 591              VIA_REG_OFFSET_TYPE + RECORD,
 592              card);
 593
 594     card->is_recording = TRUE;
 595     card->current_record_buffer = card->record_buffer1;
 596
 597   }
 598
 599    if( flags & AHISF_PLAY )
 600    {
 601       unsigned char val;
 602
 603       val = VIA_REG_CTRL_START;
 604       pci_outb(val, VIA_REG_OFFSET_CONTROL, card);
 605    }
 606
 607    if( flags & AHISF_RECORD )
 608    {
 609       unsigned char val;
 610
 611       val = VIA_REG_CTRL_START;
 612       pci_outb(val, VIA_REG_OFFSET_CONTROL + RECORD, card);
 613    }
 614
 615   return AHIE_OK;
 616 }
 617
 618
 619 /******************************************************************************
 620 ** AHIsub_Update **************************************************************
 621 ******************************************************************************/
 622
 623 void
 624 _AHIsub_Update( ULONG                   flags,
 625                 struct AHIAudioCtrlDrv* AudioCtrl,
 626                 struct DriverBase*      AHIsubBase )
 627 {
 628   struct CardData* card = (struct CardData*) AudioCtrl->ahiac_DriverData;
 629
 630   card->current_frames = AudioCtrl->ahiac_BuffSamples;
 631
 632   if( AudioCtrl->ahiac_Flags & AHIACF_STEREO )
 633   {
 634     card->current_bytesize = card->current_frames * 4;
 635   }
 636   else
 637   {
 638     card->current_bytesize = card->current_frames * 2;
 639   }
 640 }
 641
 642
 643 /******************************************************************************
 644 ** AHIsub_Stop ****************************************************************
 645 ******************************************************************************/
 646
 647 void
 648 _AHIsub_Stop( ULONG                   flags,
 649               struct AHIAudioCtrlDrv* AudioCtrl,
 650               struct DriverBase*      AHIsubBase )
 651 {
 652   struct CardData* card = (struct CardData*) AudioCtrl->ahiac_DriverData;
 653
 654   unsigned char val;
 655
 656   val = VIA_REG_CTRL_TERMINATE;
 657
 658   if( flags & AHISF_PLAY && card->is_playing)
 659   {
 660     pci_outb(val, VIA_REG_OFFSET_CONTROL, card);
 661     card->is_playing= FALSE;
 662
 663     if (card->current_bytesize > 0)
 664     {
 665        pci_free_consistent(card->playback_buffer1);
 666        pci_free_consistent(card->playback_buffer2);
 667     }
 668
 669     card->current_bytesize     = 0;
 670     card->current_frames = 0;
 671     card->current_buffer   = NULL;
 672
 673     if ( card->mix_buffer)
 674        FreeVec( card->mix_buffer );
 675     card->mix_buffer = NULL;
 676     card->playback_interrupt_enabled = FALSE;
 677
 678     if (card->play_idx_table_nonaligned)
 679     {
 680         FreeVec(card->play_idx_table_nonaligned);
 681     }
 682     card->play_idx_table = NULL;
 683   }
 684
 685   if( flags & AHISF_RECORD && card->is_recording)
 686   {
 687     pci_outb(val, VIA_REG_OFFSET_CONTROL + RECORD, card);
 688     if( card->is_recording )
 689     {
 690       // Do not restore mixer unless they have been saved
 691       RestoreMixerState( card );
 692     }
 693
 694     if( card->record_buffer1 != NULL )
 695     {
 696       pci_free_consistent( card->record_buffer1);
 697       pci_free_consistent( card->record_buffer2);
 698     }
 699
 700     card->record_buffer1 = NULL;
 701     card->record_buffer2 = NULL;
 702     card->current_record_bytesize = 0;
 703
 704     card->is_recording = FALSE;
 705     card->record_interrupt_enabled = FALSE;
 706
 707     pci_free_consistent(card->rec_idx_table_nonaligned);
 708     card->rec_idx_table = NULL;
 709
 710   }
 711
 712   card->current_bytesize = 0;
 713 }
 714
 715
 716 /******************************************************************************
 717 ** AHIsub_GetAttr *************************************************************
 718 ******************************************************************************/
 719
 720 SIPTR
 721 _AHIsub_GetAttr( ULONG                   attribute,
 722                  LONG                    argument,
 723                  LONG                    def,
 724                  struct TagItem*         taglist,
 725                  struct AHIAudioCtrlDrv* AudioCtrl,
 726                  struct DriverBase*      AHIsubBase )
 727 {
 728   int i;
 729
 730   switch( attribute )
 731   {
 732     case AHIDB_Bits:
 733       return 16;
 734
 735     case AHIDB_Frequencies:
 736       return FREQUENCIES;
 737
 738     case AHIDB_Frequency: // Index->Frequency
 739       return (SIPTR) Frequencies[ argument ];
 740
 741     case AHIDB_Index: // Frequency->Index
 742       if( argument <= (LONG) Frequencies[ 0 ] )
 743       {
 744         return 0;
 745       }
 746
 747       if( argument >= (LONG) Frequencies[ FREQUENCIES - 1 ] )
 748       {
 749         return FREQUENCIES-1;
 750       }
 751
 752       for( i = 1; i < FREQUENCIES; i++ )
 753       {
 754         if( (LONG) Frequencies[ i ] > argument )
 755         {
 756           if( ( argument - (LONG) Frequencies[ i - 1 ] ) < ( (LONG) Frequencies[ i ] - argument ) )
 757           {
 758             return i-1;
 759           }
 760           else
 761           {
 762             return i;
 763           }
 764         }
 765       }
 766
 767       return 0;  // Will not happen
 768
 769     case AHIDB_Author:
 770       return (SIPTR) "Davy Wentzler";
 771
 772     case AHIDB_Copyright:
 773       return (SIPTR) "(C) Davy Wentzler";
 774
 775     case AHIDB_Version:
 776       return (SIPTR) LibIDString;
 777
 778     case AHIDB_Annotation:
 779       return (SIPTR)
 780         "VIA VT82C686 AC97 driver";
 781
 782     case AHIDB_Record:
 783       return TRUE;
 784
 785     case AHIDB_FullDuplex:
 786       return TRUE;
 787
 788     case AHIDB_Realtime:
 789       return TRUE;
 790
 791     case AHIDB_MaxRecordSamples:
 792       return RECORD_BUFFER_SAMPLES;
 793
 794     /* formula's:
 795     #include <math.h>
 796
 797     unsigned long res = (unsigned long) (0x10000 * pow (10.0, dB / 20.0));
 798     double dB = 20.0 * log10(0xVALUE / 65536.0);
 799
 800     printf("dB = %f, res = %lx\n", dB, res);*/
 801
 802     case AHIDB_MinMonitorVolume:
 803       return 0x00000;
 804
 805     case AHIDB_MaxMonitorVolume:
 806       return 0x40000;
 807
 808     case AHIDB_MinInputGain:
 809       return 0x10000; // 0.0 dB gain
 810
 811     case AHIDB_MaxInputGain:
 812       return 0xD55D0; // 22.5 dB gain
 813
 814     case AHIDB_MinOutputVolume:
 815       return 0x00000; // -96 dB
 816
 817     case AHIDB_MaxOutputVolume:
 818       return 0x10000; // 0 dB
 819
 820     case AHIDB_Inputs:
 821       return INPUTS;
 822
 823     case AHIDB_Input:
 824       return (SIPTR) Inputs[ argument ];
 825
 826     case AHIDB_Outputs:
 827       return OUTPUTS;
 828
 829     case AHIDB_Output:
 830       return (SIPTR) Outputs[ argument ];
 831
 832     default:
 833       return def;
 834   }
 835 }
 836
 837
 838 /******************************************************************************
 839 ** AHIsub_HardwareControl *****************************************************
 840 ******************************************************************************/
 841
 842 ULONG
 843 _AHIsub_HardwareControl( ULONG                   attribute,
 844                          LONG                    argument,
 845                          struct AHIAudioCtrlDrv* AudioCtrl,
 846                          struct DriverBase*      AHIsubBase )
 847 {
 848   struct CardData* card = (struct CardData*) AudioCtrl->ahiac_DriverData;
 849
 850   switch( attribute )
 851   {
 852     case AHIC_MonitorVolume:
 853       card->monitor_volume = Linear2MixerGain( (Fixed) argument, &card->monitor_volume_bits );
 854       if( card->is_recording )
 855       {
 856          UpdateMonitorMixer( card );
 857       }
 858       return TRUE;
 859
 860     case AHIC_MonitorVolume_Query:
 861       return card->monitor_volume;
 862
 863     case AHIC_InputGain:
 864       card->input_gain = Linear2RecordGain( (Fixed) argument, &card->input_gain_bits );
 865       codec_write(card, AC97_RECORD_GAIN, card->input_gain_bits );
 866       return TRUE;
 867
 868     case AHIC_InputGain_Query:
 869       return card->input_gain;
 870
 871     case AHIC_OutputVolume:
 872       card->output_volume = Linear2MixerGain( (Fixed) argument, &card->output_volume_bits );
 873       codec_write(card, AC97_PCMOUT_VOL, card->output_volume_bits );
 874       return TRUE;
 875
 876     case AHIC_OutputVolume_Query:
 877       return card->output_volume;
 878
 879     case AHIC_Input:
 880       card->input = argument;
 881       codec_write(card, AC97_RECORD_SELECT, InputBits[ card->input ] );
 882
 883       if( card->is_recording )
 884       {
 885          UpdateMonitorMixer( card );
 886       }
 887
 888       return TRUE;
 889
 890     case AHIC_Input_Query:
 891       return card->input;
 892
 893     case AHIC_Output:
 894       card->output = argument;
 895
 896       return TRUE;
 897
 898     case AHIC_Output_Query:
 899       return card->output;
 900
 901     default:
 902       return FALSE;
 903   }
 904 }