![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to PPCDACA.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / audio / drvPPCDACA|
Return to PPCDACA.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / audio / drvPPCDACA |
1.1 ! root 1: /* ! 2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * Copyright (c) 1998 Apple Computer, Inc. All rights reserved. ! 24: * ! 25: * Interface implementation for the DAC 3550A audio Controller ! 26: * ! 27: * HISTORY ! 28: * ! 29: * ! 30: */ ! 31: ! 32: #include <IOKit/assert.h> ! 33: #include <IOKit/system.h> ! 34: ! 35: #include <IOKit/IOLib.h> ! 36: #include <IOKit/IODeviceTreeSupport.h> ! 37: #include <IOKit/IOPlatformExpert.h> ! 38: #include <IOKit/ppc/IODBDMA.h> ! 39: ! 40: // Driver headers ! 41: #include "daca_hw.h" ! 42: #include "PPCDACA_inlined.h" ! 43: #include "PPCDACA.h" ! 44: ! 45: #define super IOAudioBus ! 46: OSDefineMetaClassAndStructors( PPCDACA, IOAudioBus ) ! 47: ! 48: /* ============== ! 49: * Public Methods ! 50: * ============== */ ! 51: bool ! 52: PPCDACA::init(OSDictionary * properties) ! 53: { ! 54: if (!super::init(properties)) ! 55: return false; ! 56: ! 57: // Nulls the pointers for the arrays we allocate: ! 58: fOutputComponents = NULL; ! 59: numOutputComponents = NULL; ! 60: ! 61: // Initialize the defualt registers to non zero values (so they will be revitten) ! 62: sampleRateReg = 0xFF; ! 63: analogVolumeReg = kPowerOnDefaultAVOL; ! 64: configurationReg = 0xFF; ! 65: ! 66: // Mirror the analogVolumeReg for the speaker and for the headphones. ! 67: internalSpeakerVolume = analogVolumeReg; ! 68: internalHeadphonesVolume = analogVolumeReg; ! 69: ! 70: // Last value of the status is 0 ! 71: lastStatus = 0; ! 72: ! 73: // Clears the interface ! 74: interface = NULL; ! 75: ! 76: // Forget the provider: ! 77: sound = NULL; ! 78: ! 79: // Initialize the sound format: ! 80: dacaSerialFormat = kSndIOFormatUnknown; ! 81: ! 82: return true; ! 83: } ! 84: ! 85: void ! 86: PPCDACA::free() ! 87: { ! 88: // Releases the sound: ! 89: if(sound != NULL) ! 90: sound->release(); ! 91: sound = NULL; ! 92: ! 93: super::free(); ! 94: } ! 95: ! 96: IOService* ! 97: PPCDACA::probe(IOService* provider, SInt32* score) ! 98: { ! 99: // Finds the possible candidate for sound, to be used in ! 100: // reading the caracteristics of this hardware: ! 101: IORegistryEntry *soundCandidate = provider->childFromPath("sound", gIODTPlane); ! 102: ! 103: if (super::probe(provider, score) && implementsDACA(soundCandidate)) { ! 104: #ifdef DEBUGMODE ! 105: IOLog("PPCDACA::probe we are on a PPCDACA device !!\n"); ! 106: #endif // DEBUGMODE ! 107: ! 108: // we did not fail: ! 109: *score = kIODefaultProbeScore; ! 110: sound = soundCandidate; ! 111: return this; ! 112: } ! 113: ! 114: return (NULL); ! 115: } ! 116: ! 117: #define kNumDMAStreams 1 ! 118: bool ! 119: PPCDACA::start(IOService* provider) ! 120: { ! 121: // Gets the base for the DAC-3550 registers: ! 122: IOMemoryMap *map; ! 123: int i; ! 124: ! 125: #ifdef DEBUGMODE ! 126: // Delay for 30 seconds so we have the time to attach the debugger and look at ! 127: // what is going on here (only if DEBUGMODE of course). ! 128: IOLog("Starting DAC-3550 with provider %s ...", provider->getName()); ! 129: IOSleep(30 * 1000); ! 130: IOLog("...\n"); ! 131: #endif // DEBUGMODE ! 132: ! 133: if(!super::start(provider)) { ! 134: #ifdef DEBUGMODE ! 135: IOLog("PPCDACA::start if(!super::start(provider)) fails !!\n"); ! 136: #endif // DEBUGMODE ! 137: return (false); ! 138: } ! 139: ! 140: if (!findAndAttachI2C(provider)) { ! 141: #ifdef DEBUGMODE ! 142: IOLog("PPCDACA::start if (!findAndAttachI2C(IOService *provider)) fails !!\n"); ! 143: #endif // DEBUGMODE ! 144: return (false); ! 145: } ! 146: ! 147: map = provider->mapDeviceMemoryWithIndex(kAudioDMAdeviceInt); ! 148: if(!map) { ! 149: #ifdef DEBUGMODE ! 150: IOLog("PPCDACA::start if(!map) %d fails !!\n",kAudioDMAdeviceInt); ! 151: #endif // DEBUGMODE ! 152: return (false); ! 153: } ! 154: soundConfigSpace = (UInt8 *)map->getPhysicalAddress(); ! 155: ! 156: if (!AllocateStreams(kNumDMAStreams)) { ! 157: #ifdef DEBUGMODE ! 158: IOLog("PPCDACA::start if (!AllocateStreams(kNumDMAStreams)) fails !!\n"); ! 159: #endif // DEBUGMODE ! 160: return (false); ! 161: } ! 162: ! 163: map = provider->mapDeviceMemoryWithIndex(kAudioDMAtxInt); ! 164: if(!map) { ! 165: #ifdef DEBUGMODE ! 166: IOLog("PPCDACA::start if(!map) %d fails !!\n",kAudioDMAtxInt); ! 167: #endif // DEBUGMODE ! 168: return (false); ! 169: } ! 170: DefineStream(kAudioDMAOutputStream, kOutput, frameRate(0), (IODBDMAChannelRegisters*)map->getVirtualAddress()); ! 171: ! 172: // Creates the array of output components ! 173: numOutputComponents = numberOfInputComponents(); ! 174: ! 175: fOutputComponents = (IOAudioComponentImplPtr*)IOMalloc(sizeof(IOAudioComponentImplPtr) * numOutputComponents); ! 176: if (fOutputComponents == NULL) { ! 177: #ifdef DEBUGMODE ! 178: IOLog("PPCDACA::start if (fOutputComponents == NULL) fails !!\n"); ! 179: #endif // DEBUGMODE ! 180: ! 181: // Free the DMA and exit: ! 182: FreeStreams(); ! 183: return false; ! 184: } ! 185: ! 186: // Initalizes all the components: ! 187: for (i = 0; i < numOutputComponents; i++) ! 188: fOutputComponents[i] = NULL; ! 189: ! 190: // sets the clock base address figuring out which I2S cell we're on ! 191: if ((((UInt32)soundConfigSpace ^ kI2S0BaseOffset) & 0x0001FFFF) == 0) { ! 192: ioBaseAddress = (void *)((UInt32)soundConfigSpace - kI2S0BaseOffset); ! 193: i2SInterfaceNumber = 0; ! 194: } ! 195: else if ((((UInt32)soundConfigSpace ^ kI2S1BaseOffset) & 0x0001FFFF) == 0) { ! 196: ioBaseAddress = (void *)((UInt32)soundConfigSpace - kI2S1BaseOffset); ! 197: i2SInterfaceNumber = 1; ! 198: } ! 199: else { ! 200: IOLog("PPCDACA::start failed to setup ioBaseAddress and ioClockBaseAddress\n"); ! 201: } ! 202: ! 203: // This is the keylargo FC1 (Feature configuration 1) ! 204: ioClockBaseAddress = (void *)((UInt32)ioBaseAddress + kI2SClockOffset); ! 205: ! 206: // Finds the position of the status register: ! 207: ioStatusRegister_GPIO12 = (void *)((UInt32)ioBaseAddress + kGPio12); ! 208: ! 209: // Enables the I2S Interface: ! 210: KLSetRegister(ioClockBaseAddress, KLGetRegister(ioClockBaseAddress) | kI2S0InterfaceEnable); ! 211: ! 212: // Starts the workloop and exit since there is nothing we can be interested about anymore ! 213: startWorkLoop(); ! 214: ! 215: return true; ! 216: } ! 217: ! 218: void ! 219: PPCDACA::stop(IOService *provider) ! 220: { ! 221: // Releases all DMA streams: ! 222: FreeStreams(); ! 223: ! 224: // Releases the output components ! 225: if (fOutputComponents != NULL) { ! 226: IOFree(fOutputComponents, sizeof(IOAudioComponentImplPtr) * numOutputComponents); ! 227: fOutputComponents = NULL; ! 228: numOutputComponents = 0; ! 229: } ! 230: ! 231: // Call the parent stop: ! 232: super::stop(provider); ! 233: } ! 234: ! 235: void ! 236: PPCDACA::CreateAudioTopology(IOCommandQueue *queue) ! 237: { ! 238: IOAudioComponentImpl *mixerOut; ! 239: IOAudioComponentImpl *modem; ! 240: IOAudioComponentImpl *headphones; ! 241: IOAudioComponentImpl *cd; ! 242: IOAudioComponentImpl *speaker; ! 243: IOAudioComponentImpl *passthru; ! 244: ! 245: AudioStreamIndex outputStream; ! 246: ! 247: if (!fStreams) ! 248: return; ! 249: ! 250: outputStream = firstStreamAfter(kOutput, 0); ! 251: ! 252: if (outputStream == kInvalidStreamIndex) { ! 253: IOLog("PPCDACA::CreateAudioTopology called without available DMA streams\n"); ! 254: return; ! 255: } ! 256: else ! 257: IOLog("PPCDACA::CreateAudioTopology output stream is %d\n", outputStream); ! 258: ! 259: mixerOut = buildComponentAndAttach(GetStream(outputStream), NULL, componentDictionaryMixerOut(), queue); ! 260: headphones = buildComponentAndAttach(mixerOut, NULL, componentDictionaryHeadphones(), queue); ! 261: speaker = buildComponentAndAttach(mixerOut, NULL, componentDictionarySpeaker(), queue); ! 262: ! 263: cd = buildComponentAndAttach(NULL, NULL, componentDictionaryCD(), queue); ! 264: modem = buildComponentAndAttach(NULL, NULL, componentDictionaryModem(), queue); ! 265: ! 266: passthru = buildComponentAndAttach(NULL, mixerOut, componentDictionaryPassThru(), queue); ! 267: ! 268: // FIXME: the component connection could be done better than so ! 269: if (fOutputComponents != NULL) { ! 270: fOutputComponents[kSpeaker] = speaker; ! 271: ! 272: if (numOutputComponents > 1) ! 273: fOutputComponents[kHeadphones] = headphones; ! 274: } ! 275: ! 276: // Sets ups the DAC-3550 as required by this machine wiring ! 277: // configuration: ! 278: if (!dependentSetup()) ! 279: IOLog("PPCDACA::CreateAudioTopology DAC-3550 setup failed\n"); ! 280: } ! 281: ! 282: void ! 283: PPCDACA::DoClockTick(IOTimerEventSource *t) ! 284: { ! 285: checkStatusRegister(); ! 286: super::DoClockTick(t); ! 287: } ! 288: ! 289: void ! 290: PPCDACA::calculateTickInterval(AbsoluteTime *tickInterval) ! 291: { ! 292: AbsoluteTime maxInterval; ! 293: ! 294: // We want to check the status at least one a second ! 295: nanoseconds_to_absolutetime(NSEC_PER_SEC, &maxInterval); ! 296: if(CMP_ABSOLUTETIME(&maxInterval, tickInterval) < 0) { ! 297: *tickInterval = maxInterval; ! 298: } ! 299: super::calculateTickInterval(tickInterval); ! 300: } ! 301: ! 302: IOReturn ! 303: PPCDACA::SetControl(UInt16 id, int val) ! 304: { ! 305: IOReturn res = kIOReturnSuccess; ! 306: ! 307: switch(id) { ! 308: case kSpeakerMute: ! 309: muteInternalSpeaker(val != 0); ! 310: muteHeadphones(val == 0); ! 311: break; ! 312: ! 313: case kHeadphonesMute: ! 314: muteHeadphones(val != 0); ! 315: muteInternalSpeaker(val == 0); ! 316: break; ! 317: ! 318: case kModemMute: ! 319: setModemInput(val == 0); ! 320: break; ! 321: ! 322: case kSpeakerVolLeft: ! 323: volumeInternalSpeakerLeft(val); ! 324: break; ! 325: ! 326: case kSpeakerVolRight: ! 327: volumeInternalSpeakerRight(val); ! 328: break; ! 329: ! 330: case kHeadphonesVolLeft: ! 331: volumeHeadphonesLeft(val); ! 332: break; ! 333: ! 334: case kHeadphonesVolRight: ! 335: volumeHeadphonesRight(val); ! 336: break; ! 337: ! 338: case kCDMute: ! 339: muteCDLine(val != 0); ! 340: break; ! 341: ! 342: case kPassThruVolLeft: ! 343: break; ! 344: ! 345: case kPassThruVolRight: ! 346: break; ! 347: ! 348: case kPassThruMute: ! 349: break; ! 350: ! 351: default: ! 352: res = kIOReturnUnsupported; ! 353: } ! 354: return res; ! 355: } ! 356: ! 357: /* =============== ! 358: * Private Methods ! 359: * =============== */ ! 360: ! 361: // -------------------------------------------------------------------------- ! 362: // Method: findAndAttachI2C ! 363: // ! 364: // Purpose: ! 365: // Attaches to the i2c interface: ! 366: bool ! 367: PPCDACA::findAndAttachI2C(IOService *provider) ! 368: { ! 369: OSData *t; ! 370: UInt32 baseAddress; ! 371: UInt32 addressSteps; ! 372: UInt32 rate; ! 373: IORegistryEntry *i2cCandidate; ! 374: ! 375: // Searches the i2c: ! 376: for (i2cCandidate = NULL; ! 377: (provider != NULL) && (i2cCandidate == NULL); ! 378: provider = provider->getProvider()) { ! 379: i2cCandidate = provider->childFromPath("i2c", gIODTPlane); ! 380: #ifdef DEBUGMODE ! 381: IOLog("Looking for i2c in %s -> 0x%08lx\n", provider->getName(), (UInt32)i2cCandidate); ! 382: #endif // DEBUGMODE ! 383: } ! 384: ! 385: if (i2cCandidate == NULL) { ! 386: #ifdef DEBUGMODE ! 387: IOLog("PPCDACA::findAndAttachI2C can't find the i2c in the registry\n"); ! 388: #endif // DEBUGMODE ! 389: return false; ! 390: } ! 391: ! 392: // creates the interface for real: ! 393: interface = new PPCI2CInterface; ! 394: if (interface == NULL) { ! 395: #ifdef DEBUGMODE ! 396: IOLog("PPCDACA::findAndAttachI2C can't allocate memory for the PPCI2CInterface\n"); ! 397: #endif // DEBUGMODE ! 398: return false; ! 399: } ! 400: ! 401: // sets up the interface: ! 402: t = OSDynamicCast(OSData, i2cCandidate->getProperty("AAPL,address")); ! 403: if (t != NULL) ! 404: baseAddress = *((UInt32*)t->getBytesNoCopy()); ! 405: else { ! 406: #ifdef DEBUGMODE ! 407: IOLog( "PPCDACA::findAndAttachI2C missing property AAPL,address in i2c registry\n"); ! 408: #endif ! 409: return false; ! 410: } ! 411: ! 412: t = OSDynamicCast(OSData, i2cCandidate->getProperty("AAPL,address-step")); ! 413: if (t != NULL) ! 414: addressSteps = *((UInt32*)t->getBytesNoCopy()); ! 415: else { ! 416: #ifdef DEBUGMODE ! 417: IOLog( "PPCDACA::findAndAttachI2C missing property AAPL,address-step in i2c registry\n"); ! 418: #endif ! 419: return false; ! 420: } ! 421: ! 422: t = OSDynamicCast(OSData, i2cCandidate->getProperty("AAPL,i2c-rate")); ! 423: if (t != NULL) ! 424: rate = *((UInt32*)t->getBytesNoCopy()); ! 425: else { ! 426: #ifdef DEBUGMODE ! 427: IOLog( "PPCDACA::findAndAttachI2C missing property AAPL,i2c-rate in i2c registry\n"); ! 428: #endif ! 429: return false; ! 430: } ! 431: ! 432: if (!interface->initI2CBus((UInt8*)baseAddress, (UInt8)addressSteps)) ! 433: return false; ! 434: ! 435: if (!interface->setKhzSpeed((UInt)rate)) ! 436: return false; ! 437: ! 438: // Also sets the default mode ! 439: interface->setStandardSubMode(); ! 440: ! 441: // Finds the port to use: ! 442: return(interface->openI2CBus(getI2CPort())); ! 443: } ! 444: ! 445: // -------------------------------------------------------------------------- ! 446: // Method: detachFromI2C ! 447: // ! 448: // Purpose: ! 449: // detaches from the I2C ! 450: bool ! 451: PPCDACA::detachFromI2C(IOService* /*provider*/) ! 452: { ! 453: if (interface) ! 454: delete interface; ! 455: ! 456: return (true); ! 457: } ! 458: ! 459: // -------------------------------------------------------------------------- ! 460: // Method: implementsDACA ! 461: // ! 462: // Purpose: ! 463: // Attempts to discover if the device implements DAC-3550: ! 464: bool ! 465: PPCDACA::implementsDACA(IORegistryEntry *device) ! 466: { ! 467: if (device != NULL) { ! 468: OSData *s = NULL; ! 469: ! 470: #ifdef DEBUGMODE ! 471: IOLog("Matching DAC-3550 compatibility with %s\n", device->getName()); ! 472: #endif // DEBUGMODE ! 473: s = OSDynamicCast(OSData, device->getProperty("compatible")); ! 474: ! 475: if (s != NULL) { ! 476: if(s->isEqualTo("daca", sizeof("daca")-1)) { ! 477: return true; ! 478: } ! 479: else { ! 480: #ifdef DEBUGMODE ! 481: IOLog("PPCDAC-3550::probe sound is compatible with %s.\n", (char*)s->getBytesNoCopy(0, sizeof("daca")-1)); ! 482: #endif // DEBUGMODE ! 483: } ! 484: } ! 485: else { ! 486: #ifdef DEBUGMODE ! 487: IOLog("PPCDAC-3550::probe sound does not have a compatible property.\n"); ! 488: #endif // DEBUGMODE ! 489: } ! 490: } ! 491: else{ ! 492: #ifdef DEBUGMODE ! 493: IOLog("PPCDAC-3550::probe this hardware does not have a sound chip\n"); ! 494: #endif // DEBUGMODE ! 495: } ! 496: return false; ! 497: } ! 498: ! 499: // -------------------------------------------------------------------------- ! 500: // Method: numberOfInputComponents ! 501: // ! 502: // Purpose: ! 503: // returns the number of components for the input lines ! 504: // the name registry describes the CHIP (which has 3 inputs ! 505: // however, the iBook has no inputs, so I have to force 0 ! 506: // as output). ! 507: #define kCommonNumberOfInputComponents 0 ! 508: ! 509: int ! 510: PPCDACA::numberOfInputComponents() ! 511: { ! 512: return kCommonNumberOfInputComponents; ! 513: } ! 514: ! 515: // -------------------------------------------------------------------------- ! 516: // Method: numberOfOutputComponents ! 517: // ! 518: // Purpose: ! 519: // returns the number of components for the output lines ! 520: // usually are 2 one is the internal speacker and the other ! 521: // is the headphone line. ! 522: #define kCommonNumberOfOutputComponents 2 ! 523: ! 524: int ! 525: PPCDACA::numberOfOutputComponents() ! 526: { ! 527: if(sound) { ! 528: OSData *t; ! 529: ! 530: t = OSDynamicCast(OSData, sound->getProperty("#-outputs")); ! 531: if (t != NULL) { ! 532: return *(UInt32*)(t->getBytesNoCopy()); ! 533: } ! 534: } ! 535: return kCommonNumberOfOutputComponents; ! 536: } ! 537: ! 538: ! 539: // -------------------------------------------------------------------------- ! 540: // Method: frameRate ! 541: // ! 542: // Purpose: ! 543: // returns the frame rate as in the registry, if it is ! 544: // not found in the registry, it returns the default value. ! 545: #define kCommonFrameRate 44100 ! 546: ! 547: UInt32 ! 548: PPCDACA::frameRate(UInt32 index) ! 549: { ! 550: if(sound) { ! 551: OSData *t; ! 552: ! 553: t = OSDynamicCast(OSData, sound->getProperty("sample-rates")); ! 554: if (t != NULL) { ! 555: UInt32 *fArray = (UInt32*)(t->getBytesNoCopy()); ! 556: ! 557: if ((fArray != NULL) && (index < fArray[0])){ ! 558: // I could do >> 16, but in this way the code is portable and ! 559: // however any decent compiler will recognize this as a shift ! 560: // and do the right thing. ! 561: UInt32 fR = fArray[index + 1] / (UInt32)65536; ! 562: ! 563: #ifdef DEBUGMODE ! 564: IOLog( "PPCDACA::frameRate (%ld)\n", fR); ! 565: #endif ! 566: return fR; ! 567: } ! 568: } ! 569: } ! 570: ! 571: return (UInt32)kCommonFrameRate; ! 572: } ! 573: ! 574: // -------------------------------------------------------------------------- ! 575: // Method: getI2CPort ! 576: // ! 577: // Purpose: ! 578: // returns the i2c port to use for the audio chip. ! 579: UInt32 ! 580: PPCDACA::getI2CPort() ! 581: { ! 582: if(sound) { ! 583: OSData *t; ! 584: ! 585: t = OSDynamicCast(OSData, sound->getProperty("AAPL,i2c-port-select")); ! 586: if (t != NULL) { ! 587: UInt32 myPort = *((UInt32*)t->getBytesNoCopy()); ! 588: return myPort; ! 589: } ! 590: #ifdef DEBUGMODE ! 591: else ! 592: IOLog( "PPCDACA::getI2CPort missing property port\n"); ! 593: #endif ! 594: } ! 595: ! 596: return 0; ! 597: } ! 598: ! 599: // -------------------------------------------------------------------------- ! 600: // Method(s): componentDictionaryXXXXXX ! 601: // ! 602: // Purpose: ! 603: // the next N methods return the strings for the component dictionaries ! 604: // for each kind of component. As stated in the AWACS driver, these should ! 605: // end in the driver resources. ! 606: ! 607: // NOTE: (This is important !!!) the soundControls enum in the header file is ! 608: // bounded to the following stings in this way: ! 609: // for each component the control Id in the string must have the same value ! 610: // of the corrispondent soundControls enum item. For example the sound control ! 611: // enum item kHeadphonesVolLeft has value 4, so in sHeadphones the ID of the ! 612: // volume left control must be 4. ! 613: ! 614: char* ! 615: PPCDACA::componentDictionarySpeaker() ! 616: { ! 617: static const char *sSpeaker = ! 618: "{ ! 619: 'Type' = 'Speaker'; ! 620: 'Channels' = 2:8; ! 621: 'Master' = 1:8; ! 622: 'Controls' = { ! 623: 'MuteAll' = { ! 624: 'Type' = 'Mute'; ! 625: 'Id' = 0:16; ! 626: 'Val' = 0:8; ! 627: 'Min' = 0:8; ! 628: 'Max' = 1:8; ! 629: 'Chan' = 0:8; ! 630: }; ! 631: 'VolumeLeft' = { ! 632: 'Type' = 'Volume'; ! 633: 'Id' = 1:16; ! 634: 'Val' = 65535:16; ! 635: 'Min' = 0:16; ! 636: 'Max' = 65535:16; ! 637: 'Chan' = 1:8; ! 638: }; ! 639: 'VolumeRight' = { ! 640: 'Type' = 'Volume'; ! 641: 'Id' = 2:16; ! 642: 'Val' = 65535:16; ! 643: 'Min' = 0:16; ! 644: 'Max' = 65535:16; ! 645: 'Chan' = 2:8; ! 646: }; ! 647: }; ! 648: }"; ! 649: return (char*)sSpeaker; ! 650: } ! 651: ! 652: char* ! 653: PPCDACA::componentDictionaryHeadphones() ! 654: { ! 655: static const char *sHeadphones = ! 656: "{ ! 657: 'Type' = 'Headphones'; ! 658: 'Channels' = 2:8; ! 659: 'Master' = 1:8; ! 660: 'Controls' = { ! 661: 'MuteAll' = { ! 662: 'Type' = 'Mute'; ! 663: 'Id' = 3:16; ! 664: 'Val' = 0:8; ! 665: 'Min' = 0:8; ! 666: 'Max' = 1:8; ! 667: 'Chan' = 0:8; ! 668: }; ! 669: 'VolumeLeft' = { ! 670: 'Type' = 'Volume'; ! 671: 'Id' = 4:16; ! 672: 'Val' = 65535:16; ! 673: 'Min' = 0:16; ! 674: 'Max' = 65535:16; ! 675: 'Chan' = 1:8; ! 676: }; ! 677: 'VolumeRight' = { ! 678: 'Type' = 'Volume'; ! 679: 'Id' = 5:16; ! 680: 'Val' = 65535:16; ! 681: 'Min' = 0:16; ! 682: 'Max' = 65535:16; ! 683: 'Chan' = 2:8; ! 684: }; ! 685: }; ! 686: 'Inputs' = { ! 687: 'Jack' = { ! 688: 'Val' = 0:8; ! 689: 'Min' = 0:8; ! 690: 'Max' = 1:8; ! 691: }; ! 692: }; ! 693: }"; ! 694: return (char*)sHeadphones; ! 695: } ! 696: ! 697: char* ! 698: PPCDACA::componentDictionaryModem() ! 699: { ! 700: static const char *sModem = ! 701: "{ ! 702: 'Type' = 'Modem'; ! 703: 'Channels' = 2:8; ! 704: 'Controls' = { ! 705: 'MuteAll' = { ! 706: 'Type' = 'Mute'; ! 707: 'Id' = 6:16; ! 708: 'Val' = 0:8; ! 709: 'Min' = 0:8; ! 710: 'Max' = 1:8; ! 711: 'Chan' = 0:8; ! 712: }; ! 713: }; ! 714: 'Inputs' = { ! 715: 'Jack' = { ! 716: 'Val' = 0:8; ! 717: 'Min' = 0:8; ! 718: 'Max' = 1:8; ! 719: }; ! 720: }; ! 721: }"; ! 722: return (char*)sModem; ! 723: } ! 724: ! 725: char* ! 726: PPCDACA::componentDictionaryCD() ! 727: { ! 728: static const char *sCD = ! 729: "{ ! 730: 'Type' = 'CD'; ! 731: 'Channels' = 2:8; ! 732: 'Controls' = { ! 733: 'MuteAll' = { ! 734: 'Type' = 'Mute'; ! 735: 'Id' = 7:16; ! 736: 'Val' = 0:8; ! 737: 'Min' = 0:8; ! 738: 'Max' = 1:8; ! 739: 'Chan' = 0:8; ! 740: }; ! 741: }; ! 742: }"; ! 743: return (char*)sCD; ! 744: } ! 745: ! 746: char* ! 747: PPCDACA::componentDictionaryMixerOut() ! 748: { ! 749: static const char *sMixerOut = ! 750: "{ ! 751: 'Type' = 'Mixer'; ! 752: 'Channels' = 2:8; ! 753: }"; ! 754: return (char*)sMixerOut; ! 755: } ! 756: ! 757: char* ! 758: PPCDACA::componentDictionaryPassThru() ! 759: { ! 760: static const char *sPassThru = ! 761: "{ ! 762: 'Type' = 'Feature'; ! 763: 'Channels' = 2:8; ! 764: 'Controls' = { ! 765: 'MuteAll' = { ! 766: 'Type' = 'Mute'; ! 767: 'Id' = 12:16; ! 768: 'Val' = 1:8; ! 769: 'Min' = 0:8; ! 770: 'Max' = 1:8; ! 771: 'Chan' = 0:8; ! 772: }; ! 773: 'VolumeLeft' = { ! 774: 'Type' = 'Volume'; ! 775: 'Id' = 10:16; ! 776: 'Val' = 65535:16; ! 777: 'Min' = 0:16; ! 778: 'Max' = 65535:16; ! 779: 'Chan' = 1:8; ! 780: }; ! 781: 'VolumeRight' = { ! 782: 'Type' = 'Volume'; ! 783: 'Id' = 11:16; ! 784: 'Val' = 65535:16; ! 785: 'Min' = 0:16; ! 786: 'Max' = 65535:16; ! 787: 'Chan' = 2:8; ! 788: }; ! 789: }; ! 790: }"; ! 791: return (char*)sPassThru; ! 792: } ! 793: ! 794: // -------------------------------------------------------------------------- ! 795: // Method: dependentSetup ! 796: // ! 797: // Purpose: ! 798: // this handles the setup of the DAC-3550 chip for each kind of ! 799: // hosting hardware. ! 800: bool ! 801: PPCDACA::dependentSetup() ! 802: { ! 803: // Sets the frame rate: ! 804: UInt32 myFrameRate = frameRate(0); ! 805: ! 806: dacaSerialFormat = kSndIOFormatI2SSony; // start out in Sony format ! 807: ! 808: // Reads the initial status of the DAC3550A registers: ! 809: // The following functions return "false" on the first generation of iBooks. However I wish to ! 810: // keep them, since: ! 811: // 1] it is bad to make assumptions on what the hardware can do and can not do here (eventually these ! 812: // assumptions should be made in the i2c driver). ! 813: // 2] the next generation of iBook may supprot reading the DACA registers, and we will have more precise ! 814: // values in the "mirror" registers. ! 815: if (interface != NULL) { ! 816: interface->readI2CBus((UInt8)i2cBusAddrDAC3550A, i2cBusSubAddrSR_REG, & sampleRateReg, sizeof(sampleRateReg)); ! 817: interface->readI2CBus((UInt8)i2cBusAddrDAC3550A, i2cBusSubAddrAVOL, (UInt8*)& analogVolumeReg, sizeof(analogVolumeReg)); ! 818: interface->readI2CBus((UInt8)i2cBusAddrDAC3550A, i2cBusSubaddrGCFG, & configurationReg, sizeof(configurationReg)); ! 819: } ! 820: ! 821: // If nobody set a format before choose one: ! 822: if (dacaSerialFormat == kSndIOFormatUnknown) ! 823: dacaSerialFormat = kSndIOFormatI2SSony; ! 824: ! 825: // This call will set the next of the drame parametes ! 826: // (dacaClockSource, dacaMclkDivisor, dacaSclkDivisor) ! 827: if (!setSampleParameters(myFrameRate, 0)) { ! 828: IOLog("PPCDACA::dependentSetup can not set i2s sample rate\n"); ! 829: return false; ! 830: } ! 831: else if (!setDACASampleRate(myFrameRate)) { ! 832: IOLog("PPCDACA::dependentSetup can not set DACA sample rate\n"); ! 833: return false; ! 834: } ! 835: else ! 836: setSerialFormatRegister(dacaClockSource, dacaMclkDivisor, dacaSclkDivisor, dacaSerialFormat); ! 837: ! 838: // Sets the molumes to max as in the audio registry: ! 839: volumeInternalSpeakerLeft(65535); ! 840: volumeInternalSpeakerRight(65535); ! 841: volumeHeadphonesLeft(65535); ! 842: volumeHeadphonesRight(65535); ! 843: volumeCDLineLeft(65535); ! 844: volumeCDLineRight(65535); ! 845: ! 846: return true; ! 847: } ! 848: ! 849: // -------------------------------------------------------------------------- ! 850: // Method: checkStatusRegister ! 851: // ! 852: // Purpose: ! 853: // if the argument is true mutes the internal speaker, otherwise ! 854: // it "unmutes" it. ! 855: void ! 856: PPCDACA::checkStatusRegister() ! 857: { ! 858: if (statusChanged()) { ! 859: int i; ! 860: ! 861: OSNumber * num = OSNumber::withNumber(lastStatus, 8); ! 862: setProperty("Status", num); ! 863: num->release(); ! 864: ! 865: #ifdef DEBUGMODE ! 866: IOLog("New Status = 0x%02x\n", lastStatus); ! 867: #endif ! 868: ! 869: for (i = 0; i < numOutputComponents; i++) ! 870: if (fOutputComponents[i] != NULL) ! 871: fOutputComponents[i]->Set(gInputsSym, gJackSym, outputComponentStatus(i)); ! 872: } ! 873: } ! 874: ! 875: // -------------------------------------------------------------------------- ! 876: // Method: outputComponentStatus ! 877: // ! 878: // Purpose: ! 879: // checks the status of the jack line of the ith output component: ! 880: bool ! 881: PPCDACA::outputComponentStatus(int index) ! 882: { ! 883: switch(index) ! 884: { ! 885: case kSpeaker: ! 886: return false; // the internal speaker does not have a jack ! 887: ! 888: case kHeadphones: // check the headphones: ! 889: return headphonesInserted(); ! 890: } ! 891: ! 892: return false; // by deafult there is no jack ! 893: } ! 894: ! 895: // -------------------------------------------------------------------------- ! 896: // Method: muteInternalSpeaker ! 897: // ! 898: // Purpose: ! 899: // if the argument is true mutes the internal speaker, otherwise ! 900: // it "unmutes" it. ! 901: void ! 902: PPCDACA::muteInternalSpeaker(bool mute) ! 903: { ! 904: if (mute){ ! 905: if (!headphonesInserted()) ! 906: writeRegisterBits(i2cBusSubAddrAVOL, 0, kRightAVOLMask | kLeftAVOLMask); ! 907: internalSpeakerMuted = mute; ! 908: } ! 909: else { ! 910: internalSpeakerMuted = mute; ! 911: ! 912: if (!headphonesInserted()) ! 913: writeRegisterBits(i2cBusSubAddrAVOL, internalSpeakerVolume, kRightAVOLMask | kLeftAVOLMask); ! 914: } ! 915: } ! 916: ! 917: // -------------------------------------------------------------------------- ! 918: // Method: muteHeadphones ! 919: // ! 920: // Purpose: ! 921: // if the argument is true mutes the rear panel mini jack, otherwise ! 922: // it "unmutes" it. ! 923: void ! 924: PPCDACA::muteHeadphones(bool mute) ! 925: { ! 926: if (mute){ ! 927: if (headphonesInserted()) ! 928: writeRegisterBits(i2cBusSubAddrAVOL, 0, kRightAVOLMask | kLeftAVOLMask); ! 929: internalHeadphonesMuted = mute; ! 930: } ! 931: else { ! 932: internalHeadphonesMuted = mute; ! 933: ! 934: if (headphonesInserted()) ! 935: writeRegisterBits(i2cBusSubAddrAVOL, internalHeadphonesVolume, kRightAVOLMask | kLeftAVOLMask); ! 936: } ! 937: } ! 938: ! 939: // -------------------------------------------------------------------------- ! 940: // Method: muteCDLine ! 941: // ! 942: // Purpose: ! 943: // if the argument is true mutes the line of the cd player ! 944: void ! 945: PPCDACA::muteCDLine(bool mute) ! 946: { ! 947: // FIXME: Figure out how this is wired up: ! 948: } ! 949: ! 950: // -------------------------------------------------------------------------- ! 951: // Method: setModemInput ! 952: // ! 953: // Purpose: ! 954: // selects the modem as input source (if bool = true) ! 955: void ! 956: PPCDACA::setModemInput(bool mod) ! 957: { ! 958: #ifdef DEBUGMODE ! 959: IOLog( "PPCDACA::setModemInput: %s\n", (mod ? "True" : "False")); ! 960: #endif ! 961: } ! 962: ! 963: ! 964: // -------------------------------------------------------------------------- ! 965: // Method: statusChanged() ! 966: // ! 967: // Purpose: ! 968: // returns true if something changed in the status register:. ! 969: bool ! 970: PPCDACA::statusChanged() ! 971: { ! 972: UInt8 currentStatusRegister = *(UInt8*)ioStatusRegister_GPIO12; ! 973: ! 974: if (lastStatus == currentStatusRegister) ! 975: return (false); ! 976: ! 977: // Otherwise refresh the value of the last status register read and ! 978: // returns that the value changed: ! 979: lastStatus = currentStatusRegister; ! 980: return (true); ! 981: } ! 982: ! 983: // -------------------------------------------------------------------------- ! 984: // Method: headphonesInserted ! 985: // ! 986: // Purpose: ! 987: // returns true if the headphones are inserted. ! 988: bool ! 989: PPCDACA::headphonesInserted() ! 990: { ! 991: return((lastStatus & kHeadphoneBit) == 0); ! 992: } ! 993: ! 994: // -------------------------------------------------------------------------- ! 995: // Method: volumeHeadphonesLeft & volumeHeadphonesRight ! 996: // ! 997: // Purpose: ! 998: // sets the volume for the left and right channel of the internal ! 999: // headphones. ! 1000: void ! 1001: PPCDACA::volumeHeadphonesLeft(int vol) ! 1002: { ! 1003: analogVolumeReg = internalHeadphonesVolume; ! 1004: setDACAVolume(vol, true); ! 1005: internalHeadphonesVolume = analogVolumeReg; ! 1006: } ! 1007: ! 1008: void ! 1009: PPCDACA::volumeHeadphonesRight(int vol) ! 1010: { ! 1011: analogVolumeReg = internalHeadphonesVolume; ! 1012: setDACAVolume(vol, false); ! 1013: internalHeadphonesVolume = analogVolumeReg; ! 1014: } ! 1015: ! 1016: // -------------------------------------------------------------------------- ! 1017: // Method: volumeInternalSpeakerLeft & volumeInternalSpeakerRight ! 1018: // ! 1019: // Purpose: ! 1020: // sets the volume for the left and right channel of the internal ! 1021: // speaker. ! 1022: void ! 1023: PPCDACA::volumeInternalSpeakerLeft(int vol) ! 1024: { ! 1025: analogVolumeReg = internalSpeakerVolume; ! 1026: setDACAVolume(vol, true); ! 1027: internalSpeakerVolume = analogVolumeReg; ! 1028: } ! 1029: ! 1030: void ! 1031: PPCDACA::volumeInternalSpeakerRight(int vol) ! 1032: { ! 1033: analogVolumeReg = internalSpeakerVolume; ! 1034: setDACAVolume(vol, false); ! 1035: internalSpeakerVolume = analogVolumeReg; ! 1036: } ! 1037: ! 1038: // -------------------------------------------------------------------------- ! 1039: // Method: volumeCDLineLeft & volumeCDLineRight ! 1040: // ! 1041: // Purpose: ! 1042: // sets the volume for the left and right channel of the CD ! 1043: // line. ! 1044: void ! 1045: PPCDACA::volumeCDLineLeft(int vol) ! 1046: { ! 1047: } ! 1048: ! 1049: void ! 1050: PPCDACA::volumeCDLineRight(int vol) ! 1051: { ! 1052: } ! 1053: ! 1054: /* ============================================================= ! 1055: * VERY Private Methods used to access to the DAC-3550 registers ! 1056: * ============================================================= */ ! 1057: ! 1058: // -------------------------------------------------------------------------- ! 1059: // Method: enableInterrupts ! 1060: // ! 1061: // Purpose: ! 1062: // enable the interrupts for the I2S interface: ! 1063: bool ! 1064: PPCDACA::enableInterrupts() ! 1065: { ! 1066: I2SSetIntCtlReg(kFrameCountEnable | kClocksStoppedEnable); ! 1067: return true; ! 1068: } ! 1069: ! 1070: // Method: disableInterrupts ! 1071: // ! 1072: // Purpose: ! 1073: // disable the interrupts for the I2S interface: ! 1074: bool ! 1075: PPCDACA::disableInterrupts() ! 1076: { ! 1077: I2SSetIntCtlReg(I2SGetIntCtlReg() & (~(kFrameCountEnable | kClocksStoppedEnable))); ! 1078: return true; ! 1079: } ! 1080: ! 1081: // -------------------------------------------------------------------------- ! 1082: // Method: clockRun ! 1083: // ! 1084: // Purpose: ! 1085: // starts and stops the clock count: ! 1086: bool ! 1087: PPCDACA::clockRun(bool start) ! 1088: { ! 1089: bool success = true; ! 1090: UInt32 *baseInterrupt = (UInt32*)soundConfigSpace + kI2SIntCtlOffset; ! 1091: ! 1092: #ifdef DEBUGMODE ! 1093: IOLog("PPCDACA::clockRun(%s) 1] 0x%08lx -> 0x%08lx\n", (start ? "true" : "false"), (UInt32)baseInterrupt, *baseInterrupt); ! 1094: #endif ! 1095: ! 1096: if (start) { ! 1097: KLSetRegister(ioClockBaseAddress, KLGetRegister(ioClockBaseAddress) | kI2S0ClockEnable); ! 1098: } ! 1099: else { ! 1100: UInt16 loop = 50; ! 1101: KLSetRegister(ioClockBaseAddress, KLGetRegister(ioClockBaseAddress) & (~kI2S0ClockEnable)); ! 1102: ! 1103: while (((I2SGetIntCtlReg() & kClocksStoppedPending) == 0) && (loop--)) { ! 1104: // it does not do anything, jut waites for the clock ! 1105: // to stop ! 1106: IOSleep(10); ! 1107: #ifdef DEBUGMODE ! 1108: IOLog("PPCDACA::clockRun(%s) 2] 0x%08lx -> 0x%08lx\n", (start ? "true" : "false"), (UInt32)baseInterrupt, *baseInterrupt); ! 1109: #endif ! 1110: } ! 1111: ! 1112: // we are successful if the clock actually stopped. ! 1113: success = ((I2SGetIntCtlReg() & kClocksStoppedPending) != 0); ! 1114: } ! 1115: ! 1116: #ifdef DEBUGMODE ! 1117: if (!success) ! 1118: IOLog("PPCDACA::clockRun(%s) failed\n", (start ? "true" : "false")); ! 1119: #endif ! 1120: ! 1121: return success; ! 1122: } ! 1123: ! 1124: // -------------------------------------------------------------------------- ! 1125: // Method: setSampleRate ! 1126: // ! 1127: // Purpose: ! 1128: // Sets the sample rate on the I2S bus ! 1129: bool ! 1130: PPCDACA::setSampleParameters(UInt32 sampleRate, UInt32 mclkToFsRatio) ! 1131: { ! 1132: UInt32 mclkRatio; ! 1133: UInt32 reqMClkRate; ! 1134: ! 1135: mclkRatio = mclkToFsRatio; // remember the MClk ratio required ! 1136: ! 1137: if ( mclkRatio == 0 ) // or make one up if MClk not required ! 1138: mclkRatio = 64; // use 64 x ratio since that will give us the best characteristics ! 1139: ! 1140: reqMClkRate = sampleRate * mclkRatio; // this is the required MClk rate ! 1141: ! 1142: // look for a source clock that divides down evenly into the MClk ! 1143: if ((kClock18MHz % reqMClkRate) == 0) { ! 1144: // preferential source is 18 MHz ! 1145: dacaClockSource = kClock18MHz; ! 1146: } ! 1147: else if ((kClock45MHz % reqMClkRate) == 0) { ! 1148: // next check 45 MHz clock ! 1149: dacaClockSource = kClock45MHz; ! 1150: } ! 1151: else if ((kClock49MHz % reqMClkRate) == 0) { ! 1152: // last, try 49 Mhz clock ! 1153: dacaClockSource = kClock49MHz; ! 1154: } ! 1155: else { ! 1156: IOLog("PPCDACA::setSampleParameters Unable to find a suitable source clock (no globals changes take effect)\n"); ! 1157: return false; ! 1158: } ! 1159: ! 1160: // get the MClk divisor ! 1161: IOLog("PPCDACA:setSampleParameters %ld / %ld =", (UInt32)dacaClockSource, (UInt32)reqMClkRate); ! 1162: dacaMclkDivisor = dacaClockSource / reqMClkRate; ! 1163: IOLog("%ld\n", dacaMclkDivisor); ! 1164: switch (dacaSerialFormat) // SClk depends on format ! 1165: { ! 1166: case kSndIOFormatI2SSony: ! 1167: case kSndIOFormatI2S64x: ! 1168: dacaSclkDivisor = mclkRatio / k64TicksPerFrame; // SClk divisor is MClk ratio/64 ! 1169: break; ! 1170: case kSndIOFormatI2S32x: ! 1171: dacaSclkDivisor = mclkRatio / k32TicksPerFrame; // SClk divisor is MClk ratio/32 ! 1172: break; ! 1173: default: ! 1174: IOLog("PPCDACA::setSampleParameters Invalid serial format\n"); ! 1175: return false; ! 1176: break; ! 1177: } ! 1178: ! 1179: return true; ! 1180: } ! 1181: ! 1182: ! 1183: // -------------------------------------------------------------------------- ! 1184: // Method: setSerialFormatRegister ! 1185: // ! 1186: // Purpose: ! 1187: // Set global values to the serial format register ! 1188: void ! 1189: PPCDACA::setSerialFormatRegister(ClockSource clockSource, UInt32 mclkDivisor, UInt32 sclkDivisor, SoundFormat serialFormat) ! 1190: { ! 1191: UInt32 regValue = 0; ! 1192: ! 1193: #ifdef DEBUGMODE ! 1194: IOLog("PPCDACA::SetSerialFormatRegister(%d,%d,%d,%d)\n",(int)clockSource, (int)mclkDivisor, (int)sclkDivisor, (int)serialFormat); ! 1195: #endif // DEBUGMODE ! 1196: ! 1197: switch ((int)clockSource) ! 1198: { ! 1199: case kClock18MHz: ! 1200: regValue = kClockSource18MHz; ! 1201: break; ! 1202: case kClock45MHz: ! 1203: regValue = kClockSource45MHz; ! 1204: break; ! 1205: case kClock49MHz: ! 1206: regValue = kClockSource49MHz; ! 1207: break; ! 1208: default: ! 1209: IOLog("PPCDACA::SetSerialFormatRegister(%d,%d,%d,%d): Invalid clock source\n",(int)clockSource, (int)mclkDivisor, (int)sclkDivisor, (int)serialFormat); ! 1210: break; ! 1211: } ! 1212: ! 1213: switch (mclkDivisor) ! 1214: { ! 1215: case 1: ! 1216: regValue |= kMClkDivisor1; ! 1217: break; ! 1218: case 3: ! 1219: regValue |= kMClkDivisor3; ! 1220: break; ! 1221: case 5: ! 1222: regValue |= kMClkDivisor5; ! 1223: break; ! 1224: default: ! 1225: regValue |= (((mclkDivisor / 2) - 1) << kMClkDivisorShift) & kMClkDivisorMask; ! 1226: break; ! 1227: } ! 1228: ! 1229: switch ((int)sclkDivisor) ! 1230: { ! 1231: case 1: ! 1232: regValue |= kSClkDivisor1; ! 1233: break; ! 1234: case 3: ! 1235: regValue |= kSClkDivisor3; ! 1236: break; ! 1237: default: ! 1238: regValue |= (((sclkDivisor / 2) - 1) << kSClkDivisorShift) & kSClkDivisorMask; ! 1239: break; ! 1240: } ! 1241: regValue |= kSClkMaster; // force master mode ! 1242: ! 1243: switch (serialFormat) ! 1244: { ! 1245: case kSndIOFormatI2SSony: ! 1246: regValue |= kSerialFormatSony; ! 1247: break; ! 1248: case kSndIOFormatI2S64x: ! 1249: regValue |= kSerialFormat64x; ! 1250: break; ! 1251: case kSndIOFormatI2S32x: ! 1252: regValue |= kSerialFormat32x; ! 1253: break; ! 1254: default: ! 1255: IOLog("PPCDACA::SetSerialFormatRegister(%d,%d,%d,%d): Invalid serial format\n",(int)clockSource, (int)mclkDivisor, (int)sclkDivisor, (int)serialFormat); ! 1256: break; ! 1257: } ! 1258: ! 1259: // This is a 3 step process: ! 1260: ! 1261: // 1] Stop the clock: ! 1262: clockRun(false); ! 1263: ! 1264: // 2] Setup the serial format register ! 1265: I2SSetSerialFormatReg(regValue); ! 1266: ! 1267: // 3 restarts the clock: ! 1268: clockRun(true); ! 1269: } ! 1270: ! 1271: // -------------------------------------------------------------------------- ! 1272: // Method: setDACASampleRate ! 1273: // ! 1274: // Purpose: ! 1275: // Gets the sample rate and makes it in a format that is compatible ! 1276: // with the adac register. The funtion returs false if it fails. ! 1277: bool ! 1278: PPCDACA::setDACASampleRate(UInt rate) ! 1279: { ! 1280: UInt32 dacRate = 0; ! 1281: ! 1282: #ifdef DEBUGMODE ! 1283: IOLog("PPCDACA::setDACASampleRate(%d)\n", rate); ! 1284: #endif // DEBUGMODE ! 1285: ! 1286: switch (rate) ! 1287: { ! 1288: case 44100: // 32 kHz - 48 kHz ! 1289: dacRate = kSRC_48SR_REG; ! 1290: break; ! 1291: ! 1292: default: ! 1293: IOLog("PPCDACA::setDACASampleRate, supports only 44100 Hz (for now)\n"); ! 1294: break; ! 1295: } ! 1296: ! 1297: return(writeRegisterBits(i2cBusSubAddrSR_REG, dacRate, kSampleRateControlMask)); ! 1298: } ! 1299: ! 1300: ! 1301: // -------------------------------------------------------------------------- ! 1302: // Method: setDACAVolume ! 1303: // ! 1304: // Purpose: ! 1305: // sets the volume for the left or right channel. The first argument is ! 1306: // the wnated volume (as a range from 0 to 255), while the second argument ! 1307: // is a boolean (true for the right channel, false for the left channel). ! 1308: bool ! 1309: PPCDACA::setDACAVolume(UInt16 volume, bool isLeft) ! 1310: { ! 1311: UInt8 newVolume = ((UInt32)((UInt32)volume * (UInt32)kVolumeRangeLevel_VOL) / (UInt32)65535 + (UInt32)kMinVolumeLevel_VOL); ! 1312: bool success = true; ! 1313: ! 1314: if (isLeft) // Sets the volume on the right channel ! 1315: success = writeRegisterBits(i2cBusSubAddrAVOL, (newVolume << kLeftAVOLShift), kLeftAVOLMask); ! 1316: else // Sets the volume on the left channel ! 1317: success = writeRegisterBits(i2cBusSubAddrAVOL, (newVolume << kRightAVOLShift), kRightAVOLMask); ! 1318: ! 1319: return success; ! 1320: } ! 1321: ! 1322: // --------------------------------------------------------------------------------------- ! 1323: // Method: writeRegisterBits ! 1324: // ! 1325: // Purpose: ! 1326: // This function sets or clears bits in the Daca registers. The first argument is the ! 1327: // register sub-address, the second argument is a mask for turning bits on, while the third ! 1328: // argument is a mask for turning bits off. ! 1329: bool ! 1330: PPCDACA::writeRegisterBits(UInt8 subAddress, UInt32 bitMaskOn, UInt32 bitMaskOff) ! 1331: { ! 1332: UInt8 bitsOn = 0, bitsOff = 0, value; ! 1333: UInt16 shortBitsOn = 0, shortBitsOff = 0, value16; ! 1334: bool success = false; ! 1335: ! 1336: #ifdef DEBUGMODE ! 1337: IOLog("PPCDACA::writeRegisterBits(0x%x, 0x%08lx, 0x%08lx)\n", (UInt16)subAddress, bitMaskOn, bitMaskOff); ! 1338: #endif // DEBUGMODE ! 1339: ! 1340: // mask off irrelevant bytes ! 1341: if (subAddress == i2cBusSubAddrAVOL) { ! 1342: // 16-bit register ! 1343: shortBitsOn = bitMaskOn & 0x0000FFFF; ! 1344: shortBitsOff = bitMaskOff & 0x0000FFFF; ! 1345: } ! 1346: else { ! 1347: // 8-bit registers ! 1348: bitsOn = bitMaskOn & 0x000000FF; ! 1349: bitsOff = bitMaskOff & 0x000000FF; ! 1350: } ! 1351: ! 1352: switch (subAddress) ! 1353: { ! 1354: case i2cBusSubAddrSR_REG: ! 1355: value = sampleRateReg | bitsOn; ! 1356: value &= ~bitsOff; ! 1357: // continue only if on bits are not already on and off bits are not already off ! 1358: if (value != sampleRateReg) { ! 1359: success = interface->writeI2CBus((UInt8)i2cBusAddrDAC3550A, subAddress, &value, sizeof(value)); ! 1360: ! 1361: if (success) ! 1362: sampleRateReg = value; ! 1363: } ! 1364: else { ! 1365: // If the sample rate is already set at the wanted value ! 1366: // we do not do anything, but we return success since from the ! 1367: // caller point of view it is as the sample rate was correctly ! 1368: // set. ! 1369: success = true; ! 1370: } ! 1371: break; ! 1372: ! 1373: case i2cBusSubAddrAVOL: ! 1374: value16 = analogVolumeReg; ! 1375: value16 &= ~shortBitsOff; ! 1376: value16 |= shortBitsOn; ! 1377: // continue only if on bits are not already on and off bits are not already off ! 1378: if (value16 !=analogVolumeReg) ! 1379: { ! 1380: // It changes the volume for real only if the current output is not muted. ! 1381: if (((!headphonesInserted()) && (!internalSpeakerMuted)) || ! 1382: (headphonesInserted() && (!internalHeadphonesMuted))) ! 1383: success = interface->writeI2CBus((UInt8)i2cBusAddrDAC3550A, subAddress, (UInt8*)&value16, sizeof(value16)); ! 1384: else ! 1385: success = true; ! 1386: ! 1387: if (success) ! 1388: analogVolumeReg = value16; ! 1389: } ! 1390: else { ! 1391: // If the volume is already set at the wanted value ! 1392: // we do not do anything, but we return success since from the ! 1393: // caller point of view it is as the volume was correctly ! 1394: // set. ! 1395: success = true; ! 1396: } ! 1397: break; ! 1398: ! 1399: case i2cBusSubaddrGCFG: ! 1400: value = configurationReg | bitsOn; ! 1401: value &= ~bitsOff; ! 1402: // continue only if on bits are not already on and off bits are not already off ! 1403: if (value != configurationReg) ! 1404: { ! 1405: success = interface->writeI2CBus((UInt8)i2cBusAddrDAC3550A, subAddress, &value, sizeof(value)); ! 1406: if (success) ! 1407: configurationReg = value; ! 1408: } ! 1409: else { ! 1410: // If the config register is already set at the wanted value ! 1411: // we do not do anything, but we return success since from the ! 1412: // caller point of view it is as the configuration was correctly ! 1413: // set. ! 1414: success = true; ! 1415: } ! 1416: break; ! 1417: ! 1418: default: ! 1419: IOLog("PPCDACA::writeRegisterBits 0x%x unknown subaddress\n", (UInt16)subAddress); ! 1420: break; ! 1421: } ! 1422: return success; ! 1423: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.