/* * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * * The contents of this file constitute Original Code as defined in and * are subject to the Apple Public Source License Version 1.1 (the * "License"). You may not use this file except in compliance with the * License. Please obtain a copy of the License at * http://www.apple.com/publicsource and read it before using this file. * * This Original Code and all software distributed under the License are * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the * License for the specific language governing rights and limitations * under the License. * * @APPLE_LICENSE_HEADER_END@ */ /* * Copyright (c) 1998 Apple Computer, Inc. All rights reserved. * * Hardware independent (relatively) code for the Burgundy Controller * * HISTORY * * */ #include "AudioHardwareCommon.h" #include "AudioHardwareConstants.h" #include "AudioHardwareUtilities.h" #include "AudioHardwareDetect.h" #include "AudioHardwareOutput.h" #include "AudioHardwareInput.h" #include "AudioHardwareMux.h" #include "AudioHardwarePower.h" #include "AppleBurgundyAudio.h" #include "burgundy_hw.h" #include "AppleDBDMAAudioDMAEngine.h" /* * Prototyes for the "very private methods" at the end of this * file. They provide access to the burgundy registers: */ static void Burgundy_writeSoundControlReg( volatile UInt8*, int); static int Burgundy_readCodecSenseLines( volatile UInt8*); static int Burgundy_readCodecReg( volatile UInt8*, int); static void Burgundy_writeCodecReg( volatile UInt8*, int, int); /* ============================================================= * VERY Private Methods used to access to the burgundy registers * ============================================================= */ static void Burgundy_writeCodecReg( volatile UInt8 *ioBaseBurgundy, int regInfo, int value ) { u_int32_t regBits; u_int32_t regValue; u_int32_t i; volatile u_int32_t CodecControlReg; struct _reg { UInt8 unused0; UInt8 size; UInt8 addr; UInt8 offset; } *reg = (struct _reg *)®Info; regBits = (kCodecCtlReg_Write | kCodecCtlReg_Reset) | ((u_int32_t) reg->addr * kCodecCtlReg_Addr_Bit) | ((u_int32_t)(reg->size + reg->offset - 1) * kCodecCtlReg_LastByte_Bit); for ( i=0; i < reg->size; i++ ) { regValue = regBits | ((u_int32_t)(reg->offset + i) * kCodecCtlReg_CurrentByte_Bit) | (value & 0xFF); OSWriteLittleInt32(ioBaseBurgundy, kCodecCtlReg, regValue ); eieio(); DEBUG2_IOLOG( "PPCSound(burgundy): CodecWrite = %08x\n\r", regValue ); value >>= 8; regBits &= ~kCodecCtlReg_Reset; do { CodecControlReg = OSReadLittleInt32( ioBaseBurgundy, kCodecCtlReg ); eieio(); } while ( CodecControlReg & kCodecCtlReg_Busy ); } } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // This function is used to read any Burgundy CODEC register. The routine also // updates member variables to indicate the current state of the configuration // pins. To update the configuration pin status, issue this function with any // target register and then access the configuration pin status. Burgundy pipelining // is NOT functional so it is necessary to operate two parallel state machines // to handle the codec control and status transactions when reading a Burgundy // codec register. NOTE: The transaction level mechanism used under MacOS 9 // to retry the register access if the current register access is preempted by // another register access from interrupt level has not been ported to this // member function. Any register access that is preempted by another register // access will result in erroneous data. A blocking mechanism should be implemented // here to prevent this situation. Then this note should be removed... static int Burgundy_readCodecReg( volatile UInt8 *ioBaseBurgundy, int regInfo ) { u_int32_t regBits; u_int32_t regValue = 0; u_int32_t i,j; int value; u_int32_t byteCounter; u_int32_t currentCounter; volatile u_int32_t CodecControlReg; volatile u_int32_t CodecStatusReg; struct _reg { UInt8 unused0; UInt8 size; UInt8 addr; UInt8 offset; } *reg = (struct _reg *)®Info; value = 0; regBits = (kCodecCtlReg_Reset) | ((u_int32_t) reg->addr * kCodecCtlReg_Addr_Bit) | ((u_int32_t)(reg->size + reg->offset - 1) * kCodecCtlReg_LastByte_Bit); CodecStatusReg = OSReadLittleInt32( ioBaseBurgundy, kCodecStatusReg ); eieio(); byteCounter = ((CodecStatusReg & kCodecStatusReg_ByteCounter_Mask) / kCodecStatusReg_ByteCounter_Bit + 1) & 0x03; for ( i=0; i < reg->size; i++ ) { regValue = regBits | ((u_int32_t)(reg->offset + i) * kCodecCtlReg_CurrentByte_Bit); OSWriteLittleInt32(ioBaseBurgundy, kCodecCtlReg, regValue ); eieio(); regBits &= ~kCodecCtlReg_Reset; do { CodecControlReg = OSReadLittleInt32( ioBaseBurgundy, kCodecCtlReg ); eieio(); } while ( CodecControlReg & kCodecCtlReg_Busy ); j=0; do { CodecStatusReg = OSReadLittleInt32( ioBaseBurgundy, kCodecStatusReg ); eieio(); currentCounter = ((CodecStatusReg & kCodecStatusReg_ByteCounter_Mask) / kCodecStatusReg_ByteCounter_Bit) & 0x03; } while ( (byteCounter != currentCounter) && (j++ < 1000)); byteCounter++; IODelay(10); CodecStatusReg = OSReadLittleInt32( ioBaseBurgundy, kCodecStatusReg ); value |= ((CodecStatusReg & kCodecStatusReg_Data_Mask) / kCodecStatusReg_Data_Bit) << 8*i; } // DEBUG2_IOLOG( "PPCSound(burgundy): CodecRead = %08x %08x\n\r", regValue, value ); return value; } static int Burgundy_readCodecSenseLines( volatile UInt8 *ioBaseBurgundy ) { return ((OSReadLittleInt32( ioBaseBurgundy, kCodecStatusReg ) / kCodecStatusReg_Sense_Bit) & kCodecStatusReg_Sense_Mask); } static void Burgundy_writeSoundControlReg( volatile UInt8 *ioBaseBurgundy, int value ) { DEBUG2_IOLOG( "PPCSound(burgundy): SoundControlReg = %08x\n", value); OSWriteLittleInt32( ioBaseBurgundy, kSoundCtlReg, value ); eieio(); } #define super AppleOnboardAudio OSDefineMetaClassAndStructors( AppleBurgundyAudio, AppleOnboardAudio ) /* ============== * Public Methods * ============== */ bool AppleBurgundyAudio::init(OSDictionary * properties) { DEBUG_IOLOG("+ AppleBurgundyAudio::init\n"); if (!super::init(properties)) return false; mVolLeft = 0; mVolRight = 0; mIsMute = false; mLogicalInput = 0; mVolumeMuteIsActive = false; mMuxMix = 0; DEBUG_IOLOG("- AppleBurgundyAudio::init\n"); return true; } void AppleBurgundyAudio::free() { DEBUG_IOLOG("+ AppleBurgundyAudio::free\n"); super::free(); DEBUG_IOLOG("- AppleBurgundyAudio::free\n"); } IOService* AppleBurgundyAudio::probe(IOService* provider, SInt32* score) { IORegistryEntry *sound = 0; IORegistryEntry *perch = 0; IOService *result = 0; // We CAN fail the type check: super::probe(provider, score); *score = kIODefaultProbeScore; // we may be on a Beige G3 perch = IORegistryEntry::fromPath("/perch", gIODTPlane); if(perch) { // there is a perch we are on a beige G3 OSData *s = NULL; s = OSDynamicCast(OSData, perch->getProperty("compatible")); if (s) { if(s->isEqualTo("burgundy", sizeof("burgundy")-1) || (s->isEqualTo("DVD-Video and Audio/Video", sizeof("DVD-Video and Audio/Video")-1)) || (s->isEqualTo("bordeaux", sizeof("bordeaux")-1))) { *score = *score+2; result = this; goto BAIL; } } } // we are on a new world : the registry is assumed to be fixed sound = provider->childFromPath("sound", gIODTPlane); if(sound) { OSData *tmpData; tmpData = OSDynamicCast(OSData, sound->getProperty(kModelPropName)); if(tmpData) { if(tmpData->isEqualTo(kBurgundyModelName, sizeof(kBurgundyModelName) -1) ) { *score = *score+1; result = this; goto BAIL; } } } BAIL: DEBUG_IOLOG("- AppleBurgundyAudio::probe\n"); return (result); } bool AppleBurgundyAudio::initHardware(IOService* provider) { // Gets the base for the burgundy registers: AbsoluteTime timerInterval; bool myreturn = true; DEBUG_IOLOG("+ AppleBurgundyAudio::initHardware\n"); super::initHardware(provider); gCanPollSatus = true; checkStatus(true); // flushAudioControls(); nanoseconds_to_absolutetime(NSEC_PER_SEC, &timerInterval); addTimerEvent(this, &AppleBurgundyAudio::timerCallback, timerInterval); // aml 6.17.02, burgundy internal mic is mono mInternalMicDualMonoMode = e_Mode_CopyRightToLeft; duringInitialization = false; DEBUG_IOLOG("- AppleBurgundyAudio::initHardware\n"); return myreturn; } void AppleBurgundyAudio::setDeviceDetectionActive(){ gCanPollSatus = true; } void AppleBurgundyAudio::setDeviceDetectionInActive(){ gCanPollSatus = false; } void AppleBurgundyAudio::timerCallback(OSObject *target, IOAudioDevice *device) { AppleBurgundyAudio *burgundy; burgundy = OSDynamicCast(AppleBurgundyAudio, target); if (burgundy) burgundy->checkStatus(false); } // -------------------------------------------------------------------------- // Method: checkStatusRegister // // Purpose: // if the argument is true mutes the internal speaker, otherwise // it "unmutes" it. void AppleBurgundyAudio::checkStatus(bool force) { UInt32 tempInSense, i; AudioHardwareDetect *theDetect; UInt32 mextdev; if(false == gCanPollSatus) return; mextdev = 0; tempInSense = sndHWGetInSenseBits(); if( (curInsense != tempInSense) || force) { curInsense = tempInSense; AudioDetects = super::getDetectArray(); if(AudioDetects) { for(i = 0; i < AudioDetects->getCount(); i++) { theDetect = OSDynamicCast(AudioHardwareDetect, AudioDetects->getObject(i)); if (theDetect) mextdev |= theDetect->refreshDevices(curInsense); } super::setCurrentDevices(mextdev); } } } #pragma mark -- sndHW METHODS -- // sndHWXXXXX functions void AppleBurgundyAudio::sndHWInitialize(IOService *provider){ IOMemoryMap *map; UInt32 idx, tmpReg; DEBUG_IOLOG("+ AppleBurgundyAudio::sndHWInitialize\n"); map = provider->mapDeviceMemoryWithIndex(AppleDBDMAAudioDMAEngine::kDBDMADeviceIndex); ioBaseBurgundy = (UInt8 *)map->getVirtualAddress(); if(!ioBaseBurgundy) debugIOLog("We have no mermory map !!!\n"); curInsense = 0xFFFF; // update local variables for the settling time for( idx = kBurgundyPhysOutputPort13-kBurgundyPhysOutputPort13; idx <= kBurgundyPhysOutputPort17-kBurgundyPhysOutputPort13; idx++ ){ localSettlingTime[idx] = 0; //this is an array of 5 stuff } // set the IO part sub frame 0 soundControlRegister = ( kSoundCtlReg_InSubFrame0 | \ kSoundCtlReg_OutSubFrame0 | \ kSoundCtlReg_Rate_44100 ); Burgundy_writeSoundControlReg(ioBaseBurgundy, soundControlRegister); //Verify we are on a Burgundy hardware by getting the type // Enable the programmable output // tmpReg = kOutputCtl0Reg_OutCtl0_High | kOutputCtl0Reg_OutCtl1_High; tmpReg = kOutputCtl0Reg_OutCtl1_High; Burgundy_writeCodecReg( ioBaseBurgundy, kOutputCtl0Reg,tmpReg); // tmpReg = kOutputCtl2Reg_OutCtl2_High | kOutputCtl2Reg_OutCtl3_High| kOutputCtl2Reg_OutCtl4_High; // Burgundy_writeCodecReg( ioBaseBurgundy, kOutputCtl2Reg,tmpReg); // Muxes configuration : Mux 0 has port 1, Mux 1 has port 3, Mux 2 has port 5 tmpReg =kBurgundyAMux_0SelPort_1; Burgundy_writeCodecReg( ioBaseBurgundy, kMux01Reg , tmpReg); // select input 6 for test on Yosemite tmpReg = kBurgundyAMux_2SelPort_5; Burgundy_writeCodecReg( ioBaseBurgundy, kMux2Reg , kMux2Reg_Mux2L_SelectPort6L|kMux2Reg_Mux2R_SelectPort6R); // configure the mixers : mixer0 has nothing, // mixer 1 has the input builtin signal, // mixer2 connect digital stream A Burgundy_writeCodecReg( ioBaseBurgundy, kMX0Reg, 0); mMuxMix = kBurgundyW_2_n; Burgundy_writeCodecReg( ioBaseBurgundy, kMX1Reg,kBurgundyW_2_n); // this for input selection Burgundy_writeCodecReg( ioBaseBurgundy, kMX2Reg, kBurgundyW_A_n); Burgundy_writeCodecReg( ioBaseBurgundy, kMX3Reg, 0); // apply the default gain 0xDF to mixer normalization Burgundy_writeCodecReg( ioBaseBurgundy, kMXEQ0LReg, kMXEQ_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kMXEQ0RReg, kMXEQ_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kMXEQ1LReg, kMXEQ_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kMXEQ1RReg, kMXEQ_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kMXEQ2LReg, kMXEQ_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kMXEQ2RReg, kMXEQ_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kMXEQ3LReg, kMXEQ_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kMXEQ3RReg, kMXEQ_Default_Gain ); // configure the ouput stream selection // OS_O listens to mixer 2, OS_1 listens to Mixer 2 ==> this goes to output // OS_E listen to mixer 1 this is the input Burgundy_writeCodecReg( ioBaseBurgundy, kOSReg, kBurgundyOS_0_MXO_2| kBurgundyOS_1_MXO_2 | kBurgundyOS_E_MXO_1); // set the amplification OS/AP Burgundy_writeCodecReg( ioBaseBurgundy, kGAP0LReg , 0xFF); Burgundy_writeCodecReg( ioBaseBurgundy, kGAP0RReg , 0xFF); Burgundy_writeCodecReg( ioBaseBurgundy, kGAP1RReg , 0xFF); Burgundy_writeCodecReg( ioBaseBurgundy, kGAP1LReg , 0xFF); Burgundy_writeCodecReg( ioBaseBurgundy, kGAP2LReg , 0xFF); Burgundy_writeCodecReg( ioBaseBurgundy, kGAP2RReg , 0xFF); Burgundy_writeCodecReg( ioBaseBurgundy, kGAP3LReg , 0xFF); Burgundy_writeCodecReg( ioBaseBurgundy, kGAP3RReg , 0xFF); // Mute everything Burgundy_writeCodecReg(ioBaseBurgundy, kOutputMuteReg, 0x00); // prepare the output amplification Burgundy_writeCodecReg( ioBaseBurgundy, kOutputLvlPort14Reg, 0); Burgundy_writeCodecReg( ioBaseBurgundy, kOutputLvlPort15Reg, 0); Burgundy_writeCodecReg( ioBaseBurgundy, kOutputLvlPort16Reg, 0); Burgundy_writeCodecReg( ioBaseBurgundy, kOutputLvlPort17Reg, 0); // set up the gains : // Unity to gain and Pain 0 Burgundy_writeCodecReg( ioBaseBurgundy, kGAS0LReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS0LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS0RReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS0RReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS1LReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS1LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS1RReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS1RReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS2LReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS2LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS2RReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS2RReg,0); // Set up modem to unity Burgundy_writeCodecReg( ioBaseBurgundy, kGAS3LReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS3RReg,0xDF); // Set up PCMCIA to unity Burgundy_writeCodecReg( ioBaseBurgundy, kGAS4LReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS4RReg,0xDF); // Default gain for all digital input Burgundy_writeCodecReg( ioBaseBurgundy, kGASALReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASARReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASBLReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASBRReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASCLReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASCRReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASDLReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASDRReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASELReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASERReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASFLReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASFRReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASGLReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASGRReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASHLReg, kGAS_Default_Gain ); Burgundy_writeCodecReg( ioBaseBurgundy, kGASHRReg, kGAS_Default_Gain ); // set analog gain on input to 0 Burgundy_writeCodecReg( ioBaseBurgundy, kVGA0Reg, 0); Burgundy_writeCodecReg( ioBaseBurgundy, kVGA1Reg, 0); Burgundy_writeCodecReg( ioBaseBurgundy, kVGA2Reg, 0); Burgundy_writeCodecReg( ioBaseBurgundy, kVGA3Reg, 0); // enable digital output driver OS_E on subframe 0 Burgundy_writeCodecReg( ioBaseBurgundy, kSDInReg, 0 ); Burgundy_writeCodecReg( ioBaseBurgundy, kSDInReg2, kBurgundyOS_EOutputEnable ); DEBUG_IOLOG("- AppleBurgundyAudio::sndHWInitialize\n"); } void AppleBurgundyAudio::sndHWPostDMAEngineInit (IOService *provider) { if (NULL != driverDMAEngine) driverDMAEngine->setSampleLatencies (kBurgundySampleLatency, kBurgundySampleLatency); } UInt32 AppleBurgundyAudio::sndHWGetInSenseBits(){ UInt32 status, inSense; inSense = 0; // we need to add the parrallel input part status = Burgundy_readCodecSenseLines(ioBaseBurgundy) & kBurgundyInSenseMask; if(status & kBurgundyInSense0) inSense |= kBurgundyInSense3; if(status & kBurgundyInSense1) inSense |= kBurgundyInSense2; if(status & kBurgundyInSense2) inSense |= kBurgundyInSense1; if(status & kBurgundyInSense3) inSense |= kBurgundyInSense0; return(inSense); } UInt32 AppleBurgundyAudio::sndHWGetRegister(UInt32 regNum){ return(CodecControlRegister[regNum]); } IOReturn AppleBurgundyAudio::sndHWSetRegister(UInt32 regNum, UInt32 value){ UInt32 result = 0; return(result); } UInt32 AppleBurgundyAudio::sndHWGetConnectedDevices(void){ return(super::getCurrentDevices()); } /************************** Manipulation of input and outputs ***********************/ /********(These functions are enough to implement the simple UI policy)**************/ UInt32 AppleBurgundyAudio::sndHWGetActiveOutputExclusive(void){ UInt32 result = 0; return(result); } IOReturn AppleBurgundyAudio::sndHWSetActiveOutputExclusive(UInt32 outputPort ){ IOReturn result= kIOReturnSuccess; UInt32 physicalPort, tempOutputReg; UInt32 logicalOutputPort; logicalOutputPort = outputPort; if( logicalOutputPort > kSndHWOutput5) return(kIOReturnError); physicalPort = GetPhysicalOutputPort(logicalOutputPort); tempOutputReg = kBurgundyMuteAll; mModemActive = FALSE; mInternalSpeakerActive = FALSE; mExternalSpeakerActive = FALSE; mHeadphonesActive = FALSE; mMonoSpeakerActive = FALSE; switch(physicalPort) { case kBurgundyPhysOutputPortNone: DEBUG_IOLOG(" ++ Writing Port None\n"); break; case kBurgundyPhysOutputPort13: DEBUG_IOLOG(" ++ Writing Port 13\n"); mModemActive = TRUE; tempOutputReg |= ( kBurgundyMuteOffState << kBurgundyPort13MonoMute); break; case kBurgundyPhysOutputPort14: DEBUG_IOLOG(" ++ Writing Port 14\n"); mInternalSpeakerActive = TRUE; tempOutputReg |= (( kBurgundyMuteOffState << kBurgundyPort14LMute) | ( kBurgundyMuteOffState << kBurgundyPort14RMute)); break; case kBurgundyPhysOutputPort15: DEBUG_IOLOG(" ++ Writing Port 15\n"); mExternalSpeakerActive = TRUE; tempOutputReg |= (( kBurgundyMuteOffState << kBurgundyPort15LMute) | ( kBurgundyMuteOffState << kBurgundyPort15RMute)); break; case kBurgundyPhysOutputPort16: DEBUG_IOLOG(" ++ Writing Port 16\n"); mHeadphonesActive = TRUE; tempOutputReg |= (( kBurgundyMuteOffState << kBurgundyPort16LMute) | ( kBurgundyMuteOffState << kBurgundyPort16RMute)); break; case kBurgundyPhysOutputPort17: DEBUG_IOLOG(" ++ Writing Port 17\n"); mMonoSpeakerActive = TRUE; tempOutputReg |= ( kBurgundyMuteOffState << kBurgundyPort17MonoMute); break; } Burgundy_writeCodecReg (ioBaseBurgundy, kOutputMuteReg, tempOutputReg); return(result); } UInt32 AppleBurgundyAudio::sndHWGetActiveInputExclusive(void){ UInt32 result = mLogicalInput; return(result); } IOReturn AppleBurgundyAudio::sndHWSetActiveInputExclusive(UInt32 input ){ UInt32 physicalInput , curPhysicalInput, tmpReg; UInt8 muxToBe, curMux; DEBUG2_IOLOG(" + AppleBurgundyAudio::sndHWSetActiveInputExclusive : %lu\n", input); IOReturn result= kIOReturnSuccess; tmpReg = 0; if(mLogicalInput != input) { physicalInput = GetPhysicalInputPort(input ); curPhysicalInput = GetPhysicalInputPort( mLogicalInput ); curMux = GetInputMux(curPhysicalInput); muxToBe = GetInputMux(physicalInput); // first we disconnect the first input from the mixer 1; // - get the mux of the input // - putting the input analog gain to 0 // - putting the digital gain to 0dB // - disconnecting the input from the mixer one if( 0!= curPhysicalInput) { switch( curMux ) { case kBurgundyMux0: Burgundy_writeCodecReg( ioBaseBurgundy, kGAS0LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS0LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS0RReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS0RReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kVGA0Reg, 0); Burgundy_writeCodecReg( ioBaseBurgundy, kMX1Reg, 0); break; case kBurgundyMux1: Burgundy_writeCodecReg( ioBaseBurgundy, kGAS1LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS1LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS1RReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS1RReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kVGA1Reg, 0); Burgundy_writeCodecReg( ioBaseBurgundy, kMX1Reg,0); break; // fall through case kBurgundyMux2: Burgundy_writeCodecReg( ioBaseBurgundy, kGAS2LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS2LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS2RReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS2RReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kVGA2Reg, 0); Burgundy_writeCodecReg( ioBaseBurgundy, kMX1Reg, 0); break; // fall through default: break; } } // select the mux // reactivate the digital gain : // put the input to mixer 1 if( physicalInput != kBurgundyPhysInputPortNone ) { switch( muxToBe ) { case kBurgundyMux0: Burgundy_writeCodecReg( ioBaseBurgundy, kGAS0LReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS0LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS0RReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS0RReg,0); // select the mux switch(physicalInput) { case kBurgundyPhysInputPort1: tmpReg =kBurgundyAMux_0SelPort_1; break; case kBurgundyPhysInputPort2: tmpReg =kBurgundyAMux_0SelPort_2; break; case kBurgundyPhysInputPort3: tmpReg =kBurgundyAMux_0SelPort_3; break; } Burgundy_writeCodecReg( ioBaseBurgundy, kMux01Reg , tmpReg); // connect the mux tp the mixer mMuxMix = kBurgundyW_0_n; Burgundy_writeCodecReg( ioBaseBurgundy, kMX1Reg,mMuxMix); break; case kBurgundyMux1: Burgundy_writeCodecReg( ioBaseBurgundy, kGAS1LReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS1LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS1RReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS1RReg,0); switch(physicalInput) { case kBurgundyPhysInputPort4: tmpReg = kBurgundyAMux_1SelPort_4; break; case kBurgundyPhysInputPort5: tmpReg = kBurgundyAMux_1SelPort_5; break; } Burgundy_writeCodecReg( ioBaseBurgundy, kMux01Reg , tmpReg); mMuxMix = kBurgundyW_1_n; Burgundy_writeCodecReg( ioBaseBurgundy, kMX1Reg,mMuxMix); break; case kBurgundyMux2: Burgundy_writeCodecReg( ioBaseBurgundy, kGAS2LReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS2LReg,0); Burgundy_writeCodecReg( ioBaseBurgundy, kGAS2RReg,0xDF); Burgundy_writeCodecReg( ioBaseBurgundy, kPAS2RReg,0); switch(physicalInput) { case kBurgundyPhysInputPort6: tmpReg = kBurgundyAMux_2SelPort_6; break; case kBurgundyPhysInputPort7: tmpReg = kBurgundyAMux_2SelPort_7; break; } Burgundy_writeCodecReg( ioBaseBurgundy, kMux2Reg , tmpReg); mMuxMix = kBurgundyW_2_n; Burgundy_writeCodecReg( ioBaseBurgundy, kMX1Reg,mMuxMix); break; default: break; } } mLogicalInput = input; // keep track of our new current active input for this system } DEBUG_IOLOG(" - AppleBurgundyAudio::sndHWSetActiveInputExclusive"); return(result); } UInt32 AppleBurgundyAudio::sndHWGetProgOutput(){ UInt32 result = 0, outputConfigPins; outputConfigPins = 0; // just to quiet the warning in the compiler // outputConfigPins = Burgundy_readCodecReg( ioBaseBurgundy, kOutputCtl0Reg); result |= ( outputConfigPins & kBurgundyOut_Ctrl_0State ) ? kSndHWProgOutput0 : 0; result |= ( outputConfigPins & kBurgundyOut_Ctrl_1State ) ? kSndHWProgOutput1 : 0; // outputConfigPins = Burgundy_readCodecReg( ioBaseBurgundy, kOutputCtl2Reg); result |= ( outputConfigPins & kBurgundyOut_Ctrl_2State ) ? kSndHWProgOutput2 : 0; result |= ( outputConfigPins & kBurgundyOut_Ctrl_3State ) ? kSndHWProgOutput3 : 0; result |= ( outputConfigPins & kBurgundyOut_Ctrl_4State ) ? kSndHWProgOutput4 : 0; return(result); } IOReturn AppleBurgundyAudio::sndHWSetProgOutput(UInt32 outputBits){ IOReturn result= kIOReturnSuccess; UInt32 outputConfigPins; outputConfigPins = 0; if( outputBits & ( kSndHWProgOutput0 ) ) outputConfigPins |= kBurgundyOut_Ctrl_0State; if( outputBits & ( kSndHWProgOutput1 ) ) outputConfigPins |= kBurgundyOut_Ctrl_1State; // Burgundy_writeCodecReg( ioBaseBurgundy, kOutputCtl0Reg, outputConfigPins); outputConfigPins = 0; if( outputBits & ( kSndHWProgOutput2 ) ) outputConfigPins |= kBurgundyOut_Ctrl_2State; if( outputBits & ( kSndHWProgOutput3 ) ) outputConfigPins |= kBurgundyOut_Ctrl_3State; if( outputBits & ( kSndHWProgOutput4 ) ) outputConfigPins |= kBurgundyOut_Ctrl_4State; // Burgundy_writeCodecReg( ioBaseBurgundy, kOutputCtl2Reg,outputConfigPins); return(result); } // control function bool AppleBurgundyAudio::sndHWGetSystemMute(void){ return (mIsMute); } IOReturn AppleBurgundyAudio::sndHWSetSystemMute (bool mutestate){ IOReturn result = kIOReturnSuccess; UInt32 mutes; mutes = 0; // mute everything and keep the compiler happy if (mutestate != mIsMute) { mIsMute = mutestate; if (mutestate) { // we are muting. We do it by disconnecting the output from the mixer // we let only the OS_E stream for the sound input. Ther may be other // possibilities // Burgundy_writeCodecReg( ioBaseBurgundy, kOSReg, kBurgundyOS_E_MXO_1); // Mute all the amps mutestate = kBurgundyMuteAll; } else { // we reconnect everything // Burgundy_writeCodecReg( ioBaseBurgundy, kOSReg, kBurgundyOS_0_MXO_2| kBurgundyOS_1_MXO_2 | kBurgundyOS_E_MXO_1); // Set the volume to the correct volume as it might have been changed while we were muted sndHWSetSystemVolume (gVolLeft, gVolRight); // Unmute the amp currently in use if (TRUE == mModemActive) { mutes = kBurgundyMuteOffState << kBurgundyPort13MonoMute; } else if (TRUE == mInternalSpeakerActive) { mutes = kBurgundyMuteOffState << kBurgundyPort14LMute | kBurgundyMuteOffState << kBurgundyPort14RMute; } else if (TRUE == mExternalSpeakerActive) { mutes = kBurgundyMuteOffState << kBurgundyPort15LMute | kBurgundyMuteOffState << kBurgundyPort15RMute; } else if (TRUE == mHeadphonesActive) { mutes = kBurgundyMuteOffState << kBurgundyPort16LMute | kBurgundyMuteOffState << kBurgundyPort16RMute; } else if (TRUE == mMonoSpeakerActive) { mutes = kBurgundyMuteOffState << kBurgundyPort17MonoMute; } } Burgundy_writeCodecReg (ioBaseBurgundy, kOutputMuteReg, mutes); } return (result); } bool AppleBurgundyAudio::sndHWSetSystemVolume(UInt32 leftVolume, UInt32 rightVolume){ UInt8 leftAttn, rightAttn; UInt8 comAttn; UInt32 tLeftVolume, tRightVolume; // mVolLeft and leftVolume between 0 and 16 if (leftVolume != mVolLeft) mVolLeft = leftVolume; tLeftVolume = mVolLeft; if (0 == tLeftVolume) tLeftVolume = 1; // leftVolume between 1 and 16 tLeftVolume -= 1; // leftVolume between 0 and 15 leftAttn = 15 - (UInt8) tLeftVolume; // leftAttn between 15 and 0 if (rightVolume != mVolRight) mVolRight = rightVolume; tRightVolume = mVolRight; if (0 == tRightVolume) tRightVolume = 1; tRightVolume -= 1; rightAttn = 15 - (UInt8) tRightVolume; // rightAttn between 15 and 0 UInt32 muteStates; muteStates = Burgundy_readCodecReg (ioBaseBurgundy, kOutputMuteReg); if (mVolLeft == 0) { // Mute headphone and speaker because volume is 0 muteStates &= ~(kOutputMuteReg_Port14L | kOutputMuteReg_Port16L); } else { // Mute either the headphone or the speaker, depending on which we're not using if (TRUE == mInternalSpeakerActive) { muteStates |= kBurgundyMuteOffState << kBurgundyPort14LMute; } else if (TRUE == mHeadphonesActive) { muteStates |= kBurgundyMuteOffState << kBurgundyPort16LMute; } } if (mVolRight == 0) { // Mute headphone and speaker because volume is 0 muteStates &= ~(kOutputMuteReg_Port14R | kOutputMuteReg_Port16R); } else { // Mute either the headphone or the speaker, depending on which we're not using if (TRUE == mInternalSpeakerActive) { muteStates |= kBurgundyMuteOffState << kBurgundyPort14RMute; } else if (TRUE == mHeadphonesActive) { muteStates |= kBurgundyMuteOffState << kBurgundyPort16RMute; } } Burgundy_writeCodecReg (ioBaseBurgundy, kOutputMuteReg, muteStates); if ((mVolLeft == 0) && (mVolRight == 0)) { mVolumeMuteIsActive = TRUE; } else { mVolumeMuteIsActive = FALSE; } #if 0 if ((mVolLeft == 0) && (mVolRight == 0)) { mVolumeMuteIsActive = true; Burgundy_writeCodecReg (ioBaseBurgundy, kGAP0LReg , 0x00); Burgundy_writeCodecReg (ioBaseBurgundy, kGAP0RReg , 0x00); Burgundy_writeCodecReg (ioBaseBurgundy, kGAP1RReg , 0x00); Burgundy_writeCodecReg (ioBaseBurgundy, kGAP1LReg , 0x00); } else { // we should do it better to mute one channel only to have a good balance if (mVolumeMuteIsActive) { // we do it only if we come back from noting mVolumeMuteIsActive = false; Burgundy_writeCodecReg (ioBaseBurgundy, kGAP0LReg , 0xFF); Burgundy_writeCodecReg (ioBaseBurgundy, kGAP0RReg , 0xFF); Burgundy_writeCodecReg (ioBaseBurgundy, kGAP1RReg , 0xFF); Burgundy_writeCodecReg (ioBaseBurgundy, kGAP1LReg , 0xFF); } } #endif comAttn = rightAttn << 4 | leftAttn; Burgundy_writeCodecReg (ioBaseBurgundy, kOutputLvlPort13Reg, comAttn & 0x0F); Burgundy_writeCodecReg (ioBaseBurgundy, kOutputLvlPort14Reg, comAttn); Burgundy_writeCodecReg (ioBaseBurgundy, kOutputLvlPort15Reg, comAttn); Burgundy_writeCodecReg (ioBaseBurgundy, kOutputLvlPort16Reg, comAttn); Burgundy_writeCodecReg (ioBaseBurgundy, kOutputLvlPort17Reg, comAttn & 0x0F); bool result = true; return(result); } IOReturn AppleBurgundyAudio::sndHWSetSystemVolume(UInt32 value){ IOReturn result= kIOReturnSuccess; sndHWSetSystemVolume(value, value); return(result); } IOReturn AppleBurgundyAudio::sndHWSetSystemInputGain(UInt32 leftGain, UInt32 rightGain){ IOReturn myReturn = kIOReturnSuccess; UInt32 totGain; UInt8 galeft, garight; DEBUG3_IOLOG("+ AppleBurgundyAudio::sndHWSetSystemInputGain (%ld, %ld)\n", leftGain, rightGain); totGain = 0; galeft = (UInt8) leftGain; garight = (UInt8) rightGain; totGain |= galeft; totGain |= (garight <<4); Burgundy_writeCodecReg( ioBaseBurgundy, kVGA0Reg, totGain ); Burgundy_writeCodecReg( ioBaseBurgundy, kVGA1Reg, totGain ); Burgundy_writeCodecReg( ioBaseBurgundy, kVGA2Reg, totGain ); Burgundy_writeCodecReg( ioBaseBurgundy, kVGA3Reg, leftGain ); DEBUG_IOLOG("- AppleBurgundyAudio::sndHWSetSystemInputGain\n"); return(myReturn); } IOReturn AppleBurgundyAudio::sndHWSetPlayThrough(bool playthroughstate){ IOReturn result= kIOReturnSuccess; DEBUG_IOLOG("+ AppleBurgundyAudio::sndHWSetPlayThrough\n"); if(playthroughstate) Burgundy_writeCodecReg( ioBaseBurgundy, kMX2Reg, mMuxMix | kBurgundyW_A_n); else Burgundy_writeCodecReg( ioBaseBurgundy, kMX2Reg, kBurgundyW_A_n); DEBUG_IOLOG("- AppleBurgundyAudio::sndHWSetPlayThrough\n"); return(result); } // Power Management IOReturn AppleBurgundyAudio::sndHWSetPowerState ( IOAudioDevicePowerState theState ) { IOReturn myReturn; DEBUG_IOLOG("+ AppleBurgundyAudio::sndHWSetPowerState\n"); myReturn = kIOReturnSuccess; switch ( theState ) { case kIOAudioDeviceSleep: myReturn = performDeviceIdleSleep(); break; // When sleeping case kIOAudioDeviceIdle: myReturn = performDeviceSleep(); break; // When no audio engines running case kIOAudioDeviceActive: myReturn = performDeviceWake(); break; // audio engines running default: DEBUG_IOLOG("AppleDACAAudio::sndHWSetPowerState unknown power state\n"); myReturn = kIOReturnBadArgument ; break ; } DEBUG_IOLOG("- AppleBurgundyAudio::sndHWSetPowerState\n"); return ( myReturn ); } // -------------------------------------------------------------------------- IOReturn AppleBurgundyAudio::performDeviceWake () { DEBUG_IOLOG("+ AppleBurgundyAudio::performDeviceWake\n"); DEBUG_IOLOG("- AppleBurgundyAudio::performDeviceWake\n"); return ( kIOReturnSuccess ); } // -------------------------------------------------------------------------- IOReturn AppleBurgundyAudio::performDeviceSleep () { DEBUG_IOLOG("+ AppleBurgundyAudio::performDeviceSleep\n"); DEBUG_IOLOG("- AppleBurgundyAudio::performDeviceSleep\n"); return ( kIOReturnSuccess ); } // -------------------------------------------------------------------------- IOReturn AppleBurgundyAudio::performDeviceIdleSleep () { DEBUG_IOLOG("+ AppleBurgundyAudio::performDeviceIdleSleep\n"); DEBUG_IOLOG("- AppleBurgundyAudio::performDeviceIdleSleep\n"); return ( kIOReturnSuccess ); } // Identification UInt32 AppleBurgundyAudio::sndHWGetType( void ){ UInt32 result; DEBUG_IOLOG("+ AppleBurgundyAudio::sndHWGetType\n"); result = 0; DEBUG_IOLOG("- AppleBurgundyAudio::sndHWGetType\n"); return(result); } UInt32 AppleBurgundyAudio::sndHWGetManufacturer( void ){ UInt32 result, info; DEBUG_IOLOG("+ AppleBurgundyAudio::sndHWGetManufacturer\n"); info = sndHWGetRegister(kBurgundyIDReg); switch (info & kBurgundySiliconVendor){ case kBurgundyManfCrystal: result = kSndHWManfCrystal; break; case kBurgundyManfTI: result = kSndHWManfTI; break; default: result = kSndHWManfUnknown; break; } DEBUG_IOLOG("- AppleBurgundyAudio::sndHWGetManufacturer\n"); return(result); } #pragma mark -- BURGUNDY SPECIFIC -- //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // This routine will disconnect an input sample stream (i.e. MUX) from // ALL mixers. Argument "mixer" is a bit mapped enable of the mixer // sources to be disconnected from an input stream as follows: // // kBurgundyW_0_n mux_0 ports 1, 2 & 3 built-in // kBurgundyW_1_n mux_1 ports 4 & 5 built-in // kBurgundyW_2_n mux_2 ports 6 & 7 built-in // kBurgundyW_3_n mux_3 port 8 telephony modem record // kBurgundyW_4_n mux_4 port 9 pcmcia // kBurgundyW_A_n subframe 0 built-in digital play // kBurgundyW_B_n subframe 1 telephony digital play void AppleBurgundyAudio::DisconnectMixer(UInt32 mixer) { UInt32 temp; temp = Burgundy_readCodecReg( ioBaseBurgundy, kMX0Reg); temp &= ~mixer; temp |= kBurgundyW_A_n; Burgundy_writeCodecReg( ioBaseBurgundy, kMX0Reg, temp); // playthrough path always gets digital stream Burgundy_writeCodecReg( ioBaseBurgundy, kMX2Reg, temp); // ext. speaker/line out is a mirror image of play path temp = Burgundy_readCodecReg( ioBaseBurgundy, kMX1Reg); // disconnect input from recording input stream temp &= ~mixer; Burgundy_writeCodecReg( ioBaseBurgundy, kMX1Reg, temp); } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ UInt32 AppleBurgundyAudio::GetPhysicalInputPort( UInt32 logicalPort ) { UInt32 physicalPort; physicalPort = kBurgundyPhysInputPortIllegal; switch( logicalPort ){ case kSndHWInputNone: physicalPort = kBurgundyPhysInputPortNone; break; case kSndHWInput1: physicalPort = kBurgundyPhysInputPort1; break; case kSndHWInput2: physicalPort = kBurgundyPhysInputPort2; break; case kSndHWInput3: physicalPort = kBurgundyPhysInputPort3; break; case kSndHWInput4: physicalPort = kBurgundyPhysInputPort4; break; case kSndHWInput5: physicalPort = kBurgundyPhysInputPort5; break; case kSndHWInput6: physicalPort = kBurgundyPhysInputPort6; break; case kSndHWInput7: physicalPort = kBurgundyPhysInputPort7; break; case kSndHWInput8: physicalPort = kBurgundyPhysInputPort8; break; case kSndHWInput9: physicalPort = kBurgundyPhysInputPort9; break; } return physicalPort; } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ UInt32 AppleBurgundyAudio::GetPhysicalOutputPort(UInt32 logicalPort ) { UInt32 physicalPort; physicalPort = kBurgundyPhysOutputPortIllegal; switch( logicalPort ) { case kSndHWOutputNone: physicalPort = kBurgundyPhysOutputPortNone; break; case kSndHWOutput1: physicalPort = kBurgundyPhysOutputPort14; break; case kSndHWOutput2: physicalPort = kBurgundyPhysOutputPort15; break; case kSndHWOutput3: physicalPort = kBurgundyPhysOutputPort16; break; case kSndHWOutput4: physicalPort = kBurgundyPhysOutputPort17; break; case kSndHWOutput5: physicalPort = kBurgundyPhysOutputPort13; break; } return physicalPort; } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Returns the port configuration so that maximum gain can be determined. // // DIGITAL ONLY: 9 // ANALOG & DIGITAL: 1 2 3 4 8 // PREAMP, ANALOG & DIGITAL: 5 6 7 UInt32 AppleBurgundyAudio::GetInputPortType(UInt32 inputPhysicalPort){ UInt32 result; switch( inputPhysicalPort ) { case kBurgundyPhysInputPort1: // fallthrough case kBurgundyPhysInputPort2: // fallthrough case kBurgundyPhysInputPort3: // fallthrough case kBurgundyPhysInputPort4: // fallthrough case kBurgundyPhysInputPort8: result = kBurgundyPortType_AD; break; case kBurgundyPhysInputPort5: // fallthrough case kBurgundyPhysInputPort6: // fallthrough case kBurgundyPhysInputPort7: result = kBurgundyPortType_AAD; break; case kBurgundyPhysInputPort9: result = kBurgundyPortType_D; break; case kBurgundyPhysInputPortNone: // fallthrough default: result = kBurgundyPortType_NONE; break; } return result; } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Several of the analog inputs are available as in input selection to // more than one mux. This routine determines which mux is the primary // destination for a specific input source. For inputs that have more // than one possible destination, the primary source is the lower orderd // destination multiplexer. UInt8 AppleBurgundyAudio::GetInputMux(UInt32 physicalInput){ UInt8 theMux; if( physicalInput > kSndHWInput9) { theMux = kBurgundyMuxNone; goto Exit; } switch( physicalInput ){ case kBurgundyPhysInputPort1: // fall through (port 1, 2 & 3 share the same mux) case kBurgundyPhysInputPort2: // fall through (port 1, 2 & 3 share the same mux) case kBurgundyPhysInputPort3: theMux = kBurgundyMux0; break; case kBurgundyPhysInputPort4: // fall through (port 4 & 5 share the same mux) case kBurgundyPhysInputPort5: theMux = kBurgundyMux1; break; case kBurgundyPhysInputPort6: // fall through (port 6 & 7 share the same mux) case kBurgundyPhysInputPort7: theMux = kBurgundyMux2; break; case kBurgundyPhysInputPort8: theMux = kBurgundyMux3; break; case kBurgundyPhysInputPort9: theMux = kBurgundyMux4; break; case kBurgundyPhysInputPortNone: theMux = kBurgundyMuxNone; break; } Exit: return theMux; } void AppleBurgundyAudio::ReleaseMux(UInt8 mux){ // __SndHWSetPan( system, kMinSoftwareGain, kMinSoftwareGain ); UInt32 temp; temp = 0; switch( mux ){ case kBurgundyMux0: temp = kBurgundyW_0_n; break; // prepare to disconnect the mux 0 from mixer 'n' connection case kBurgundyMux1: temp = kBurgundyW_1_n; break; // prepare to disconnect the mux 1 from mixer 'n' connection case kBurgundyMux2: temp = kBurgundyW_2_n; break; // prepare to disconnect the mux 2 from mixer 'n' connection case kBurgundyMux4: temp = kBurgundyW_4_n; break; // prepare to disconnect the mux 4 from mixer 'n' connection } // disconnect the mux to mixer connection DisconnectMixer( temp ); // // gGlobals->muxReservation[mux] = kSndHWInputNone; } void AppleBurgundyAudio::ReserveMux(UInt8 mux, UInt32 physicalInput){ } IOReturn AppleBurgundyAudio::setModemSound(bool state) { IOReturn myReturn = kIOReturnSuccess; debug2IOLog ("+ AppleBurgundyAudio::setModemSound(%d)\n", state); // make sure that the imic is not enabled when playthrough is turned on -- there will be no FEEDBACK!!! if(TRUE == state) { gIsModemSoundActive = true; Burgundy_writeCodecReg( ioBaseBurgundy, kMX2Reg, kBurgundyW_3_n | kBurgundyW_A_n ); } else { Burgundy_writeCodecReg( ioBaseBurgundy, kMX2Reg, kBurgundyW_A_n); super::setModemSound(state); } debug2IOLog ("- AppleBurgundyAudio::setModemSound(%d)\n", state); return(myReturn); }