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
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.
10 The Original Code is (C) Copyright 2004-2011 Ross Vumbaca.
12 The Initial Developer of the Original Code is Ross Vumbaca.
18 #include <exec/memory.h>
22 #include <aros/debug.h>
25 #include <proto/exec.h>
26 #include <proto/dos.h>
30 #include "interrupt.h"
33 #include "pci_wrapper.h"
36 #define DebugPrintF bug
37 INTGW(static, void, playbackinterrupt
, PlaybackInterrupt
);
38 INTGW(static, void, recordinterrupt
, RecordInterrupt
);
39 INTGW(static, ULONG
, cardinterrupt
, CardInterrupt
);
42 /* Global in Card.c */
43 extern const UWORD InputBits
[];
45 /* Public functions in main.c */
46 int card_init(struct SB128_DATA
*card
);
47 void card_cleanup(struct SB128_DATA
*card
);
49 #if !defined(__AROS__)
50 void AddResetHandler(struct SB128_DATA
*card
);
53 void micro_delay(unsigned int val
)
55 struct Device
* TimerBase
= NULL
;
56 struct timerequest
* TimerIO
= NULL
;
57 struct MsgPort
* replymp
;
59 replymp
= (struct MsgPort
*) CreateMsgPort();
62 DebugPrintF("SB128: Couldn't create reply port\n");
66 TimerIO
= (struct TimeRequest
*)CreateIORequest(replymp
, sizeof(struct timerequest
));
70 DebugPrintF("SB128: Out of memory.\n");
74 if (OpenDevice((CONST_STRPTR
) "timer.device", UNIT_MICROHZ
, (struct IORequest
*)TimerIO
, 0) != 0)
76 DebugPrintF("SB128: Unable to open 'timer.device'.\n");
81 TimerBase
= (struct Device
*)TimerIO
->tr_node
.io_Device
;
86 TimerIO
->tr_node
.io_Command
= TR_ADDREQUEST
;
87 TimerIO
->tr_time
.tv_secs
= 0;
88 TimerIO
->tr_time
.tv_micro
= val
;
89 DoIO((struct IORequest
*)TimerIO
);
90 DeleteIORequest((struct IORequest
*)TimerIO
);
92 CloseDevice((struct IORequest
*)TimerIO
);
97 DeleteMsgPort(replymp
);
101 unsigned long src_ready(struct SB128_DATA
*card
)
103 struct PCIDevice
*dev
= (struct PCIDevice
*) card
->pci_dev
;
107 /* Wait for the busy bit to become invalid, and then return the contents
108 of the SRC register. */
109 for (i
= 0; i
< 0x1000; i
++)
111 if (!((r
= pci_inl(SB128_SRC
, card
)) & SRC_BUSY
))
116 DebugPrintF("SB128: SRC Ready timeout.\n");
120 void src_write(struct SB128_DATA
*card
, unsigned short addr
, unsigned short data
)
122 struct PCIDevice
*dev
= (struct PCIDevice
*) card
->pci_dev
;
125 // ObtainSemaphore(&card->sb128_semaphore);
127 /* Get copy of SRC register when it's not busy, add address and data, write back. */
128 r
= src_ready(card
) & (SRC_DISABLE
| SRC_DIS_DAC2
| SRC_DIS_ADC
);
129 r
= r
| (addr
<< SRC_ADDR_SHIFT
);
131 pci_outl(r
| SRC_WE
, SB128_SRC
, card
);
134 // ReleaseSemaphore(&card->sb128_semaphore);
137 unsigned short src_read(struct SB128_DATA
*card
, unsigned short addr
)
139 struct PCIDevice
*dev
= (struct PCIDevice
*) card
->pci_dev
;
141 //There may be ES137x bugs that require accomodating in this section.
145 // ObtainSemaphore(&card->sb128_semaphore);
147 /* Get copy of SRC register when it's not busy, add address, write back,
148 wait for ready, then read back value. */
149 r
= src_ready(card
) & (SRC_DISABLE
| SRC_DIS_DAC2
| SRC_DIS_ADC
);
150 r
= r
| (addr
<< SRC_ADDR_SHIFT
);
151 pci_outl(r
, SB128_SRC
, card
);
153 /* Give the chip a chance to set the busy bit. */
156 // ReleaseSemaphore(&card->sb128_semaphore);
158 return (src_ready(card
) & 0xFFFF);
161 /* Translate AC97 commands to AK4531 commands, and write to the AK4531 codec */
162 void ak4531_ac97_write(struct SB128_DATA
*card
, unsigned short reg
, unsigned short val
)
169 char input_right
= 0;
177 if (reg
== AC97_RECORD_SELECT
)
179 /* Change input select settings */
181 input_left
= val
>> 8;
183 /* Translate as appropriate */
184 switch (input_left
) {
211 /* Stereo Mix (all) */
226 /* Shouldn't happen */
227 DebugPrintF("SB128: Unsupported Record Input command\n");
230 switch (input_right
) {
257 /* Stereo Mix (all) */
272 /* Shouldn't happen */
273 DebugPrintF("SB128: Unsupported Record Input command\n");
276 /* Write input values to AK4531 */
278 codec_write(card
, AK4531_INPUT_MUX_L_1
, ak4531_L1
);
279 codec_write(card
, AK4531_INPUT_MUX_R_1
, ak4531_R1
);
280 codec_write(card
, AK4531_INPUT_MUX_L_2
, ak4531_L2
);
281 codec_write(card
, AK4531_INPUT_MUX_R_2
, ak4531_R2
);
285 if (reg
== AC97_PHONE_VOL
|| AC97_MIC_VOL
|| AC97_LINEIN_VOL
|| AC97_CD_VOL
|| AC97_AUX_VOL
|| AC97_PCMOUT_VOL
)
287 /* Adjust PCM (from card) Input gain */
290 /* Using a muted volume */
291 right_vol
= (AK4531_MUTE
| 0x6);
292 left_vol
= (AK4531_MUTE
| 0x6);
297 right_vol
= (val
& 0x1F);
298 left_vol
= (val
>> 8);
300 /* Convert right volume */
303 steps
= 0x8 - right_vol
;
306 right_vol
= (int) (steps
+ 0.5);
307 right_vol
= 0x6 - right_vol
;
309 else if (right_vol
> 0x8)
311 steps
= right_vol
- 0x8;
314 right_vol
= (int) (steps
+ 0.5);
315 right_vol
= 0x6 + right_vol
;
317 else if (right_vol
== 0x8)
319 /* No attentuation, no mute */
323 /* Convert left volume */
326 steps
= 0x8 - left_vol
;
329 left_vol
= (int) (steps
+ 0.5);
330 left_vol
= 0x6 - left_vol
;
332 else if (left_vol
> 0x8)
334 steps
= left_vol
- 0x8;
337 left_vol
= (int) (steps
+ 0.5);
338 left_vol
= 0x6 + left_vol
;
340 else if (left_vol
== 0x8)
342 /* No attentuation, no mute */
348 /* Write adjusted volume to appropriate place */
349 /* Un-mute, and disable output, if an input muted */
353 codec_write(card
, AK4531_PHONE_VOL_L
, right_vol
);
354 codec_write(card
, AK4531_PHONE_VOL_R
, right_vol
);
358 codec_write(card
, AK4531_MIC_VOL
, right_vol
);
361 case AC97_LINEIN_VOL
:
362 if ((left_vol
& AK4531_MUTE
) && (right_vol
& AK4531_MUTE
))
366 /* Disable on OUTPUT mux */
367 card
->ak4531_output_1
= (card
->ak4531_output_1
& ~(AK4531_OUTPUT_LINE
));
368 codec_write(card
, AK4531_OUTPUT_MUX_1
, card
->ak4531_output_1
);
372 codec_write(card
, AK4531_LINEIN_VOL_L
, left_vol
);
373 codec_write(card
, AK4531_LINEIN_VOL_R
, right_vol
);
374 /* Re-enable on OUTPUT mux */
375 card
->ak4531_output_1
= (card
->ak4531_output_1
| AK4531_OUTPUT_LINE
);
376 codec_write(card
, AK4531_OUTPUT_MUX_1
, card
->ak4531_output_1
);
381 if ((left_vol
& AK4531_MUTE
) && (right_vol
& AK4531_MUTE
))
385 /* Disable on OUTPUT mux */
386 card
->ak4531_output_1
= (card
->ak4531_output_1
& ~(AK4531_OUTPUT_CD
));
387 codec_write(card
, AK4531_OUTPUT_MUX_1
, card
->ak4531_output_1
);
391 codec_write(card
, AK4531_CD_VOL_L
, left_vol
);
392 codec_write(card
, AK4531_CD_VOL_R
, right_vol
);
393 /* Re-enable on OUTPUT mux */
394 card
->ak4531_output_1
= (card
->ak4531_output_1
| AK4531_OUTPUT_CD
);
395 codec_write(card
, AK4531_OUTPUT_MUX_1
, card
->ak4531_output_1
);
400 if ((left_vol
& AK4531_MUTE
) && (right_vol
& AK4531_MUTE
))
404 /* Disable on OUTPUT mux */
405 card
->ak4531_output_2
= (card
->ak4531_output_2
& ~(AK4531_OUTPUT_AUX
));
406 codec_write(card
, AK4531_OUTPUT_MUX_2
, card
->ak4531_output_2
);
410 codec_write(card
, AK4531_AUX_VOL_L
, left_vol
);
411 codec_write(card
, AK4531_AUX_VOL_R
, right_vol
);
412 /* Re-enable on OUTPUT mux */
413 card
->ak4531_output_2
= (card
->ak4531_output_2
| AK4531_OUTPUT_AUX
);
414 codec_write(card
, AK4531_OUTPUT_MUX_2
, card
->ak4531_output_2
);
418 case AC97_PCMOUT_VOL
:
419 codec_write(card
, AK4531_PCMOUT_VOL_L
, left_vol
);
420 codec_write(card
, AK4531_PCMOUT_VOL_R
, right_vol
);
424 DebugPrintF("SB128: Invalid value for Volume Set\n");
433 void codec_write(struct SB128_DATA
*card
, unsigned short reg
, unsigned short val
)
435 struct PCIDevice
*dev
= (struct PCIDevice
*) card
->pci_dev
;
438 /* Take hold of the hardware semaphore */
439 //ObtainSemaphore(&card->sb128_semaphore);
443 for (i
= 0; i
< 10; i
++)
445 if (!(pci_inl(SB128_STATUS
, card
) & CODEC_CSTAT
))
449 DebugPrintF("SB128: Couldn't write to ak4531!\n");
453 pci_outw(((unsigned char)reg
<< ES1370_CODEC_ADD_SHIFT
) | (unsigned char)val
, ES1370_SB128_CODEC
, card
);
460 for (i
= 0; i
< 0x1000; i
++)
462 if (!(pci_inl(SB128_CODEC
, card
) & CODEC_WIP
))
465 DebugPrintF("SB128: Couldn't write to ac97! (1)\n");
466 //ReleaseSemaphore(&card->sb128_semaphore);
470 /* Get copy of SRC register when it's not busy. */
472 /* Enable "SRC State Data", an undocumented feature! */
473 pci_outl((r
& (SRC_DISABLE
| SRC_DIS_DAC2
| SRC_DIS_ADC
)) | 0x00010000, SB128_SRC
, card
);
475 /* Wait for "state 0", to avoid "transition states". */
476 for (i
= 0; i
< 0x1000; i
++)
478 if ((pci_inl(SB128_SRC
, card
) & 0x00870000) == 0x00)
483 /* Now wait for an undocumented bit to be set (and the SRC to be NOT busy) */
484 for (i
= 0; i
< 0x1000; i
++)
486 if ((pci_inl(SB128_SRC
, card
) & 0x00870000) == 0x00010000)
491 /* Write out the value to the codec now. */
492 pci_outl((((reg
<< CODEC_ADD_SHIFT
) & CODEC_ADD_MASK
) | val
), SB128_CODEC
, card
);
494 /* Delay to make sure the chip had time to set the WIP after
498 /* Restore SRC register. */
500 pci_outl(r
, SB128_SRC
, card
);
502 /* Check for WIP before returning. */
503 for (i
= 0; i
< 0x1000; i
++)
505 if (!(pci_inl(SB128_CODEC
, card
) & CODEC_WIP
))
507 //ReleaseSemaphore(&card->sb128_semaphore);
512 DebugPrintF("SB128: Couldn't write to ac97! (2)\n");
515 //ReleaseSemaphore(&card->sb128_semaphore);
519 unsigned short codec_read(struct SB128_DATA
*card
, unsigned short reg
)
521 struct PCIDevice
*dev
= (struct PCIDevice
*) card
->pci_dev
;
528 //ObtainSemaphore(&card->sb128_semaphore);
531 for (i
= 0; i
< 0x1000; i
++) {
532 if (!((pci_inl(SB128_CODEC
, card
)) & CODEC_WIP
))
535 DebugPrintF("SB128: Couldn't read from ac97! (1)\n");
536 // ReleaseSemaphore(&card->sb128_semaphore);
541 /* Get copy of SRC register when it's not busy. */
544 /* Enable "SRC State Data", an undocumented feature! */
545 pci_outl((r
& (SRC_DISABLE
| SRC_DIS_DAC1
| SRC_DIS_DAC2
| SRC_DIS_ADC
)) | 0x00010000, SB128_SRC
, card
);
547 /* Wait for "state 0", to avoid "transition states".
548 Seen in open code. */
549 for (i
= 0; i
< 0x1000; i
++)
551 if ((pci_inl(SB128_SRC
, card
) & 0x00870000) == 0x00)
556 /* Now wait for an undocumented bit to be set (and the SRC to be NOT busy) */
557 for (i
= 0; i
< 0x1000; i
++)
559 if ((pci_inl(SB128_SRC
, card
) & 0x00870000) == 0x00010000)
564 /* Write the read request to the chip now */
565 pci_outl((((reg
<< CODEC_ADD_SHIFT
) & CODEC_ADD_MASK
) | CODEC_READ
), SB128_CODEC
, card
);
567 /* Give the chip time to respond to our read request. */
570 /* Restore SRC register. */
572 pci_outl(r
, SB128_SRC
, card
);
575 for (i
= 0; i
< 0x1000; i
++) {
576 if (!((pci_inl(SB128_CODEC
, card
)) & CODEC_WIP
))
579 DebugPrintF("SB128: Couldn't read from ac97 (2)!\n");
580 // ReleaseSemaphore(&card->sb128_semaphore);
587 for (i
= 0; i
< 0x1000; i
++) {
588 if (!((pci_inl(SB128_CODEC
, card
)) & CODEC_RDY
))
591 DebugPrintF("SB128: Couldn't read from ac97 (3)!\n");
592 // ReleaseSemaphore(&card->sb128_semaphore);
597 Delay(1); //A delay here is crucial, remove this if you use micro_delay()
598 val
= pci_inl(SB128_CODEC
, card
);
600 // ReleaseSemaphore(&card->sb128_semaphore);
605 void rate_set_adc(struct SB128_DATA
*card
, unsigned long rate
)
607 struct PCIDevice
*dev
= (struct PCIDevice
*) card
->pci_dev
;
609 unsigned long n
, truncm
, freq
;
611 //ObtainSemaphore(&card->sb128_semaphore);
620 pci_outl(((pci_inl(SB128_CONTROL
, card
) & ~DAC2_DIV_MASK
) | (DAC2_SRTODIV(rate
) << DAC2_DIV_SHIFT
)), SB128_CONTROL
, card
);
625 /* This is completely undocumented */
627 if ((1 << n
) & ((1 << 15) | (1 << 13) | (1 << 11) | (1 << 9)))
629 truncm
= (21 * n
- 1) | 1;
630 freq
= ((48000UL << 15) / rate
) * n
;
636 src_write(card
, SRC_ADC
+ SRC_TRUNC
, (((239 - truncm
) >> 1) << 9) | (n
<< 4));
642 src_write(card
, SRC_ADC
+ SRC_TRUNC
, 0x8000 | (((119 - truncm
) >> 1) << 9) | (n
<< 4));
644 src_write(card
, SRC_ADC
+ SRC_INT
,
645 (src_read(card
, SRC_ADC
+ SRC_INT
) & 0x00FF) | ((freq
>> 5) & 0xFC00));
646 src_write(card
, SRC_ADC
+ SRC_VF
, freq
& 0x7FFF);
647 src_write(card
, SRC_VOL_ADC
, n
<< 8);
648 src_write(card
, SRC_VOL_ADC
+ 1, n
<< 8);
652 //ReleaseSemaphore(&card->sb128_semaphore);
656 void rate_set_dac2(struct SB128_DATA
*card
, unsigned long rate
)
658 struct PCIDevice
*dev
= (struct PCIDevice
*) card
->pci_dev
;
660 unsigned long freq
, r
;
662 //ObtainSemaphore(&card->sb128_semaphore);
671 pci_outl(((pci_inl(SB128_CONTROL
, card
) & ~DAC2_DIV_MASK
) | (DAC2_SRTODIV(rate
) << DAC2_DIV_SHIFT
)), SB128_CONTROL
, card
);
676 freq
= ((rate
<< 15 ) + 1500) / 3000;
678 /* Get copy of SRC register when it's not busy, clear, preserve the disable bits, write back. */
679 r
= src_ready(card
) & (SRC_DISABLE
| SRC_DIS_DAC1
| SRC_DIS_DAC2
| SRC_DIS_ADC
);
680 pci_outl(r
, SB128_SRC
, card
);
682 /* This is completely undocumented */
683 src_write(card
, SRC_DAC2
+ SRC_INT
,
684 (src_read(card
, SRC_DAC2
+ SRC_INT
) & 0x00FF) | ((freq
>> 5) & 0xFC00));
685 src_write(card
, SRC_DAC2
+ SRC_VF
, freq
& 0x7FFF);
686 r
= (src_ready(card
) & (SRC_DISABLE
| SRC_DIS_DAC1
| SRC_DIS_ADC
));
687 pci_outl(r
, SB128_SRC
, card
);
691 //ReleaseSemaphore(&card->sb128_semaphore);
695 /******************************************************************************
696 ** DriverData allocation ******************************************************
697 ******************************************************************************/
699 /* This code used to be in _AHIsub_AllocAudio(), but since we're now
700 handling CAMD support too, it needs to be done at driver loading
704 AllocDriverData( struct PCIDevice
* dev
,
705 struct DriverBase
* AHIsubBase
)
707 struct SB128Base
* SB128Base
= (struct SB128Base
*) AHIsubBase
;
708 struct SB128_DATA
* card
;
712 bug("[SB128]: %s()\n", __PRETTY_FUNCTION__
);
714 // FIXME: This should be non-cachable, DMA-able memory
715 card
= AllocVec( sizeof( *card
), MEMF_PUBLIC
| MEMF_CLEAR
);
719 Req( "Unable to allocate driver structure." );
723 card
->ahisubbase
= AHIsubBase
;
725 card
->interrupt
.is_Node
.ln_Type
= IRQTYPE
;
726 card
->interrupt
.is_Node
.ln_Pri
= 0;
727 card
->interrupt
.is_Node
.ln_Name
= (STRPTR
) LibName
;
729 card
->interrupt
.is_Code
= (void(*)(void))&cardinterrupt
;
731 card
->interrupt
.is_Code
= (void(*)(void))CardInterrupt
;
733 card
->interrupt
.is_Data
= (APTR
) card
;
735 card
->playback_interrupt
.is_Node
.ln_Type
= IRQTYPE
;
736 card
->playback_interrupt
.is_Node
.ln_Pri
= 0;
737 card
->playback_interrupt
.is_Node
.ln_Name
= (STRPTR
) LibName
;
739 card
->playback_interrupt
.is_Code
= (void(*)(void))&playbackinterrupt
;
741 card
->playback_interrupt
.is_Code
= (void(*)(void))PlaybackInterrupt
;
743 card
->playback_interrupt
.is_Data
= (APTR
) card
;
745 card
->record_interrupt
.is_Node
.ln_Type
= IRQTYPE
;
746 card
->record_interrupt
.is_Node
.ln_Pri
= 0;
747 card
->record_interrupt
.is_Node
.ln_Name
= (STRPTR
) LibName
;
749 card
->record_interrupt
.is_Code
= (void(*)(void))&recordinterrupt
;
751 card
->record_interrupt
.is_Code
= (void(*)(void))RecordInterrupt
;
753 card
->record_interrupt
.is_Data
= (APTR
) card
;
757 command_word
= inw_config( PCI_COMMAND
, dev
);
758 command_word
|= PCI_COMMAND_IO
| PCI_COMMAND_MEMORY
| PCI_COMMAND_MASTER
;
759 outw_config( PCI_COMMAND
, command_word
, dev
);
761 card
->pci_master_enabled
= TRUE
;
763 card
->iobase
= ahi_pci_get_base_address(0, dev
);
764 card
->length
= ~( ahi_pci_get_base_size(0, dev
) & PCI_BASE_ADDRESS_IO_MASK
);
765 card
->irq
= ahi_pci_get_irq(dev
);
766 card
->chiprev
= inb_config(PCI_REVISION_ID
, dev
);
767 card
->model
= inw_config(PCI_SUBSYSTEM_ID
, dev
);
769 bug("[CMI8738]: %s: iobase = 0x%p, len = %d\n", __PRETTY_FUNCTION__
, card
->iobase
, card
->length
);
771 /* Initialise hardware access Semaphore */
772 InitSemaphore(&card
->sb128_semaphore
);
775 /* Initialize chip */
776 if( card_init( card
) < 0 )
778 DebugPrintF("SB128: Unable to initialize Card subsystem.");
782 ahi_pci_add_intserver(&card
->interrupt
, dev
);
783 card
->interrupt_added
= TRUE
;
786 card
->card_initialized
= TRUE
;
789 card
->monitor_volume
= Linear2MixerGain( 0, &card
->monitor_volume_bits
);
790 card
->input_gain
= Linear2RecordGain( 0x10000, &card
->input_gain_bits
);
791 card
->output_volume
= Linear2MixerGain( 0x10000, &card
->output_volume_bits
);
792 SaveMixerState(card
);
794 #if !defined(__AROS__)
795 AddResetHandler(card
);
802 /******************************************************************************
803 ** DriverData deallocation ****************************************************
804 ******************************************************************************/
806 /* And this code used to be in _AHIsub_FreeAudio(). */
809 FreeDriverData( struct SB128_DATA
* card
,
810 struct DriverBase
* AHIsubBase
)
814 if( card
->pci_dev
!= NULL
)
816 if( card
->card_initialized
)
818 card_cleanup( card
);
821 if( card
->pci_master_enabled
)
825 cmd
= inw_config(PCI_COMMAND
, (struct PCIDevice
* ) card
->pci_dev
);
826 cmd
&= ~( PCI_COMMAND_IO
| PCI_COMMAND_MEMORY
| PCI_COMMAND_MASTER
);
827 outw_config(PCI_COMMAND
, cmd
, (struct PCIDevice
* ) card
->pci_dev
);
831 if( card
->interrupt_added
)
833 ahi_pci_rem_intserver(&card
->interrupt
, card
->pci_dev
);
841 int card_init(struct SB128_DATA
*card
)
843 struct PCIDevice
*dev
= (struct PCIDevice
*) card
->pci_dev
;
847 /* Check if the card is an original ES1370 - different code needed */
848 if (inw_config(2, dev
) == 0x5000)
851 card
->es1370
= FALSE
;
853 /* Different init sequence for the ES1370 */
856 /* Enable CODEC access, set DAC sample rate to 44100 */
857 pci_outl(CTRL_CDC_EN
| (DAC2_SRTODIV(44100) << DAC2_DIV_SHIFT
), SB128_CONTROL
, card
);
858 pci_outl(0x00, SB128_SCON
, card
);
859 DebugPrintF("SB128: Did RATE init\n");
861 /* CODEC initialisation */
862 codec_write(card
, AK4531_RESET
, 0x03); /* Enable CODEC */
863 codec_write(card
, AK4531_CLOCK_SEL
, 0x00); /* CODEC ADC and DAC use PLL */
864 codec_write(card
, AK4531_RECORD_SELECT
, 0x00); /* CODEC ADC set to use mixer for input */
865 codec_write(card
, AK4531_RECORD_GAIN_MIC
, 0x00); /* Mic gain set to 0 dB */
867 /* Volume initialisation */
868 codec_write(card
, AK4531_MASTER_VOL_L
, 0x00); /* No attentuation */
869 codec_write(card
, AK4531_MASTER_VOL_R
, 0x00);
870 codec_write(card
, AK4531_MASTER_VOL_MONO
, 0x00);
872 /* Analogue mixer input gain registers */
873 codec_write(card
, AK4531_PHONE_VOL_L
, AK4531_MUTE
| 0x06);
874 codec_write(card
, AK4531_PHONE_VOL_R
, AK4531_MUTE
| 0x06);
875 codec_write(card
, AK4531_MIC_VOL
, AK4531_MUTE
| 0x06);
876 codec_write(card
, AK4531_LINEIN_VOL_L
, AK4531_MUTE
| 0x06);
877 codec_write(card
, AK4531_LINEIN_VOL_R
, AK4531_MUTE
| 0x06);
878 codec_write(card
, AK4531_CD_VOL_L
, 0x06);
879 codec_write(card
, AK4531_CD_VOL_R
, 0x06);
880 codec_write(card
, AK4531_AUX_VOL_L
, 0x06);
881 codec_write(card
, AK4531_AUX_VOL_R
, 0x06);
882 codec_write(card
, AK4531_PCMOUT_VOL_L
, 0x06);
883 codec_write(card
, AK4531_PCMOUT_VOL_R
, 0x06);
885 /* Mixer registers */
888 codec_write(card
, AK4531_OUTPUT_MUX_1
, 0x1F);
889 codec_write(card
, AK4531_OUTPUT_MUX_2
, 0x3F);
891 /* Store value of OUTPUT MUX registers */
892 card
->ak4531_output_1
= 0x1F;
893 card
->ak4531_output_2
= 0x3F;
895 /* Analogous to "Record Select", only TMIC and Phone enabled here */
896 codec_write(card
, AK4531_INPUT_MUX_L_1
, 0x00);
897 codec_write(card
, AK4531_INPUT_MUX_R_1
, 0x00);
898 codec_write(card
, AK4531_INPUT_MUX_L_2
, 0x80);
899 codec_write(card
, AK4531_INPUT_MUX_R_2
, 0x80);
901 DebugPrintF("SB128: Did VOLUME init\n");
905 /* Basic clear of everything */
906 pci_outl(0x00, SB128_CONTROL
, card
);
907 pci_outl(0x00, SB128_SCON
, card
);
908 pci_outl(0x00, SB128_LEGACY
, card
);
910 /* Magical CT5880 AC97 enable bit plus 20ms delay
911 (Gotta love the undocumented stuff) */
912 pci_outl(0x20000000, SB128_STATUS
, card
);
915 /* Assert the AC97 reset, and wait 20ms */
916 pci_outl(CODEC_RESET
, SB128_CONTROL
, card
);
918 /* De-assert delay, and wait 20ms */
919 pci_outl(0x00, SB128_CONTROL
, card
);
922 DebugPrintF("SB128: Did AC97 reset.\n");
924 /* Disable the Sample Rate Converter (SRC) */
926 pci_outl(SRC_DISABLE
, SB128_SRC
, card
);
927 /* Clear the SRC RAM */
928 for (i
= 0; i
< 0x80; i
++)
929 src_write(card
, i
, 0);
931 DebugPrintF("SB128: Did SRC wipe.\n");
933 /* Perform basic configuration of the SRC, not well documented! */
934 src_write(card
, SRC_DAC1
+ SRC_TRUNC
, 0x100);
935 src_write(card
, SRC_DAC1
+ SRC_INT
, 0x4000);
936 src_write(card
, SRC_DAC2
+ SRC_TRUNC
, 0x100);
937 src_write(card
, SRC_DAC2
+ SRC_INT
, 0x4000);
938 src_write(card
, SRC_VOL_ADC
, 0x1000);
939 src_write(card
, SRC_VOL_ADC
+ 1, 0x1000);
940 src_write(card
, SRC_VOL_DAC1
, 0x1000);
941 src_write(card
, SRC_VOL_DAC1
+ 1, 0x1000);
942 src_write(card
, SRC_VOL_DAC2
, 0x1000);
943 src_write(card
, SRC_VOL_DAC2
+ 1, 0x1000);
945 DebugPrintF("SB128: Did SRC init.\n");
947 rate_set_adc(card
, 44100);
948 rate_set_dac2(card
, 44100);
950 /* Re-enable the SRC */
952 pci_outl(0, SB128_SRC
, card
);
954 card
->currentPlayFreq
= 9;
955 card
->currentRecFreq
= 9;
957 DebugPrintF("SB128: Did RATE init.\n");
959 /* Initialise registers of AC97 to default */
960 codec_write(card
, AC97_RESET
, 0x00);
962 /* Initialise volumes of AC97 */
963 codec_write(card
, AC97_MASTER_VOL_STEREO
, 0x0000 ); /* no attenuation */
964 codec_write(card
, AC97_AUXOUT_VOL
, 0x0000 ); /* volume of the rear output */
965 codec_write(card
, AC97_MASTER_VOL_MONO
, 0x0000 );
966 codec_write(card
, AC97_MASTER_TONE
, 0x0f0f ); /* bass/treble control (if present) */
968 codec_write(card
, AC97_RECORD_SELECT
, 0);
969 codec_write(card
, AC97_RECORD_GAIN
, 0x0000 ); /* 0 dB gain */
971 /* Analogue mixer input gain registers */
972 codec_write(card
, AC97_PHONE_VOL
, AC97_MUTE
| 0x0008 );
973 codec_write(card
, AC97_MIC_VOL
, AC97_MUTE
| 0x0008 );
974 codec_write(card
, AC97_LINEIN_VOL
, AC97_MUTE
| 0x0808 );
975 codec_write(card
, AC97_CD_VOL
, 0x0808 );
976 codec_write(card
, AC97_VIDEO_VOL
, AC97_MUTE
| 0x0808 );
977 codec_write(card
, AC97_AUX_VOL
, 0x0808 );
978 codec_write(card
, AC97_PCMOUT_VOL
, 0x0808 );
980 DebugPrintF("SB128: Did VOLUME init.\n");
982 cod
= codec_read(card
, AC97_RESET
);
983 DebugPrintF("SB128: AC97 capabilities = %x\n", cod
);
985 cod
= codec_read(card
, AC97_VENDOR_ID0
);
986 DebugPrintF("SB128: AC97_VENDOR_ID0 = %x\n", cod
);
988 cod
= codec_read(card
, AC97_VENDOR_ID1
);
989 DebugPrintF("SB128: AC97_VENDOR_ID1 = %x\n", cod
);
996 void card_cleanup(struct SB128_DATA
*card
)
1002 /******************************************************************************
1003 ** Misc. **********************************************************************
1004 ******************************************************************************/
1007 SaveMixerState( struct SB128_DATA
* card
)
1009 card
->ac97_mic
= codec_read( card
, AC97_MIC_VOL
);
1010 card
->ac97_cd
= codec_read( card
, AC97_CD_VOL
);
1011 card
->ac97_aux
= codec_read( card
, AC97_AUX_VOL
);
1012 card
->ac97_linein
= codec_read( card
, AC97_LINEIN_VOL
);
1013 card
->ac97_phone
= codec_read( card
, AC97_PHONE_VOL
);
1018 RestoreMixerState( struct SB128_DATA
* card
)
1022 /* Not possible to save the state, so restore all volumes to mid levels */
1023 ak4531_ac97_write(card
, AC97_MIC_VOL
, 0x0808);
1024 ak4531_ac97_write(card
, AC97_CD_VOL
, 0x0808);
1025 ak4531_ac97_write(card
, AC97_AUX_VOL
, 0x0808);
1026 ak4531_ac97_write(card
, AC97_LINEIN_VOL
, 0x0808);
1027 ak4531_ac97_write(card
, AC97_PHONE_VOL
, 0x0808);
1031 codec_write(card
, AC97_MIC_VOL
, card
->ac97_mic
);
1032 codec_write(card
, AC97_CD_VOL
, card
->ac97_cd
);
1033 codec_write(card
, AC97_AUX_VOL
, card
->ac97_aux
);
1034 codec_write(card
, AC97_LINEIN_VOL
, card
->ac97_linein
);
1035 codec_write(card
, AC97_PHONE_VOL
, card
->ac97_phone
);
1040 UpdateMonitorMixer( struct SB128_DATA
* card
)
1042 int i
= InputBits
[ card
->input
];
1043 UWORD m
= card
->monitor_volume_bits
& 0x801f;
1044 UWORD s
= card
->monitor_volume_bits
;
1045 UWORD mm
= AC97_MUTE
| 0x0008;
1046 UWORD sm
= AC97_MUTE
| 0x0808;
1048 if( i
== AC97_RECMUX_STEREO_MIX
)
1050 /* Use the original mixer settings */
1051 RestoreMixerState( card
);
1057 ak4531_ac97_write(card
, AC97_MIC_VOL
,
1058 i
== AC97_RECMUX_MIC
? m
: mm
);
1060 ak4531_ac97_write(card
, AC97_CD_VOL
,
1061 i
== AC97_RECMUX_CD
? s
: sm
);
1063 ak4531_ac97_write(card
, AC97_AUX_VOL
,
1064 i
== AC97_RECMUX_AUX
? s
: sm
);
1066 ak4531_ac97_write(card
, AC97_LINEIN_VOL
,
1067 i
== AC97_RECMUX_LINE
? s
: sm
);
1069 ak4531_ac97_write(card
, AC97_PHONE_VOL
,
1070 i
== AC97_RECMUX_PHONE
? m
: mm
);
1074 codec_write(card
, AC97_MIC_VOL
,
1075 i
== AC97_RECMUX_MIC
? m
: mm
);
1077 codec_write(card
, AC97_CD_VOL
,
1078 i
== AC97_RECMUX_CD
? s
: sm
);
1080 codec_write(card
, AC97_AUX_VOL
,
1081 i
== AC97_RECMUX_AUX
? s
: sm
);
1083 codec_write(card
, AC97_LINEIN_VOL
,
1084 i
== AC97_RECMUX_LINE
? s
: sm
);
1086 codec_write(card
, AC97_PHONE_VOL
,
1087 i
== AC97_RECMUX_PHONE
? m
: mm
);
1094 Linear2MixerGain( Fixed linear
,
1097 static const Fixed gain
[ 33 ] =
1099 260904, /* +12.0 dB */
1100 219523, /* +10.5 dB */
1101 184706, /* +9.0 dB */
1102 155410, /* +7.5 dB */
1103 130762, /* +6.0 dB */
1104 110022, /* +4.5 dB */
1105 92572, /* +3.0 dB */
1106 77890, /* +1.5 dB */
1107 65536, /* ±0.0 dB */
1108 55142, /* -1.5 dB */
1109 46396, /* -3.0 dB */
1110 39037, /* -4.5 dB */
1111 32846, /* -6.0 dB */
1112 27636, /* -7.5 dB */
1113 23253, /* -9.0 dB */
1114 19565, /* -10.5 dB */
1115 16462, /* -12.0 dB */
1116 13851, /* -13.5 dB */
1117 11654, /* -15.0 dB */
1118 9806, /* -16.5 dB */
1119 8250, /* -18.0 dB */
1120 6942, /* -19.5 dB */
1121 5841, /* -21.0 dB */
1122 4915, /* -22.5 dB */
1123 4135, /* -24.0 dB */
1124 3479, /* -25.5 dB */
1125 2927, /* -27.0 dB */
1126 2463, /* -28.5 dB */
1127 2072, /* -30.0 dB */
1128 1744, /* -31.5 dB */
1129 1467, /* -33.0 dB */
1130 1234, /* -34.5 dB */
1135 while( linear
< gain
[ v
] )
1142 *bits
= 0x8000; /* Mute */
1146 *bits
= ( v
<< 8 ) | v
;
1152 Linear2RecordGain( Fixed linear
,
1155 static const Fixed gain
[ 17 ] =
1157 873937, /* +22.5 dB */
1158 735326, /* +21.0 dB */
1159 618700, /* +19.5 dB */
1160 520571, /* +18.0 dB */
1161 438006, /* +16.5 dB */
1162 368536, /* +15.0 dB */
1163 310084, /* +13.5 dB */
1164 260904, /* +12.0 dB */
1165 219523, /* +10.5 dB */
1166 184706, /* +9.0 dB */
1167 155410, /* +7.5 dB */
1168 130762, /* +6.0 dB */
1169 110022, /* +4.5 dB */
1170 92572, /* +3.0 dB */
1171 77890, /* +1.5 dB */
1172 65536, /* ±0.0 dB */
1178 while( linear
< gain
[ v
] )
1185 *bits
= 0x8000; /* Mute */
1189 *bits
= ( ( 15 - v
) << 8 ) | ( 15 - v
);
1197 SamplerateToLinearPitch( ULONG samplingrate
)
1199 samplingrate
= (samplingrate
<< 8) / 375;
1200 return (samplingrate
>> 1) + (samplingrate
& 1);
1204 void *pci_alloc_consistent(size_t size
, APTR
*NonAlignedAddress
, unsigned int boundary
)
1209 bug("[CMI8738]: %s()\n", __PRETTY_FUNCTION__
);
1211 address
= (void *) AllocVec(size
+ boundary
, MEMF_PUBLIC
| MEMF_CLEAR
);
1213 if (address
!= NULL
)
1215 a
= (unsigned long) address
;
1216 a
= (a
+ boundary
- 1) & ~(boundary
- 1);
1217 address
= (void *) a
;
1220 if (NonAlignedAddress
)
1222 *NonAlignedAddress
= address
;
1229 void pci_free_consistent(void* addr
)
1231 bug("[CMI8738]: %s()\n", __PRETTY_FUNCTION__
);
1236 static ULONG
ResetHandler(struct ExceptionContext
*ctx
, struct ExecBase
*pExecBase
, struct SB128_DATA
*card
)
1238 struct PCIDevice
*dev
= card
->pci_dev
;
1240 //Stop SB128 interrupts and playback/recording
1243 ctrl
= pci_inl(SB128_CONTROL
, card
);
1244 ctrl
&= ( ~(CTRL_DAC2_EN
) & ~(CTRL_ADC_EN
) );
1247 pci_outl(ctrl
, SB128_CONTROL
, card
);
1249 /* Clear and mask interrupts */
1250 pci_outl((pci_inl(SB128_SCON
, card
) & SB128_IRQ_MASK
), SB128_SCON
, card
);
1255 #if !defined(__AROS__)
1256 void AddResetHandler(struct SB128_DATA
*card
)
1258 static struct Interrupt interrupt
;
1260 interrupt
.is_Code
= (void (*)())ResetHandler
;
1261 interrupt
.is_Data
= (APTR
) card
;
1262 interrupt
.is_Node
.ln_Pri
= 0;
1263 interrupt
.is_Node
.ln_Type
= NT_EXTINTERRUPT
;
1264 interrupt
.is_Node
.ln_Name
= "SB128 Reset Handler";
1266 AddResetCallback( &interrupt
);