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

   1 /*
   2
   3 The contents of this file are subject to the AROS Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
   4 http://www.aros.org/license.html
   5
   6 Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
   7 ANY KIND, either express or implied. See the License for the specific language governing rights and
   8 limitations under the License.
   9
  10 The Original Code is (C) Copyright 2004-2011 Ross Vumbaca.
  11
  12 The Initial Developer of the Original Code is Ross Vumbaca.
  13
  14 All Rights Reserved.
  15
  16 */
  17
  18 #include <exec/memory.h>
  19
  20 #ifdef __AROS__
  21 #define DEBUG 1
  22 #include <aros/debug.h>
  23 #endif
  24
  25 #include <proto/exec.h>
  26 #include <proto/dos.h>
  27
  28 #include "library.h"
  29 #include "regs.h"
  30 #include "interrupt.h"
  31 #include "misc.h"
  32
  33 #include "pci_wrapper.h"
  34
  35 #ifdef __AROS__
  36 #define DebugPrintF bug
  37 INTGW(static, void,  playbackinterrupt, PlaybackInterrupt);
  38 INTGW(static, void,  recordinterrupt,   RecordInterrupt);
  39 INTGW(static, ULONG, cardinterrupt,  CardInterrupt);
  40 #endif
  41
  42 /* Global in Card.c */
  43 extern const UWORD InputBits[];
  44
  45 /* Public functions in main.c */
  46 int card_init(struct SB128_DATA *card);
  47 void card_cleanup(struct SB128_DATA *card);
  48
  49 #if !defined(__AROS__)
  50 void AddResetHandler(struct SB128_DATA *card);
  51 #endif
  52
  53 void micro_delay(unsigned int val)
  54 {
  55   struct Device*              TimerBase = NULL;
  56   struct timerequest*         TimerIO = NULL;
  57   struct MsgPort *            replymp;
  58
  59   replymp = (struct MsgPort *) CreateMsgPort();
  60   if (!replymp)
  61   {
  62     DebugPrintF("SB128: Couldn't create reply port\n");
  63     return;
  64   }
  65
  66   TimerIO = (struct TimeRequest *)CreateIORequest(replymp, sizeof(struct timerequest));
  67
  68   if (TimerIO == NULL)
  69   {
  70     DebugPrintF("SB128: Out of memory.\n");
  71     return;
  72   }
  73
  74   if (OpenDevice((CONST_STRPTR) "timer.device", UNIT_MICROHZ, (struct IORequest *)TimerIO, 0) != 0)
  75   {
  76     DebugPrintF("SB128: Unable to open 'timer.device'.\n");
  77     return;
  78   }
  79   else
  80   {
  81     TimerBase = (struct Device *)TimerIO->tr_node.io_Device;
  82   }
  83
  84   TimerIO->tr_node.io_Command = TR_ADDREQUEST;
  85   TimerIO->tr_time.tv_secs = 0;
  86   TimerIO->tr_time.tv_micro = val;
  87   DoIO((struct IORequest *)TimerIO);
  88   CloseDevice((struct IORequest *)TimerIO);
  89   DeleteIORequest((struct IORequest *)TimerIO);
  90   TimerIO = NULL;
  91
  92   if (replymp)
  93   {
  94     DeleteMsgPort(replymp);
  95   }
  96 }
  97
  98 unsigned long src_ready(struct SB128_DATA *card)
  99 {
 100   struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
 101   unsigned int i;
 102   unsigned long r;
 103
 104   /* Wait for the busy bit to become invalid, and then return the contents
 105      of the SRC register. */
 106   for (i = 0; i < 0x1000; i++)
 107   {
 108     if (!((r = pci_inl(SB128_SRC, card)) & SRC_BUSY))
 109         return r;
 110     //micro_delay(1);
 111   }
 112
 113   DebugPrintF("SB128: SRC Ready timeout.\n");
 114   return 0;
 115 }
 116
 117 void src_write(struct SB128_DATA *card, unsigned short addr, unsigned short data)
 118 {
 119   struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
 120   unsigned long r;
 121
 122 //  ObtainSemaphore(&card->sb128_semaphore);
 123
 124   /* Get copy of SRC register when it's not busy, add address and data, write back. */
 125   r = src_ready(card) & (SRC_DISABLE | SRC_DIS_DAC2 | SRC_DIS_ADC);
 126   r = r | (addr << SRC_ADDR_SHIFT);
 127   r = r | data;
 128   pci_outl(r | SRC_WE, SB128_SRC, card);
 129   //micro_delay(1);
 130
 131 //  ReleaseSemaphore(&card->sb128_semaphore);
 132 }
 133
 134 unsigned short src_read(struct SB128_DATA *card, unsigned short addr)
 135 {
 136   struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
 137
 138   //There may be ES137x bugs that require accomodating in this section.
 139
 140   unsigned long r;
 141
 142 //  ObtainSemaphore(&card->sb128_semaphore);
 143
 144   /* Get copy of SRC register when it's not busy, add address, write back,
 145      wait for ready, then read back value. */
 146   r = src_ready(card) & (SRC_DISABLE | SRC_DIS_DAC2 | SRC_DIS_ADC);
 147   r = r | (addr << SRC_ADDR_SHIFT);
 148   pci_outl(r, SB128_SRC, card);
 149
 150   /* Give the chip a chance to set the busy bit. */
 151   //micro_delay(1);
 152
 153 //  ReleaseSemaphore(&card->sb128_semaphore);
 154
 155   return (src_ready(card) & 0xFFFF);
 156 }
 157
 158 /* Translate AC97 commands to AK4531 commands, and write to the AK4531 codec */
 159 void ak4531_ac97_write(struct SB128_DATA *card, unsigned short reg, unsigned short val)
 160 {
 161   char ak4531_L1 = 0;
 162   char ak4531_R1 = 0;
 163   char ak4531_L2 = 0;
 164   char ak4531_R2 = 0;
 165
 166   char input_right = 0;
 167   char input_left  = 0;
 168
 169   short left_vol = 0;
 170   short right_vol = 0;
 171
 172   float steps = 0;
 173
 174   if (reg == AC97_RECORD_SELECT)
 175   {
 176     /* Change input select settings */
 177     input_right = val;
 178     input_left = val >> 8;
 179
 180     /* Translate as appropriate */
 181     switch (input_left) {
 182
 183       case 0:
 184         /* Mic */
 185         ak4531_L2 = 0x80;
 186         break;
 187
 188       case 1:
 189         /* CD */
 190         ak4531_L1 = 0x04;
 191         break;
 192
 193       case 2:
 194         /* Video */
 195         break;
 196
 197       case 3:
 198         /* Aux */
 199         ak4531_L2 = 0x10;
 200         break;
 201
 202       case 4:
 203         /* Line in */
 204         ak4531_L1 = 0x10;
 205         break;
 206
 207       case 5:
 208         /* Stereo Mix (all) */
 209         ak4531_L1 = 0x14;
 210         ak4531_L2 = 0xF4;
 211         break;
 212
 213       case 6:
 214         /* Mono Mix */
 215         break;
 216
 217       case 7:
 218         /* Phone */
 219         ak4531_L2 = 0x60;
 220         break;
 221
 222       default:
 223         /* Shouldn't happen */
 224         DebugPrintF("SB128: Unsupported Record Input command\n");
 225     }
 226
 227     switch (input_right) {
 228
 229       case 0:
 230         /* Mic */
 231         ak4531_R2 = 0x80;
 232         break;
 233
 234       case 1:
 235         /* CD */
 236         ak4531_R1 = 0x02;
 237         break;
 238
 239       case 2:
 240         /* Video */
 241         break;
 242
 243       case 3:
 244         /* Aux */
 245         ak4531_R2 = 0x08;
 246         break;
 247
 248       case 4:
 249         /* Line in */
 250         ak4531_R1 = 0x08;
 251         break;
 252
 253       case 5:
 254         /* Stereo Mix (all) */
 255         ak4531_R1 = 0x0A;
 256         ak4531_R2 = 0xEC;
 257         break;
 258
 259       case 6:
 260         /* Mono Mix */
 261         break;
 262
 263       case 7:
 264         /* Phone */
 265         ak4531_R2 = 0x60;
 266         break;
 267
 268       default:
 269         /* Shouldn't happen */
 270         DebugPrintF("SB128: Unsupported Record Input command\n");
 271     }
 272
 273     /* Write input values to AK4531 */
 274
 275     codec_write(card, AK4531_INPUT_MUX_L_1, ak4531_L1);
 276     codec_write(card, AK4531_INPUT_MUX_R_1, ak4531_R1);
 277     codec_write(card, AK4531_INPUT_MUX_L_2, ak4531_L2);
 278     codec_write(card, AK4531_INPUT_MUX_R_2, ak4531_R2);
 279     return;
 280   }
 281
 282   if (reg == AC97_PHONE_VOL || AC97_MIC_VOL || AC97_LINEIN_VOL || AC97_CD_VOL || AC97_AUX_VOL || AC97_PCMOUT_VOL)
 283   {
 284     /* Adjust PCM (from card) Input gain */
 285     if (val & AC97_MUTE)
 286     {
 287       /* Using a muted volume */
 288       right_vol = (AK4531_MUTE | 0x6);
 289       left_vol  = (AK4531_MUTE | 0x6);
 290     }
 291     else
 292     {
 293       /* Strip bits */
 294       right_vol = (val & 0x1F);
 295       left_vol  = (val >> 8);
 296
 297       /* Convert right volume */
 298       if (right_vol < 0x8)
 299       {
 300         steps = 0x8 - right_vol;
 301         steps = steps * 1.5;
 302         steps = steps / 2;
 303         right_vol = (int) (steps + 0.5);
 304         right_vol = 0x6 - right_vol;
 305       }
 306       else if (right_vol > 0x8)
 307       {
 308         steps = right_vol - 0x8;
 309         steps = steps * 1.5;
 310         steps = steps / 2;
 311         right_vol = (int) (steps + 0.5);
 312         right_vol = 0x6 + right_vol;
 313       }
 314       else if (right_vol == 0x8)
 315       {
 316        /* No attentuation, no mute */
 317         right_vol = 0x6;
 318       }
 319
 320       /* Convert left volume */
 321       if (left_vol < 0x8)
 322       {
 323         steps = 0x8 - left_vol;
 324         steps = steps * 1.5;
 325         steps = steps / 2;
 326         left_vol = (int) (steps + 0.5);
 327         left_vol = 0x6 - left_vol;
 328       }
 329       else if (left_vol > 0x8)
 330       {
 331         steps = left_vol - 0x8;
 332         steps = steps * 1.5;
 333         steps = steps / 2;
 334         left_vol = (int) (steps + 0.5);
 335         left_vol = 0x6 + left_vol;
 336       }
 337       else if (left_vol == 0x8)
 338       {
 339         /* No attentuation, no mute */
 340         left_vol = 0x6;
 341       }
 342
 343     }
 344
 345     /* Write adjusted volume to appropriate place */
 346     /* Un-mute, and disable output, if an input muted */
 347     switch (reg) {
 348
 349       case AC97_PHONE_VOL:
 350         codec_write(card, AK4531_PHONE_VOL_L, right_vol);
 351         codec_write(card, AK4531_PHONE_VOL_R, right_vol);
 352         break;
 353
 354       case AC97_MIC_VOL:
 355         codec_write(card, AK4531_MIC_VOL, right_vol);
 356         break;
 357
 358       case AC97_LINEIN_VOL:
 359         if ((left_vol & AK4531_MUTE) && (right_vol & AK4531_MUTE))
 360         {
 361           left_vol = 0x6;
 362           right_vol = 0x6;
 363           /* Disable on OUTPUT mux */
 364           card->ak4531_output_1 = (card->ak4531_output_1 & ~(AK4531_OUTPUT_LINE));
 365           codec_write(card, AK4531_OUTPUT_MUX_1, card->ak4531_output_1);
 366         }
 367         else
 368         {
 369           codec_write(card, AK4531_LINEIN_VOL_L, left_vol);
 370           codec_write(card, AK4531_LINEIN_VOL_R, right_vol);
 371           /* Re-enable on OUTPUT mux */
 372           card->ak4531_output_1 = (card->ak4531_output_1 | AK4531_OUTPUT_LINE);
 373           codec_write(card, AK4531_OUTPUT_MUX_1, card->ak4531_output_1);
 374         }
 375         break;
 376
 377       case AC97_CD_VOL:
 378          if ((left_vol & AK4531_MUTE) && (right_vol & AK4531_MUTE))
 379         {
 380           left_vol = 0x6;
 381           right_vol = 0x6;
 382           /* Disable on OUTPUT mux */
 383           card->ak4531_output_1 = (card->ak4531_output_1 & ~(AK4531_OUTPUT_CD));
 384           codec_write(card, AK4531_OUTPUT_MUX_1, card->ak4531_output_1);
 385         }
 386         else
 387         {
 388           codec_write(card, AK4531_CD_VOL_L, left_vol);
 389           codec_write(card, AK4531_CD_VOL_R, right_vol);
 390           /* Re-enable on OUTPUT mux */
 391           card->ak4531_output_1 = (card->ak4531_output_1 | AK4531_OUTPUT_CD);
 392           codec_write(card, AK4531_OUTPUT_MUX_1, card->ak4531_output_1);
 393         }
 394         break;
 395
 396       case AC97_AUX_VOL:
 397           if ((left_vol & AK4531_MUTE) && (right_vol & AK4531_MUTE))
 398         {
 399           left_vol = 0x6;
 400           right_vol = 0x6;
 401           /* Disable on OUTPUT mux */
 402           card->ak4531_output_2 = (card->ak4531_output_2 & ~(AK4531_OUTPUT_AUX));
 403           codec_write(card, AK4531_OUTPUT_MUX_2, card->ak4531_output_2);
 404         }
 405         else
 406         {
 407           codec_write(card, AK4531_AUX_VOL_L, left_vol);
 408           codec_write(card, AK4531_AUX_VOL_R, right_vol);
 409           /* Re-enable on OUTPUT mux */
 410           card->ak4531_output_2 = (card->ak4531_output_2 | AK4531_OUTPUT_AUX);
 411           codec_write(card, AK4531_OUTPUT_MUX_2, card->ak4531_output_2);
 412         }
 413         break;
 414
 415       case AC97_PCMOUT_VOL:
 416         codec_write(card, AK4531_PCMOUT_VOL_L, left_vol);
 417         codec_write(card, AK4531_PCMOUT_VOL_R, right_vol);
 418         break;
 419
 420       default:
 421         DebugPrintF("SB128: Invalid value for Volume Set\n");
 422     }
 423
 424     return;
 425
 426   }
 427
 428 }
 429
 430 void codec_write(struct SB128_DATA *card, unsigned short reg, unsigned short val)
 431 {
 432   struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
 433   unsigned long i, r;
 434
 435   /* Take hold of the hardware semaphore */
 436   //ObtainSemaphore(&card->sb128_semaphore);
 437
 438   if(card->es1370)
 439   {
 440     for (i = 0; i < 10; i++)
 441     {
 442       if (!(pci_inl(SB128_STATUS, card) & CODEC_CSTAT ))
 443         goto es1370_ok1;
 444       Delay(1);
 445     }
 446     DebugPrintF("SB128: Couldn't write to ak4531!\n");
 447     return;
 448
 449     es1370_ok1:
 450     pci_outw(((unsigned char)reg << ES1370_CODEC_ADD_SHIFT) | (unsigned char)val, ES1370_SB128_CODEC, card);
 451     micro_delay(100);
 452   }
 453   else
 454   {
 455
 456     /* Check for WIP. */
 457     for (i = 0; i < 0x1000; i++)
 458     {
 459           if (!(pci_inl(SB128_CODEC, card) & CODEC_WIP ))
 460             goto ok1;
 461         }
 462     DebugPrintF("SB128: Couldn't write to ac97! (1)\n");
 463     //ReleaseSemaphore(&card->sb128_semaphore);
 464     return;
 465
 466     ok1:
 467     /* Get copy of SRC register when it's not busy. */
 468     r = src_ready(card);
 469     /* Enable "SRC State Data", an undocumented feature! */
 470     pci_outl((r & (SRC_DISABLE | SRC_DIS_DAC2 | SRC_DIS_ADC)) | 0x00010000, SB128_SRC, card);
 471
 472     /* Wait for "state 0", to avoid "transition states". */
 473     for (i = 0; i < 0x1000; i++)
 474     {
 475       if ((pci_inl(SB128_SRC, card) & 0x00870000) == 0x00)
 476         break;
 477       //micro_delay(1);
 478     }
 479
 480     /* Now wait for an undocumented bit to be set (and the SRC to be NOT busy) */
 481     for (i = 0; i < 0x1000; i++)
 482     {
 483       if ((pci_inl(SB128_SRC, card) & 0x00870000) == 0x00010000)
 484         break;
 485       //micro_delay(1);
 486     }
 487
 488     /* Write out the value to the codec now. */
 489     pci_outl((((reg << CODEC_ADD_SHIFT) & CODEC_ADD_MASK) | val), SB128_CODEC, card);
 490
 491     /* Delay to make sure the chip had time to set the WIP after
 492        the codec write. */
 493     //micro_delay(1);
 494
 495     /* Restore SRC register. */
 496     src_ready(card);
 497     pci_outl(r, SB128_SRC, card);
 498
 499     /* Check for WIP before returning. */
 500     for (i = 0; i < 0x1000; i++)
 501     {
 502             if (!(pci_inl(SB128_CODEC, card) & CODEC_WIP))
 503       {
 504         //ReleaseSemaphore(&card->sb128_semaphore);
 505         return;
 506       }
 507     }
 508
 509     DebugPrintF("SB128: Couldn't write to ac97! (2)\n");
 510   }
 511
 512   //ReleaseSemaphore(&card->sb128_semaphore);
 513   return;
 514 }
 515
 516 unsigned short codec_read(struct SB128_DATA *card, unsigned short reg)
 517 {
 518   struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
 519   unsigned long i, r;
 520   unsigned short val;
 521
 522   if(card->es1370)
 523     return 0;
 524
 525 //ObtainSemaphore(&card->sb128_semaphore);
 526
 527   /* Check for WIP. */
 528   for (i = 0; i < 0x1000; i++) {
 529           if (!((pci_inl(SB128_CODEC, card)) & CODEC_WIP ))
 530                   goto ok1;
 531         }
 532   DebugPrintF("SB128: Couldn't read from ac97! (1)\n");
 533 //  ReleaseSemaphore(&card->sb128_semaphore);
 534   return 0;
 535
 536   ok1:
 537
 538   /* Get copy of SRC register when it's not busy. */
 539   r = src_ready(card);
 540
 541   /* Enable "SRC State Data", an undocumented feature! */
 542   pci_outl((r & (SRC_DISABLE | SRC_DIS_DAC1 | SRC_DIS_DAC2 | SRC_DIS_ADC)) | 0x00010000, SB128_SRC, card);
 543
 544   /* Wait for "state 0", to avoid "transition states".
 545      Seen in open code. */
 546   for (i = 0; i < 0x1000; i++)
 547   {
 548     if ((pci_inl(SB128_SRC, card) & 0x00870000) == 0x00)
 549       break;
 550     //micro_delay(1);
 551   }
 552
 553  /* Now wait for an undocumented bit to be set (and the SRC to be NOT busy) */
 554   for (i = 0; i < 0x1000; i++)
 555   {
 556     if ((pci_inl(SB128_SRC, card) & 0x00870000) == 0x00010000)
 557       break;
 558     //micro_delay(1);
 559   }
 560
 561   /* Write the read request to the chip now */
 562   pci_outl((((reg << CODEC_ADD_SHIFT) & CODEC_ADD_MASK) | CODEC_READ), SB128_CODEC, card);
 563
 564   /* Give the chip time to respond to our read request. */
 565   //micro_delay(1);
 566
 567   /* Restore SRC register. */
 568   src_ready(card);
 569   pci_outl(r, SB128_SRC, card);
 570
 571   /* Check for WIP. */
 572   for (i = 0; i < 0x1000; i++) {
 573     if (!((pci_inl(SB128_CODEC, card)) & CODEC_WIP))
 574       goto ok2;
 575   }
 576   DebugPrintF("SB128: Couldn't read from ac97 (2)!\n");
 577 //  ReleaseSemaphore(&card->sb128_semaphore);
 578   return 0;
 579
 580   ok2:
 581
 582   /* Wait for RDY. */
 583   //micro_delay(1);
 584   for (i = 0; i < 0x1000; i++) {
 585                 if (!((pci_inl(SB128_CODEC, card)) & CODEC_RDY))
 586                   goto ok3;
 587         }
 588   DebugPrintF("SB128: Couldn't read from ac97 (3)!\n");
 589 //  ReleaseSemaphore(&card->sb128_semaphore);
 590   return 0;
 591
 592   ok3:
 593   //micro_delay(5);
 594   Delay(1); //A delay here is crucial, remove this if you use micro_delay()
 595   val = pci_inl(SB128_CODEC, card);
 596
 597 //  ReleaseSemaphore(&card->sb128_semaphore);
 598
 599   return val;
 600 }
 601
 602 void rate_set_adc(struct SB128_DATA *card, unsigned long rate)
 603 {
 604   struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
 605
 606   unsigned long n, truncm, freq;
 607
 608   //ObtainSemaphore(&card->sb128_semaphore);
 609
 610   if (rate > 48000)
 611     rate = 48000;
 612   if (rate < 4000)
 613     rate = 4000;
 614
 615   if (card->es1370)
 616   {
 617     pci_outl(((pci_inl(SB128_CONTROL, card) & ~DAC2_DIV_MASK) | (DAC2_SRTODIV(rate) << DAC2_DIV_SHIFT)), SB128_CONTROL, card);
 618   }
 619   else
 620   {
 621
 622     /* This is completely undocumented */
 623     n = rate / 3000;
 624     if ((1 << n) & ((1 << 15) | (1 << 13) | (1 << 11) | (1 << 9)))
 625       n--;
 626     truncm = (21 * n - 1) | 1;
 627     freq = ((48000UL << 15) / rate) * n;
 628
 629     if (rate >= 24000)
 630     {
 631       if (truncm > 239)
 632         truncm = 239;
 633       src_write(card, SRC_ADC + SRC_TRUNC, (((239 - truncm) >> 1) << 9) | (n << 4));
 634     }
 635     else
 636     {
 637       if (truncm > 119)
 638         truncm = 119;
 639       src_write(card, SRC_ADC + SRC_TRUNC, 0x8000 | (((119 - truncm) >> 1) << 9) | (n << 4));
 640     }
 641     src_write(card, SRC_ADC + SRC_INT,
 642         (src_read(card, SRC_ADC + SRC_INT) & 0x00FF) | ((freq >> 5) & 0xFC00));
 643     src_write(card, SRC_ADC + SRC_VF, freq & 0x7FFF);
 644     src_write(card, SRC_VOL_ADC, n << 8);
 645     src_write(card, SRC_VOL_ADC + 1, n << 8);
 646
 647   }
 648
 649     //ReleaseSemaphore(&card->sb128_semaphore);
 650
 651 }
 652
 653 void rate_set_dac2(struct SB128_DATA *card, unsigned long rate)
 654 {
 655   struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
 656
 657   unsigned long freq, r;
 658
 659   //ObtainSemaphore(&card->sb128_semaphore);
 660
 661   if (rate > 48000)
 662     rate = 48000;
 663   if (rate < 4000)
 664     rate = 4000;
 665
 666   if(card->es1370)
 667   {
 668     pci_outl(((pci_inl(SB128_CONTROL, card) & ~DAC2_DIV_MASK) | (DAC2_SRTODIV(rate) << DAC2_DIV_SHIFT)), SB128_CONTROL, card);
 669   }
 670   else
 671   {
 672
 673     freq = ((rate << 15 ) + 1500) / 3000;
 674
 675     /* Get copy of SRC register when it's not busy, clear, preserve the disable bits, write back. */
 676     r = src_ready(card) & (SRC_DISABLE | SRC_DIS_DAC1 | SRC_DIS_DAC2 | SRC_DIS_ADC);
 677     pci_outl(r, SB128_SRC, card);
 678
 679     /* This is completely undocumented */
 680     src_write(card, SRC_DAC2 + SRC_INT,
 681         (src_read(card, SRC_DAC2 + SRC_INT) & 0x00FF) | ((freq >> 5) & 0xFC00));
 682     src_write(card, SRC_DAC2 + SRC_VF, freq & 0x7FFF);
 683     r = (src_ready(card) & (SRC_DISABLE | SRC_DIS_DAC1 | SRC_DIS_ADC));
 684     pci_outl(r, SB128_SRC, card);
 685
 686   }
 687
 688   //ReleaseSemaphore(&card->sb128_semaphore);
 689
 690 }
 691
 692 /******************************************************************************
 693 ** DriverData allocation ******************************************************
 694 ******************************************************************************/
 695
 696 /* This code used to be in _AHIsub_AllocAudio(), but since we're now
 697    handling CAMD support too, it needs to be done at driver loading
 698    time. */
 699
 700 struct SB128_DATA*
 701 AllocDriverData( struct PCIDevice *    dev,
 702                  struct DriverBase* AHIsubBase )
 703 {
 704   struct SB128Base* SB128Base = (struct SB128Base*) AHIsubBase;
 705   struct SB128_DATA* card;
 706   UWORD command_word;
 707   int i;
 708
 709     bug("[SB128]: %s()\n", __PRETTY_FUNCTION__);
 710
 711   // FIXME: This should be non-cachable, DMA-able memory
 712   card = AllocVec( sizeof( *card ), MEMF_PUBLIC | MEMF_CLEAR );
 713
 714   if( card == NULL )
 715   {
 716     Req( "Unable to allocate driver structure." );
 717     return NULL;
 718   }
 719
 720   card->ahisubbase = AHIsubBase;
 721
 722   card->interrupt.is_Node.ln_Type = IRQTYPE;
 723   card->interrupt.is_Node.ln_Pri  = 0;
 724   card->interrupt.is_Node.ln_Name = (STRPTR) LibName;
 725 #ifdef __AROS__
 726     card->interrupt.is_Code         = (void(*)(void))&cardinterrupt;
 727 #else
 728     card->interrupt.is_Code         = (void(*)(void))CardInterrupt;
 729 #endif
 730   card->interrupt.is_Data         = (APTR) card;
 731
 732   card->playback_interrupt.is_Node.ln_Type = IRQTYPE;
 733   card->playback_interrupt.is_Node.ln_Pri  = 0;
 734   card->playback_interrupt.is_Node.ln_Name = (STRPTR) LibName;
 735 #ifdef __AROS__
 736     card->playback_interrupt.is_Code         = (void(*)(void))&playbackinterrupt;
 737 #else
 738     card->playback_interrupt.is_Code         = (void(*)(void))PlaybackInterrupt;
 739 #endif
 740   card->playback_interrupt.is_Data         = (APTR) card;
 741
 742   card->record_interrupt.is_Node.ln_Type = IRQTYPE;
 743   card->record_interrupt.is_Node.ln_Pri  = 0;
 744   card->record_interrupt.is_Node.ln_Name = (STRPTR) LibName;
 745 #ifdef __AROS__
 746     card->record_interrupt.is_Code         = (void(*)(void))&recordinterrupt;
 747 #else
 748     card->record_interrupt.is_Code         = (void(*)(void))RecordInterrupt;
 749 #endif
 750   card->record_interrupt.is_Data         = (APTR) card;
 751
 752   card->pci_dev = dev;
 753
 754   command_word = inw_config( PCI_COMMAND , dev);
 755   command_word |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
 756   outw_config( PCI_COMMAND, command_word , dev);
 757
 758   card->pci_master_enabled = TRUE;
 759
 760   card->iobase  = ahi_pci_get_base_address(0, dev);
 761   card->length  = ~( ahi_pci_get_base_size(0, dev) & PCI_BASE_ADDRESS_IO_MASK );
 762   card->irq     = ahi_pci_get_irq(dev);
 763   card->chiprev = inb_config(PCI_REVISION_ID, dev);
 764   card->model   = inw_config(PCI_SUBSYSTEM_ID, dev);
 765
 766     bug("[CMI8738]: %s: iobase = 0x%p, len = %d\n", __PRETTY_FUNCTION__, card->iobase, card->length);
 767
 768   /* Initialise hardware access Semaphore */
 769   InitSemaphore(&card->sb128_semaphore);
 770
 771
 772   /* Initialize chip */
 773   if( card_init( card ) < 0 )
 774   {
 775     DebugPrintF("SB128: Unable to initialize Card subsystem.");
 776     return NULL;
 777   }
 778
 779     ahi_pci_add_intserver(&card->interrupt, dev);
 780   card->interrupt_added = TRUE;
 781
 782
 783   card->card_initialized = TRUE;
 784   card->input          = 0;
 785   card->output         = 0;
 786   card->monitor_volume = Linear2MixerGain( 0, &card->monitor_volume_bits );
 787   card->input_gain     = Linear2RecordGain( 0x10000, &card->input_gain_bits );
 788   card->output_volume  = Linear2MixerGain( 0x10000, &card->output_volume_bits );
 789   SaveMixerState(card);
 790
 791 #if !defined(__AROS__)
 792   AddResetHandler(card);
 793 #endif
 794
 795   return card;
 796 }
 797
 798
 799 /******************************************************************************
 800 ** DriverData deallocation ****************************************************
 801 ******************************************************************************/
 802
 803 /* And this code used to be in _AHIsub_FreeAudio(). */
 804
 805 void
 806 FreeDriverData( struct SB128_DATA* card,
 807                 struct DriverBase*  AHIsubBase )
 808 {
 809   if( card != NULL )
 810   {
 811     if( card->pci_dev != NULL )
 812     {
 813       if( card->card_initialized )
 814       {
 815         card_cleanup( card );
 816       }
 817
 818       if( card->pci_master_enabled )
 819       {
 820         UWORD cmd;
 821
 822         cmd = inw_config(PCI_COMMAND, (struct PCIDevice * ) card->pci_dev);
 823         cmd &= ~( PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER );
 824         outw_config(PCI_COMMAND, cmd, (struct PCIDevice * ) card->pci_dev );
 825       }
 826     }
 827
 828     if( card->interrupt_added )
 829     {
 830       ahi_pci_rem_intserver(&card->interrupt, card->pci_dev);
 831     }
 832
 833     FreeVec( card );
 834   }
 835 }
 836
 837
 838 int card_init(struct SB128_DATA *card)
 839 {
 840     struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
 841     unsigned short cod;
 842     unsigned int i;
 843
 844     /* Check if the card is an original ES1370 - different code needed */
 845     if (inw_config(2, dev) == 0x5000)
 846         card->es1370 = TRUE;
 847     else
 848         card->es1370 = FALSE;
 849
 850     /* Different init sequence for the ES1370 */
 851     if (card->es1370)
 852     {
 853       /* Enable CODEC access, set DAC sample rate to 44100 */
 854       pci_outl(CTRL_CDC_EN | (DAC2_SRTODIV(44100) << DAC2_DIV_SHIFT), SB128_CONTROL, card);
 855       pci_outl(0x00, SB128_SCON, card);
 856       DebugPrintF("SB128: Did RATE init\n");
 857
 858       /* CODEC initialisation */
 859       codec_write(card, AK4531_RESET,             0x03); /* Enable CODEC */
 860       codec_write(card, AK4531_CLOCK_SEL,         0x00); /* CODEC ADC and DAC use PLL */
 861       codec_write(card, AK4531_RECORD_SELECT,     0x00); /* CODEC ADC set to use mixer for input */
 862       codec_write(card, AK4531_RECORD_GAIN_MIC,   0x00); /* Mic gain set to 0 dB */
 863
 864       /* Volume initialisation */
 865       codec_write(card, AK4531_MASTER_VOL_L,    0x00); /* No attentuation */
 866       codec_write(card, AK4531_MASTER_VOL_R,    0x00);
 867       codec_write(card, AK4531_MASTER_VOL_MONO, 0x00);
 868
 869       /* Analogue mixer input gain registers */
 870       codec_write(card, AK4531_PHONE_VOL_L,   AK4531_MUTE | 0x06);
 871       codec_write(card, AK4531_PHONE_VOL_R,   AK4531_MUTE | 0x06);
 872       codec_write(card, AK4531_MIC_VOL,       AK4531_MUTE | 0x06);
 873       codec_write(card, AK4531_LINEIN_VOL_L,  AK4531_MUTE | 0x06);
 874       codec_write(card, AK4531_LINEIN_VOL_R,  AK4531_MUTE | 0x06);
 875       codec_write(card, AK4531_CD_VOL_L,      0x06);
 876       codec_write(card, AK4531_CD_VOL_R,      0x06);
 877       codec_write(card, AK4531_AUX_VOL_L,     0x06);
 878       codec_write(card, AK4531_AUX_VOL_R,     0x06);
 879       codec_write(card, AK4531_PCMOUT_VOL_L,  0x06);
 880       codec_write(card, AK4531_PCMOUT_VOL_R,  0x06);
 881
 882       /* Mixer registers */
 883
 884       /* Always on */
 885       codec_write(card, AK4531_OUTPUT_MUX_1,  0x1F);
 886       codec_write(card, AK4531_OUTPUT_MUX_2,  0x3F);
 887
 888       /* Store value of OUTPUT MUX registers */
 889       card->ak4531_output_1 = 0x1F;
 890       card->ak4531_output_2 = 0x3F;
 891
 892       /* Analogous to "Record Select", only TMIC and Phone enabled here */
 893       codec_write(card, AK4531_INPUT_MUX_L_1,  0x00);
 894       codec_write(card, AK4531_INPUT_MUX_R_1,  0x00);
 895       codec_write(card, AK4531_INPUT_MUX_L_2,  0x80);
 896       codec_write(card, AK4531_INPUT_MUX_R_2,  0x80);
 897
 898       DebugPrintF("SB128: Did VOLUME init\n");
 899     }
 900     else
 901     {
 902       /* Basic clear of everything */
 903       pci_outl(0x00, SB128_CONTROL, card);
 904       pci_outl(0x00, SB128_SCON, card);
 905       pci_outl(0x00, SB128_LEGACY, card);
 906
 907       /* Magical CT5880 AC97 enable bit plus 20ms delay
 908       (Gotta love the undocumented stuff) */
 909       pci_outl(0x20000000, SB128_STATUS, card);
 910       Delay(1);
 911
 912       /* Assert the AC97 reset, and wait 20ms */
 913       pci_outl(CODEC_RESET, SB128_CONTROL, card);
 914       Delay(1);
 915       /* De-assert delay, and wait 20ms */
 916       pci_outl(0x00, SB128_CONTROL, card);
 917       Delay(1);
 918
 919       DebugPrintF("SB128: Did AC97 reset.\n");
 920
 921       /* Disable the Sample Rate Converter (SRC) */
 922       src_ready(card);
 923       pci_outl(SRC_DISABLE, SB128_SRC, card);
 924       /* Clear the SRC RAM */
 925       for (i = 0; i < 0x80; i++)
 926         src_write(card, i, 0);
 927
 928       DebugPrintF("SB128: Did SRC wipe.\n");
 929
 930       /* Perform basic configuration of the SRC, not well documented! */
 931       src_write(card, SRC_DAC1 + SRC_TRUNC, 0x100);
 932       src_write(card, SRC_DAC1 + SRC_INT, 0x4000);
 933       src_write(card, SRC_DAC2 + SRC_TRUNC, 0x100);
 934       src_write(card, SRC_DAC2 + SRC_INT, 0x4000);
 935       src_write(card, SRC_VOL_ADC, 0x1000);
 936       src_write(card, SRC_VOL_ADC + 1, 0x1000);
 937       src_write(card, SRC_VOL_DAC1, 0x1000);
 938       src_write(card, SRC_VOL_DAC1 + 1, 0x1000);
 939       src_write(card, SRC_VOL_DAC2, 0x1000);
 940       src_write(card, SRC_VOL_DAC2 + 1, 0x1000);
 941
 942       DebugPrintF("SB128: Did SRC init.\n");
 943
 944       rate_set_adc(card, 44100);
 945       rate_set_dac2(card, 44100);
 946
 947       /* Re-enable the SRC */
 948       src_ready(card);
 949       pci_outl(0, SB128_SRC, card);
 950
 951       card->currentPlayFreq = 9;
 952       card->currentRecFreq = 9;
 953
 954       DebugPrintF("SB128: Did RATE init.\n");
 955
 956       /* Initialise registers of AC97 to default */
 957       codec_write(card, AC97_RESET, 0x00);
 958
 959       /* Initialise volumes of AC97 */
 960       codec_write(card, AC97_MASTER_VOL_STEREO, 0x0000 ); /* no attenuation */
 961       codec_write(card, AC97_AUXOUT_VOL,        0x0000 ); /* volume of the rear output */
 962       codec_write(card, AC97_MASTER_VOL_MONO,   0x0000 );
 963       codec_write(card, AC97_MASTER_TONE,       0x0f0f ); /* bass/treble control (if present) */
 964
 965       codec_write(card, AC97_RECORD_SELECT,     0);
 966       codec_write(card, AC97_RECORD_GAIN,       0x0000 ); /* 0 dB gain */
 967
 968       /* Analogue mixer input gain registers */
 969       codec_write(card, AC97_PHONE_VOL,         AC97_MUTE | 0x0008 );
 970       codec_write(card, AC97_MIC_VOL,           AC97_MUTE | 0x0008 );
 971       codec_write(card, AC97_LINEIN_VOL,        AC97_MUTE | 0x0808 );
 972       codec_write(card, AC97_CD_VOL,            0x0808 );
 973       codec_write(card, AC97_VIDEO_VOL,         AC97_MUTE | 0x0808 );
 974       codec_write(card, AC97_AUX_VOL,           0x0808 );
 975       codec_write(card, AC97_PCMOUT_VOL,        0x0808 );
 976
 977       DebugPrintF("SB128: Did VOLUME init.\n");
 978
 979       cod = codec_read(card, AC97_RESET);
 980       DebugPrintF("SB128: AC97 capabilities = %x\n", cod);
 981
 982       cod = codec_read(card, AC97_VENDOR_ID0);
 983       DebugPrintF("SB128: AC97_VENDOR_ID0 = %x\n", cod);
 984
 985       cod = codec_read(card, AC97_VENDOR_ID1);
 986       DebugPrintF("SB128: AC97_VENDOR_ID1 = %x\n", cod);
 987     }
 988
 989     return 0;
 990 }
 991
 992
 993 void card_cleanup(struct SB128_DATA *card)
 994 {
 995 }
 996
 997
 998
 999 /******************************************************************************
1000 ** Misc. **********************************************************************
1001 ******************************************************************************/
1002
1003 void
1004 SaveMixerState( struct SB128_DATA* card )
1005 {
1006   card->ac97_mic    = codec_read( card, AC97_MIC_VOL );
1007   card->ac97_cd     = codec_read( card, AC97_CD_VOL );
1008   card->ac97_aux    = codec_read( card, AC97_AUX_VOL );
1009   card->ac97_linein = codec_read( card, AC97_LINEIN_VOL );
1010   card->ac97_phone  = codec_read( card, AC97_PHONE_VOL );
1011 }
1012
1013
1014 void
1015 RestoreMixerState( struct SB128_DATA* card )
1016 {
1017   if(card->es1370)
1018   {
1019     /* Not possible to save the state, so restore all volumes to mid levels */
1020     ak4531_ac97_write(card, AC97_MIC_VOL, 0x0808);
1021     ak4531_ac97_write(card, AC97_CD_VOL, 0x0808);
1022     ak4531_ac97_write(card, AC97_AUX_VOL, 0x0808);
1023     ak4531_ac97_write(card, AC97_LINEIN_VOL, 0x0808);
1024     ak4531_ac97_write(card, AC97_PHONE_VOL, 0x0808);
1025   }
1026   else
1027   {
1028     codec_write(card, AC97_MIC_VOL,    card->ac97_mic );
1029     codec_write(card, AC97_CD_VOL,     card->ac97_cd );
1030     codec_write(card, AC97_AUX_VOL,    card->ac97_aux );
1031     codec_write(card, AC97_LINEIN_VOL, card->ac97_linein );
1032     codec_write(card, AC97_PHONE_VOL,  card->ac97_phone );
1033   }
1034 }
1035
1036 void
1037 UpdateMonitorMixer( struct SB128_DATA* card )
1038 {
1039   int   i  = InputBits[ card->input ];
1040   UWORD m  = card->monitor_volume_bits & 0x801f;
1041   UWORD s  = card->monitor_volume_bits;
1042   UWORD mm = AC97_MUTE | 0x0008;
1043   UWORD sm = AC97_MUTE | 0x0808;
1044
1045   if( i == AC97_RECMUX_STEREO_MIX )
1046   {
1047     /* Use the original mixer settings */
1048     RestoreMixerState( card );
1049   }
1050   else
1051   {
1052     if(card->es1370)
1053     {
1054       ak4531_ac97_write(card, AC97_MIC_VOL,
1055                         i == AC97_RECMUX_MIC ? m : mm );
1056
1057       ak4531_ac97_write(card, AC97_CD_VOL,
1058                         i == AC97_RECMUX_CD ? s : sm );
1059
1060       ak4531_ac97_write(card, AC97_AUX_VOL,
1061                         i == AC97_RECMUX_AUX ? s : sm );
1062
1063       ak4531_ac97_write(card, AC97_LINEIN_VOL,
1064                         i == AC97_RECMUX_LINE ? s : sm );
1065
1066       ak4531_ac97_write(card, AC97_PHONE_VOL,
1067                         i == AC97_RECMUX_PHONE ? m : mm );
1068     }
1069     else
1070     {
1071       codec_write(card, AC97_MIC_VOL,
1072                         i == AC97_RECMUX_MIC ? m : mm );
1073
1074       codec_write(card, AC97_CD_VOL,
1075                         i == AC97_RECMUX_CD ? s : sm );
1076
1077       codec_write(card, AC97_AUX_VOL,
1078                         i == AC97_RECMUX_AUX ? s : sm );
1079
1080       codec_write(card, AC97_LINEIN_VOL,
1081                         i == AC97_RECMUX_LINE ? s : sm );
1082
1083       codec_write(card, AC97_PHONE_VOL,
1084                         i == AC97_RECMUX_PHONE ? m : mm );
1085     }
1086   }
1087 }
1088
1089
1090 Fixed
1091 Linear2MixerGain( Fixed  linear,
1092                   UWORD* bits )
1093 {
1094   static const Fixed gain[ 33 ] =
1095   {
1096     260904, /* +12.0 dB */
1097     219523, /* +10.5 dB */
1098     184706, /*  +9.0 dB */
1099     155410, /*  +7.5 dB */
1100     130762, /*  +6.0 dB */
1101     110022, /*  +4.5 dB */
1102     92572,  /*  +3.0 dB */
1103     77890,  /*  +1.5 dB */
1104     65536,  /*  ±0.0 dB */
1105     55142,  /*  -1.5 dB */
1106     46396,  /*  -3.0 dB */
1107     39037,  /*  -4.5 dB */
1108     32846,  /*  -6.0 dB */
1109     27636,  /*  -7.5 dB */
1110     23253,  /*  -9.0 dB */
1111     19565,  /* -10.5 dB */
1112     16462,  /* -12.0 dB */
1113     13851,  /* -13.5 dB */
1114     11654,  /* -15.0 dB */
1115     9806,   /* -16.5 dB */
1116     8250,   /* -18.0 dB */
1117     6942,   /* -19.5 dB */
1118     5841,   /* -21.0 dB */
1119     4915,   /* -22.5 dB */
1120     4135,   /* -24.0 dB */
1121     3479,   /* -25.5 dB */
1122     2927,   /* -27.0 dB */
1123     2463,   /* -28.5 dB */
1124     2072,   /* -30.0 dB */
1125     1744,   /* -31.5 dB */
1126     1467,   /* -33.0 dB */
1127     1234,   /* -34.5 dB */
1128     0       /*   -oo dB */
1129   };
1130
1131   int v = 0;
1132   while( linear < gain[ v ] )
1133   {
1134     ++v;
1135   }
1136
1137   if( v == 32 )
1138   {
1139     *bits = 0x8000; /* Mute */
1140   }
1141   else
1142   {
1143     *bits = ( v << 8 ) | v;
1144   }
1145   return gain[ v ];
1146 }
1147
1148 Fixed
1149 Linear2RecordGain( Fixed  linear,
1150                    UWORD* bits )
1151 {
1152   static const Fixed gain[ 17 ] =
1153   {
1154     873937, /* +22.5 dB */
1155     735326, /* +21.0 dB */
1156     618700, /* +19.5 dB */
1157     520571, /* +18.0 dB */
1158     438006, /* +16.5 dB */
1159     368536, /* +15.0 dB */
1160     310084, /* +13.5 dB */
1161     260904, /* +12.0 dB */
1162     219523, /* +10.5 dB */
1163     184706, /*  +9.0 dB */
1164     155410, /*  +7.5 dB */
1165     130762, /*  +6.0 dB */
1166     110022, /*  +4.5 dB */
1167     92572,  /*  +3.0 dB */
1168     77890,  /*  +1.5 dB */
1169     65536,  /*  ±0.0 dB */
1170     0       /*  -oo dB */
1171   };
1172
1173   int v = 0;
1174
1175   while( linear < gain[ v ] )
1176   {
1177     ++v;
1178   }
1179
1180   if( v == 16 )
1181   {
1182     *bits = 0x8000; /* Mute */
1183   }
1184   else
1185   {
1186     *bits = ( ( 15 - v ) << 8 ) | ( 15 - v );
1187   }
1188
1189   return gain[ v ];
1190 }
1191
1192
1193 ULONG
1194 SamplerateToLinearPitch( ULONG samplingrate )
1195 {
1196   samplingrate = (samplingrate << 8) / 375;
1197   return (samplingrate >> 1) + (samplingrate & 1);
1198 }
1199
1200
1201 void *pci_alloc_consistent(size_t size, APTR *NonAlignedAddress, unsigned int boundary)
1202 {
1203     void* address;
1204     unsigned long a;
1205
1206     bug("[CMI8738]: %s()\n", __PRETTY_FUNCTION__);
1207
1208     address = (void *) AllocVec(size + boundary, MEMF_PUBLIC | MEMF_CLEAR);
1209
1210     if (address != NULL)
1211     {
1212         a = (unsigned long) address;
1213         a = (a + boundary - 1) & ~(boundary - 1);
1214         address = (void *) a;
1215     }
1216
1217     if (NonAlignedAddress)
1218     {
1219         *NonAlignedAddress = address;
1220     }
1221
1222     return address;
1223 }
1224
1225
1226 void pci_free_consistent(void* addr)
1227 {
1228     bug("[CMI8738]: %s()\n", __PRETTY_FUNCTION__);
1229
1230     FreeVec(addr);
1231 }
1232
1233 static ULONG ResetHandler(struct ExceptionContext *ctx, struct ExecBase *pExecBase, struct SB128_DATA *card)
1234 {
1235   struct PCIDevice *dev = card->pci_dev;
1236
1237   //Stop SB128 interrupts and playback/recording
1238   unsigned long ctrl;
1239
1240   ctrl = pci_inl(SB128_CONTROL, card);
1241   ctrl &= ( ~(CTRL_DAC2_EN)  &  ~(CTRL_ADC_EN) );
1242
1243   /* Stop */
1244   pci_outl(ctrl, SB128_CONTROL, card);
1245
1246   /* Clear and mask interrupts */
1247   pci_outl((pci_inl(SB128_SCON, card) & SB128_IRQ_MASK), SB128_SCON, card);
1248
1249   return 0UL;
1250 }
1251
1252 #if !defined(__AROS__)
1253 void AddResetHandler(struct SB128_DATA *card)
1254 {
1255   static struct Interrupt interrupt;
1256
1257   interrupt.is_Code = (void (*)())ResetHandler;
1258   interrupt.is_Data = (APTR) card;
1259   interrupt.is_Node.ln_Pri = 0;
1260   interrupt.is_Node.ln_Type = NT_EXTINTERRUPT;
1261   interrupt.is_Node.ln_Name = "SB128 Reset Handler";
1262
1263   AddResetCallback( &interrupt );
1264 }
1265 #endif