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