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

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