workbench/devs/AHI/Drivers/HDAudio/hdaudio.c

   1 #include <config.h>
   2
   3 #include <devices/ahi.h>
   4 #include <exec/memory.h>
   5 #include <libraries/ahi_sub.h>
   6 #include <math.h>
   7
   8 #include <proto/ahi_sub.h>
   9 #include <proto/exec.h>
  10 #include <proto/dos.h>
  11 #include <proto/utility.h>
  12 #ifdef __AROS__
  13 #include <aros/debug.h>
  14 #define DebugPrintF bug
  15 #endif
  16 #include <string.h>
  17
  18 #include "library.h"
  19 #include "regs.h"
  20 #include "misc.h"
  21 #include "pci_wrapper.h"
  22
  23
  24
  25 extern int z, timer;
  26
  27
  28 /******************************************************************************
  29 ** Globals ********************************************************************
  30 ******************************************************************************/
  31
  32 static BOOL build_buffer_descriptor_list(struct HDAudioChip *card, ULONG nr_of_buffers, ULONG buffer_size, struct Stream *stream);
  33 static void free_buffer_descriptor_list(struct HDAudioChip *card, ULONG nr_of_buffers, struct Stream *stream);
  34 static BOOL stream_reset(struct Stream *stream, struct HDAudioChip *card);
  35 void set_converter_format(struct HDAudioChip *card, UBYTE nid);
  36
  37
  38 static const char *Inputs[INPUTS] =
  39 {
  40   "Line in",
  41   "Mic 1",
  42   "Mic 2",
  43   "CD",
  44   "Mixer"
  45 };
  46
  47
  48 #define OUTPUTS 1
  49
  50
  51 static const char *Outputs[OUTPUTS] =
  52 {
  53   "Line",
  54 };
  55
  56
  57
  58 #define uint32 unsigned int
  59
  60
  61 /******************************************************************************
  62 ** AHIsub_AllocAudio **********************************************************
  63 ******************************************************************************/
  64
  65 ULONG _AHIsub_AllocAudio(struct TagItem* taglist,
  66                          struct AHIAudioCtrlDrv* AudioCtrl,
  67                          struct DriverBase* AHIsubBase)
  68 {
  69     struct HDAudioBase* card_base = (struct HDAudioBase*) AHIsubBase;
  70
  71     int   card_num;
  72     ULONG ret;
  73     ULONG i;
  74
  75     card_num = (GetTagData(AHIDB_AudioID, 0, taglist) & 0x0000f000) >> 12;
  76
  77     if (card_num >= card_base->cards_found ||
  78         card_base->driverdatas[card_num] == NULL)
  79     {
  80         DebugPrintF("no data for card = %ld\n", card_num);
  81         Req("No HDAudioChip for card %ld.", card_num);
  82         return AHISF_ERROR;
  83     }
  84     else
  85     {
  86         BOOL in_use;
  87         struct PCIDevice *dev;
  88         struct HDAudioChip *card;
  89         unsigned short uval;
  90
  91         card  = card_base->driverdatas[card_num];
  92         AudioCtrl->ahiac_DriverData = card;
  93
  94         ObtainSemaphore(&card_base->semaphore);
  95         in_use = (card->audioctrl != NULL);
  96         if (!in_use)
  97         {
  98             card->audioctrl = AudioCtrl;
  99         }
 100         ReleaseSemaphore(&card_base->semaphore);
 101
 102         if (in_use)
 103         {
 104             return AHISF_ERROR;
 105         }
 106
 107         dev = card->pci_dev;
 108
 109         //bug("AudioCtrl->ahiac_MixFreq = %lu\n", AudioCtrl->ahiac_MixFreq);
 110         if (AudioCtrl->ahiac_MixFreq < card->frequencies[0].frequency)
 111             AudioCtrl->ahiac_MixFreq = card->frequencies[0].frequency;
 112
 113         card->selected_freq_index = 0;
 114         for (i = 1; i < card->nr_of_frequencies; i++)
 115         {
 116             if ((ULONG) card->frequencies[i].frequency >= AudioCtrl->ahiac_MixFreq)
 117             {
 118                 if ((AudioCtrl->ahiac_MixFreq - (LONG) card->frequencies[i - 1].frequency)
 119                     < ((LONG) card->frequencies[i].frequency - AudioCtrl->ahiac_MixFreq))
 120                 {
 121                     card->selected_freq_index = i - 1;
 122                     break;
 123                 }
 124                 else
 125                 {
 126                     card->selected_freq_index = i;
 127                     break;
 128                 }
 129             }
 130         }
 131
 132         //bug("card->selected_freq_index = %lu\n", card->selected_freq_index);
 133
 134         ret = AHISF_KNOWHIFI | AHISF_KNOWSTEREO | AHISF_MIXING | AHISF_TIMING;
 135
 136         for (i = 0; i < card->nr_of_frequencies; i++)
 137         {
 138             if (AudioCtrl->ahiac_MixFreq == card->frequencies[i].frequency)
 139             {
 140                 ret |= AHISF_CANRECORD;
 141                 break;
 142             }
 143         }
 144
 145         return ret;
 146     }
 147 }
 148
 149
 150
 151 /******************************************************************************
 152 ** AHIsub_FreeAudio ***********************************************************
 153 ******************************************************************************/
 154
 155 void _AHIsub_FreeAudio(struct AHIAudioCtrlDrv* AudioCtrl,
 156                        struct DriverBase* AHIsubBase)
 157 {
 158     struct HDAudioBase* card_base = (struct HDAudioBase*) AHIsubBase;
 159     struct HDAudioChip* card = (struct HDAudioChip*) AudioCtrl->ahiac_DriverData;
 160
 161     if (card != NULL)
 162     {
 163         ObtainSemaphore(&card_base->semaphore);
 164         if (card->audioctrl == AudioCtrl)
 165         {
 166             // Release it if we own it.
 167             card->audioctrl = NULL;
 168         }
 169
 170         ReleaseSemaphore(&card_base->semaphore);
 171
 172         AudioCtrl->ahiac_DriverData = NULL;
 173     }
 174 }
 175
 176
 177 /******************************************************************************
 178 ** AHIsub_Disable *************************************************************
 179 ******************************************************************************/
 180
 181 void _AHIsub_Disable(struct AHIAudioCtrlDrv* AudioCtrl,
 182                      struct DriverBase* AHIsubBase)
 183 {
 184     struct HDAudioBase* card_base = (struct HDAudioBase*) AHIsubBase;
 185
 186     // V6 drivers do not have to preserve all registers
 187
 188     Disable();
 189 }
 190
 191
 192 /******************************************************************************
 193 ** AHIsub_Enable **************************************************************
 194 ******************************************************************************/
 195
 196 void _AHIsub_Enable(struct AHIAudioCtrlDrv* AudioCtrl,
 197                     struct DriverBase* AHIsubBase)
 198 {
 199     struct HDAudioBase* card_base = (struct HDAudioBase*) AHIsubBase;
 200
 201     // V6 drivers do not have to preserve all registers
 202
 203     Enable();
 204 }
 205
 206
 207 /******************************************************************************
 208 ** AHIsub_Start ***************************************************************
 209 ******************************************************************************/
 210
 211 ULONG _AHIsub_Start(ULONG flags,
 212                     struct AHIAudioCtrlDrv* AudioCtrl,
 213                     struct DriverBase* AHIsubBase)
 214 {
 215     struct HDAudioBase* card_base = (struct HDAudioBase*) AHIsubBase;
 216     struct HDAudioChip* card = (struct HDAudioChip*) AudioCtrl->ahiac_DriverData;
 217     struct PCIDevice *dev = card->pci_dev;
 218     UWORD PlayCtrlFlags = 0, RecCtrlFlags = 0;
 219     ULONG dma_buffer_size = 0;
 220     int i;
 221     unsigned short uval;
 222     UBYTE input_streams = 0;
 223     struct Stream *input_stream = &(card->streams[0]);
 224     struct Stream *output_stream = &(card->streams[card->nr_of_input_streams]);
 225     UBYTE old_rirb_wp;
 226
 227     if (flags & AHISF_PLAY)
 228     {
 229         ULONG dma_sample_frame_size;
 230         int i;
 231         unsigned short cod, ChannelsFlag = 0;
 232
 233         detect_headphone_change(card);
 234
 235         card->mix_buffer = (APTR) AllocVec(AudioCtrl->ahiac_BuffSize, MEMF_PUBLIC | MEMF_CLEAR);
 236
 237         if (card->mix_buffer == NULL)
 238         {
 239             bug("Unable to allocate %ld bytes for mixing buffer.", AudioCtrl->ahiac_BuffSize);
 240             return AHIE_NOMEM;
 241         }
 242
 243         /* Allocate a buffer large enough for 32-bit double-buffered playback (mono or stereo) */
 244         if (AudioCtrl->ahiac_Flags & AHIACF_STEREO)
 245         {
 246             dma_sample_frame_size = 4 * 2;
 247             dma_buffer_size = AudioCtrl->ahiac_MaxBuffSamples * dma_sample_frame_size;
 248         }
 249         else
 250         {
 251             dma_sample_frame_size = 4;
 252             dma_buffer_size = AudioCtrl->ahiac_MaxBuffSamples * dma_sample_frame_size;
 253         }
 254
 255         //bug("dma_buffer_size = %ld, %lx, freq = %d\n", dma_buffer_size, dma_buffer_size, AudioCtrl->ahiac_MixFreq);
 256         build_buffer_descriptor_list(card, 2, dma_buffer_size, output_stream);
 257
 258         card->playback_buffer1 = (APTR) output_stream->bdl[0].lower_address;
 259         card->playback_buffer2 = (APTR) output_stream->bdl[1].lower_address;
 260
 261         //bug("BDLE[0] = %lx, BDLE[1] = %lx\n", output_stream->bdl[0].lower_address, output_stream->bdl[1].lower_address);
 262         if (stream_reset(output_stream, card) == FALSE)
 263         {
 264             return AHISF_ERROR;
 265         }
 266
 267         // 4.5.3 Starting Streams
 268         outb_setbits((output_stream->tag << 4), output_stream->sd_reg_offset + HD_SD_OFFSET_CONTROL + 2, card); // set stream number
 269         pci_outl(dma_buffer_size * 2, output_stream->sd_reg_offset + HD_SD_OFFSET_CYCLIC_BUFFER_LEN, card);
 270         pci_outw(1, output_stream->sd_reg_offset + HD_SD_OFFSET_LAST_VALID_INDEX, card); // 2 buffers, last valid index = 1
 271
 272         // set sample rate and format
 273         pci_outw(((card->frequencies[card->selected_freq_index].base44100 > 0) ? BASE44 : 0) | // base freq: 48 or 44.1 kHz
 274             (card->frequencies[card->selected_freq_index].mult << 11) | // multiplier
 275             (card->frequencies[card->selected_freq_index].div << 8) | // divisor
 276             FORMAT_24BITS | // set to 24-bit for now
 277             FORMAT_STEREO,
 278             output_stream->sd_reg_offset + HD_SD_OFFSET_FORMAT, card);
 279
 280         send_command_4(card->codecnr, card->dac_nid, VERB_SET_CONVERTER_FORMAT,
 281             ((card->frequencies[card->selected_freq_index].base44100 > 0) ? BASE44 : 0) | // base freq: 48 or 44.1 kHz
 282             (card->frequencies[card->selected_freq_index].mult << 11) | // multiplier
 283             (card->frequencies[card->selected_freq_index].div << 8) | // divisor
 284             FORMAT_24BITS | // set to 24-bit for now
 285             FORMAT_STEREO , card); // stereo
 286
 287         send_command_4(card->codecnr, card->dac_nid, 0xA, 0, card);
 288
 289
 290         // set BDL for scatter/gather
 291         pci_outl((ULONG) output_stream->bdl, output_stream->sd_reg_offset + HD_SD_OFFSET_BDL_ADDR_LOW, card);
 292         pci_outl(0, output_stream->sd_reg_offset + HD_SD_OFFSET_BDL_ADDR_HIGH, card);
 293
 294         // set stream ID and channel for DAC
 295         send_command_12(card->codecnr, card->dac_nid, VERB_SET_CONVERTER_STREAM_CHANNEL, (output_stream->tag << 4), card); // stream 1, channel 0
 296
 297         card->current_bytesize = dma_buffer_size;
 298         card->current_frames = AudioCtrl->ahiac_MaxBuffSamples;
 299         card->current_buffer   = card->playback_buffer1;
 300         card->flip = 1;
 301         card->is_playing = TRUE;
 302     }
 303
 304     if (flags & AHISF_RECORD)
 305     {
 306         dma_buffer_size = RECORD_BUFFER_SAMPLES * 4;
 307
 308         build_buffer_descriptor_list(card, 2, dma_buffer_size, input_stream);
 309
 310         card->record_buffer1 = (APTR) input_stream->bdl[0].lower_address;
 311         card->record_buffer2 = (APTR) input_stream->bdl[1].lower_address;
 312
 313         if (stream_reset(input_stream, card) == FALSE)
 314         {
 315             return AHISF_ERROR;
 316         }
 317
 318         // 4.5.3 Starting Streams
 319         outb_setbits((input_stream->tag << 4), input_stream->sd_reg_offset + HD_SD_OFFSET_CONTROL + 2, card); // set stream number
 320         pci_outl(dma_buffer_size * 2, input_stream->sd_reg_offset + HD_SD_OFFSET_CYCLIC_BUFFER_LEN, card);
 321         pci_outw(1, input_stream->sd_reg_offset + HD_SD_OFFSET_LAST_VALID_INDEX, card); // 2 buffers, last valid index = 1
 322
 323         // set sample rate and format
 324         pci_outw(((card->frequencies[card->selected_freq_index].base44100 > 0) ? BASE44 : 0) | // base freq: 48 or 44.1 kHz
 325             (card->frequencies[card->selected_freq_index].mult << 11) | // multiplier
 326             (card->frequencies[card->selected_freq_index].div << 8) | // divisor
 327             FORMAT_16BITS | // set to 16-bit for now
 328             FORMAT_STEREO,
 329         input_stream->sd_reg_offset + HD_SD_OFFSET_FORMAT, card);
 330
 331         send_command_4(card->codecnr, card->adc_nid, VERB_SET_CONVERTER_FORMAT,
 332             ((card->frequencies[card->selected_freq_index].base44100 > 0) ? BASE44 : 0) | // base freq: 48 or 44.1 kHz
 333             (card->frequencies[card->selected_freq_index].mult << 11) | // multiplier
 334             (card->frequencies[card->selected_freq_index].div << 8) | // divisor
 335             FORMAT_16BITS | // set to 16-bit for now
 336             FORMAT_STEREO , card); // stereo
 337
 338         // set BDL for scatter/gather
 339         pci_outl((ULONG) input_stream->bdl, input_stream->sd_reg_offset + HD_SD_OFFSET_BDL_ADDR_LOW, card);
 340         pci_outl(0, input_stream->sd_reg_offset + HD_SD_OFFSET_BDL_ADDR_HIGH, card);
 341
 342         // set stream ID and channel for ADC
 343         send_command_12(card->codecnr, card->adc_nid, VERB_SET_CONVERTER_STREAM_CHANNEL, (input_stream->tag << 4), card);
 344
 345         bug("RECORD\n");
 346         codec_discovery(card); // tbd < --------------------
 347
 348         card->current_record_bytesize = dma_buffer_size;
 349         card->current_record_buffer = card->record_buffer1;
 350         card->recflip = 1;
 351         card->is_recording = TRUE;
 352     }
 353
 354     if (flags & AHISF_PLAY)
 355     {
 356         // enable irq's
 357         z = 0;
 358         timer = 0; // for demo/test
 359
 360         //bug("GOING TO PLAY\n");
 361         outl_setbits((1 << output_stream->index), HD_INTCTL, card);
 362         outl_setbits(HD_SD_CONTROL_STREAM_RUN | HD_SD_STATUS_MASK, output_stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card); // Stream Run
 363     }
 364
 365
 366     if (flags & AHISF_RECORD)
 367     {
 368         // enable irq's
 369         outl_setbits((1 << input_stream->index), HD_INTCTL, card);
 370         outl_setbits(HD_SD_CONTROL_STREAM_RUN | HD_SD_STATUS_MASK, input_stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card); // Stream Run
 371
 372     }
 373
 374     return AHIE_OK;
 375 }
 376
 377
 378 /******************************************************************************
 379 ** AHIsub_Update **************************************************************
 380 ******************************************************************************/
 381
 382 void _AHIsub_Update(ULONG flags,
 383                     struct AHIAudioCtrlDrv* AudioCtrl,
 384                     struct DriverBase* AHIsubBase)
 385 {
 386     struct HDAudioBase* card_base = (struct HDAudioBase*) AHIsubBase;
 387     struct HDAudioChip* card = (struct HDAudioChip*) AudioCtrl->ahiac_DriverData;
 388
 389     card->current_frames = AudioCtrl->ahiac_BuffSamples;
 390
 391     if (AudioCtrl->ahiac_Flags & AHIACF_STEREO)
 392     {
 393         card->current_bytesize = card->current_frames * 4;
 394     }
 395     else
 396     {
 397         card->current_bytesize = card->current_frames * 2;
 398     }
 399 }
 400
 401
 402 /******************************************************************************
 403 ** AHIsub_Stop ****************************************************************
 404 ******************************************************************************/
 405
 406 void _AHIsub_Stop(ULONG flags,
 407                   struct AHIAudioCtrlDrv* AudioCtrl,
 408                   struct DriverBase* AHIsubBase)
 409 {
 410     struct HDAudioBase* card_base = (struct HDAudioBase*) AHIsubBase;
 411     struct HDAudioChip* card = (struct HDAudioChip*) AudioCtrl->ahiac_DriverData;
 412     struct PCIDevice *dev = card->pci_dev;
 413
 414     unsigned char val;
 415
 416     //bug("Stop\n");
 417
 418     if ((flags & AHISF_PLAY) && card->is_playing)
 419     {
 420         struct Stream *output_stream = &(card->streams[card->nr_of_input_streams]);
 421         outl_clearbits(HD_SD_CONTROL_STREAM_RUN, output_stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card);
 422         card->is_playing = FALSE;
 423
 424         card->current_bytesize = 0;
 425         card->current_frames = 0;
 426         card->current_buffer = NULL;
 427
 428         if (card->mix_buffer)
 429         {
 430             FreeVec(card->mix_buffer);
 431         }
 432         card->mix_buffer = NULL;
 433
 434         free_buffer_descriptor_list(card, 2, output_stream);
 435
 436 //#ifdef TIME_LIMITED
 437         bug("HDAUDIO: IRQ's received was %d\n", z);
 438 //#endif
 439     }
 440
 441     if ((flags & AHISF_RECORD) && card->is_recording)
 442     {
 443         struct Stream *input_stream = &(card->streams[0]);
 444         outl_clearbits(HD_SD_CONTROL_STREAM_RUN, input_stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card);
 445
 446         card->record_buffer1 = NULL;
 447         card->record_buffer2 = NULL;
 448         card->current_record_bytesize = 0;
 449
 450         card->is_recording = FALSE;
 451
 452         free_buffer_descriptor_list(card, 2, input_stream);
 453     }
 454
 455     card->current_bytesize = 0;
 456 }
 457
 458
 459 /******************************************************************************
 460 ** AHIsub_GetAttr *************************************************************
 461 ******************************************************************************/
 462
 463 LONG _AHIsub_GetAttr(ULONG attribute,
 464                              LONG argument,
 465                              LONG def,
 466                              struct TagItem* taglist,
 467                              struct AHIAudioCtrlDrv* AudioCtrl,
 468                              struct DriverBase* AHIsubBase)
 469 {
 470     struct HDAudioBase* card_base = (struct HDAudioBase*) AHIsubBase;
 471     struct HDAudioChip* card = card_base->driverdatas[0];
 472     ULONG i;
 473
 474     switch(attribute)
 475     {
 476         case AHIDB_Bits:
 477           return 16;
 478
 479         case AHIDB_Frequencies:
 480         {
 481           return card->nr_of_frequencies;
 482         }
 483
 484         case AHIDB_Frequency: // Index->Frequency
 485           return (LONG) card->frequencies[argument].frequency;
 486
 487         case AHIDB_Index: // Frequency->Index
 488         {
 489           if (argument <= (LONG) card->frequencies[0].frequency)
 490           {
 491             return 0;
 492           }
 493
 494           if (argument >= (LONG) card->frequencies[card->nr_of_frequencies - 1].frequency)
 495           {
 496             return card->nr_of_frequencies - 1;
 497           }
 498
 499           for (i = 1; i < card->nr_of_frequencies; i++)
 500           {
 501             if ((LONG) card->frequencies[i].frequency > argument)
 502             {
 503               if ((argument - (LONG) card->frequencies[i - 1].frequency) < ((LONG) card->frequencies[i].frequency - argument))
 504               {
 505                 return i-1;
 506               }
 507               else
 508               {
 509                 return i;
 510               }
 511             }
 512           }
 513
 514           return 0;  // Will not happen
 515         }
 516
 517         case AHIDB_Author:
 518           return (LONG) "Davy Wentzler";
 519
 520         case AHIDB_Copyright:
 521           return (LONG) "(C) 2011 The AROS Dev Team";
 522
 523         case AHIDB_Version:
 524           return (LONG) LibIDString;
 525
 526         case AHIDB_Annotation:
 527           return (LONG)
 528         "AROS HD Audio driver";
 529
 530         case AHIDB_Record:
 531           return TRUE;
 532
 533         case AHIDB_FullDuplex:
 534           return TRUE;
 535
 536         case AHIDB_Realtime:
 537           return TRUE;
 538
 539         case AHIDB_MaxRecordSamples:
 540           return RECORD_BUFFER_SAMPLES;
 541
 542         /* formula's:
 543         #include <math.h>
 544
 545         unsigned long res = (unsigned long) (0x10000 * pow (10.0, dB / 20.0));
 546         double dB = 20.0 * log10(0xVALUE / 65536.0);
 547
 548         printf("dB = %f, res = %lx\n", dB, res);*/
 549
 550         case AHIDB_MinMonitorVolume:
 551           return (unsigned long) (0x10000 * pow (10.0, -34.5 / 20.0)); // -34.5 dB
 552
 553         case AHIDB_MaxMonitorVolume:
 554           return (unsigned long) (0x10000 * pow (10.0, 12.0 / 20.0)); // 12 dB
 555
 556         case AHIDB_MinInputGain:
 557           return (unsigned long) (0x10000 * pow (10.0, card->adc_min_gain / 20.0));
 558
 559         case AHIDB_MaxInputGain:
 560           return (unsigned long) (0x10000 * pow (10.0, card->adc_max_gain / 20.0));
 561
 562         case AHIDB_MinOutputVolume:
 563           return  (unsigned long) (0x10000 * pow (10.0, card->dac_min_gain / 20.0));
 564
 565         case AHIDB_MaxOutputVolume:
 566           return  (unsigned long) (0x10000 * pow (10.0, card->dac_max_gain / 20.0));
 567
 568         case AHIDB_Inputs:
 569           return INPUTS;
 570
 571         case AHIDB_Input:
 572           return (LONG) Inputs[argument];
 573
 574         case AHIDB_Outputs:
 575           return OUTPUTS;
 576
 577         case AHIDB_Output:
 578           return (LONG) Outputs[argument];
 579
 580         default:
 581           return def;
 582     }
 583 }
 584
 585
 586 /******************************************************************************
 587 ** AHIsub_HardwareControl *****************************************************
 588 ******************************************************************************/
 589
 590 ULONG _AHIsub_HardwareControl(ULONG attribute,
 591                               LONG argument,
 592                               struct AHIAudioCtrlDrv* AudioCtrl,
 593                               struct DriverBase* AHIsubBase)
 594 {
 595     struct HDAudioBase* card_base = (struct HDAudioBase*) AHIsubBase;
 596     struct HDAudioChip* card = card_base->driverdatas[0];
 597
 598     switch(attribute)
 599     {
 600         case AHIC_MonitorVolume:
 601         {
 602             double dB = 20.0 * log10(argument / 65536.0);
 603
 604             card->monitor_volume = argument;
 605             set_monitor_volumes(card, dB);
 606
 607             return TRUE;
 608         }
 609
 610         case AHIC_MonitorVolume_Query:
 611         {
 612             return card->monitor_volume;
 613         }
 614
 615         case AHIC_InputGain:
 616         {
 617             double dB = 20.0 * log10(argument / 65536.0);
 618             card->input_gain = argument;
 619
 620             set_adc_gain(card, dB);
 621             return TRUE;
 622         }
 623
 624         case AHIC_InputGain_Query:
 625             return card->input_gain;
 626
 627         case AHIC_OutputVolume:
 628         {
 629             double dB = 20.0 * log10(argument / 65536.0);
 630             card->output_volume = argument;
 631
 632             set_dac_gain(card, dB);
 633
 634             return TRUE;
 635         }
 636
 637         case AHIC_OutputVolume_Query:
 638             return card->output_volume;
 639
 640         case AHIC_Input:
 641             card->input = argument;
 642             set_adc_input(card);
 643
 644           return TRUE;
 645
 646         case AHIC_Input_Query:
 647             return card->input;
 648
 649         case AHIC_Output:
 650             card->output = argument;
 651
 652             return TRUE;
 653
 654         case AHIC_Output_Query:
 655             return card->output;
 656
 657         default:
 658             return FALSE;
 659     }
 660 }
 661
 662
 663 static BOOL build_buffer_descriptor_list(struct HDAudioChip *card, ULONG nr_of_buffers, ULONG buffer_size, struct Stream *stream)
 664 {
 665     unsigned int entry;
 666
 667     stream->bdl = pci_alloc_consistent(nr_of_buffers * sizeof(struct BDLE), &(stream->bdl_nonaligned), 128);
 668     stream->bdl_nonaligned_addresses = (APTR) AllocVec(nr_of_buffers * 8, MEMF_PUBLIC | MEMF_CLEAR);
 669
 670     for (entry = 0; entry < nr_of_buffers; entry++)
 671     {
 672         APTR non_aligned_address = 0;
 673
 674         stream->bdl[entry].lower_address = (ULONG) pci_alloc_consistent(buffer_size, &non_aligned_address, 128);
 675         stream->bdl[entry].upper_address = 0;
 676         stream->bdl[entry].length = buffer_size;
 677         stream->bdl[entry].reserved_ioc = 1;
 678
 679         stream->bdl_nonaligned_addresses[entry] = non_aligned_address;
 680
 681         //bug("BDL %d = %lx\n", entry, stream->bdl[entry].lower_address);
 682     }
 683
 684     return TRUE;
 685 }
 686
 687
 688 static void free_buffer_descriptor_list(struct HDAudioChip *card, ULONG nr_of_buffers, struct Stream *stream)
 689 {
 690     unsigned int entry;
 691
 692     stream->bdl = pci_alloc_consistent(nr_of_buffers * sizeof(struct BDLE), &(stream->bdl_nonaligned), 128);
 693     stream->bdl_nonaligned_addresses = (APTR) AllocVec(nr_of_buffers * 8, MEMF_PUBLIC | MEMF_CLEAR);
 694
 695     for (entry = 0; entry < nr_of_buffers; entry++)
 696     {
 697         pci_free_consistent(stream->bdl_nonaligned_addresses[entry]);
 698         stream->bdl[entry].lower_address = 0;
 699         stream->bdl_nonaligned_addresses[entry] = NULL;
 700     }
 701
 702     pci_free_consistent(stream->bdl_nonaligned);
 703     stream->bdl_nonaligned = NULL;
 704
 705     FreeVec(stream->bdl_nonaligned_addresses);
 706     stream->bdl_nonaligned_addresses = NULL;
 707 }
 708
 709
 710 static BOOL stream_reset(struct Stream *stream, struct HDAudioChip *card)
 711 {
 712     int i;
 713     UBYTE control;
 714
 715     outb_clearbits(HD_SD_CONTROL_STREAM_RUN, stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card); // stop stream run
 716
 717     outb_setbits(0x1C, stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card);
 718     outb_setbits(0x1C, stream->sd_reg_offset + HD_SD_OFFSET_STATUS, card);
 719     outb_setbits(0x1, stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card); // stream reset
 720
 721     for (i = 0; i < 1000; i++)
 722     {
 723         if ((pci_inb(stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card) & 0x1) == 0x1)
 724         {
 725             break;
 726         }
 727
 728         udelay(100);
 729     }
 730
 731     if (i == 1000)
 732     {
 733         bug("Stream reset not ok\n");
 734         return FALSE;
 735     }
 736
 737     outb_clearbits(0x1, stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card); // stream reset
 738     udelay(10);
 739     for (i = 0; i < 1000; i++)
 740     {
 741         if ((pci_inb(stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card) & 0x1) == 0x0)
 742         {
 743             break;
 744         }
 745
 746         udelay(100);
 747     }
 748
 749     if (i == 1000)
 750     {
 751        bug("Stream reset 2 not ok\n");
 752        return FALSE;
 753     }
 754
 755     outb_clearbits(HD_SD_CONTROL_STREAM_RUN, stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card); // stop stream run
 756
 757     control = pci_inb(stream->sd_reg_offset + HD_SD_OFFSET_CONTROL, card);
 758     if ((control & 0x1) == 1)
 759     {
 760         return FALSE;
 761     }
 762
 763     return TRUE;
 764 }
 765
 766
 767 void set_converter_format(struct HDAudioChip *card, UBYTE nid)
 768 {
 769     send_command_4(card->codecnr, nid, VERB_SET_CONVERTER_FORMAT, (1 << 14) | (0x3 << 4) | 1, card); // 44.1kHz 24-bits stereo
 770 }
 771