![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to PPCBurgundy.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 / drvPPCBurgundy|
Return to PPCBurgundy.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / audio / drvPPCBurgundy |
1.1 root 1: /*
2: * Copyright (c) 1998 Apple Computer, Inc. All rights reserved.
3: *
4: * Hardware independent (relatively) code for the Burgundy Controller
5: *
6: * HISTORY
7: *
8: *
9: */
10: #include <IOKit/assert.h>
11: #include <IOKit/system.h>
12:
13: #include <IOKit/IOLib.h>
14: #include <IOKit/IODeviceTreeSupport.h>
15: #include <IOKit/IOPlatformExpert.h>
16: #include <IOKit/ppc/IODBDMA.h>
17: #include "PPCBurgundy.h"
18: #include "burgundy_hw.h"
19:
20: /*
21: * Prototyes for the "very private methods" at the end of this
22: * file. They provide access to the burgundy registers:
23: */
24: static void writeSoundControlReg( volatile UInt8*, int);
25: static int readCodecSenseLines( volatile UInt8*);
26: static int readCodecReg( volatile UInt8*, int);
27: static void writeCodecReg( volatile UInt8*, int, int);
28:
29: #define super IOAudioBus
30: OSDefineMetaClassAndStructors( PPCBurgundy, IOAudioBus )
31:
32: /* ==============
33: * Public Methods
34: * ============== */
35: bool
36: PPCBurgundy::init(OSDictionary * properties)
37: {
38: if (!super::init(properties)) {
39: #ifdef DEBUGMODE
40: IOLog( "PPCBurgundy::init (this = 0x%08lx) super fails\n", (UInt32)this);
41: #endif
42: return false;
43: }
44:
45: if(!properties){
46: #ifdef DEBUGMODE
47: IOLog( "PPCBurgundy::init (this = 0x%08lx) Need to know where Burgundy is !!\n", (UInt32)this);
48: #endif
49: return false; // Need to know where Burgundy is!
50: }
51:
52: // This invalidate the cache of the machine architecture
53: machineType = kMachineTypeUnknown;
54:
55: // Nulls the pointers for the arrays we allocate:
56: fInputComponents = NULL;
57: fOutputComponents = NULL;
58: sound = NULL;
59:
60: // We start with a clean status register mirror so first read will
61: // set the driver in the correct mode:
62: lastStatusRegister = 0L;
63:
64: #ifdef DEBUGMODE
65: IOLog( "PPCBurgundy::init (this = 0x%08lx)\n", (UInt32)this);
66: #endif
67: return true;
68: }
69:
70: void
71: PPCBurgundy::free()
72: {
73: // Releases the sound:
74: if(sound != NULL)
75: sound->release();
76: sound = NULL;
77:
78: super::free();
79: }
80:
81: IOService*
82: PPCBurgundy::probe(IOService* provider, SInt32* score)
83: {
84: IOService *myService = this;
85:
86: // We CAN fail the tye check:
87: super::probe(provider, score);
88: *score = kIODefaultProbeScore;
89:
90: // finds and cashes the hardware we are running on:
91: int mType = findHostingHardware(provider);
92:
93: // If it one of the machine I know supports
94: // burgundy I'm going to increment the score
95: if ((mType == kMachineTypeYosemite) || (mType == kMachineTypeiMac)) {
96: // One score increment because this is a burgundy-hosting motherboard
97: *score = *score + 1;
98: }
99:
100: // Figure out if this is a bugundy and if it is a bordeaux
101: sound = NULL;
102: isBordeaux = false;
103:
104: // This is likely to be the case that this is perch
105: if (implementsBurgundy(IORegistryEntry::fromPath("/perch", gIODTPlane))) {
106: *score = *score + 1;
107: myService = this;
108: }
109: else if ((sound = provider->childFromPath("sound", gIODTPlane)) != NULL) {
110: // IOLog("PPCBurgundy::probe looking for sound\n");
111: if (implementsBurgundy(sound)) {
112: *score = *score + 1;
113: myService = this;
114: }
115: }
116:
117: if (myService != NULL) {
118: IOLog("Found Burgundy compatible chip %s\n", (isBordeaux ? "and Bordeaux card": "NON Bordeaux card"));
119: }
120:
121: return (myService);
122: }
123:
124: #define kNumDMAStreams 2
125:
126: bool
127: PPCBurgundy::start(IOService* provider)
128: {
129: // Gets the base for the burgundy registers:
130: IOMemoryMap *map;
131: int i;
132:
133: if( !super::start(provider))
134: return (false);
135:
136: map = provider->mapDeviceMemoryWithIndex(kAudioDMAdeviceInt);
137: if(!map) {
138: return false;
139: }
140: ioBaseBurgundy = (UInt8 *)map->getVirtualAddress();
141:
142: if (!AllocateStreams(kNumDMAStreams))
143: return false;
144:
145: map = provider->mapDeviceMemoryWithIndex(kAudioDMAtxInt);
146: if(!map) {
147: return false;
148: }
149: DefineStream(kAudioDMAOutputStream, kOutput, outputFrameRate(), (IODBDMAChannelRegisters*)map->getVirtualAddress());
150:
151: map = provider->mapDeviceMemoryWithIndex(kAudioDMArxInt);
152: if(!map) {
153: return false;
154: }
155: DefineStream(kAudioDMAInputStream, kInput, inputFrameRate(), (IODBDMAChannelRegisters*)map->getVirtualAddress());
156:
157: // Creates the array of input and output components
158: numInputComponents = numberOfOutputComponents();
159: numOutputComponents = numberOfInputComponents();
160:
161: fInputComponents = (IOAudioComponentImplPtr*)IOMalloc(sizeof(IOAudioComponentImplPtr) * numInputComponents);
162: if (fInputComponents == NULL) {
163: // Free the DMA and exit:
164: FreeStreams();
165: return false;
166: }
167:
168: fOutputComponents = (IOAudioComponentImplPtr*)IOMalloc(sizeof(IOAudioComponentImplPtr) * numOutputComponents);
169: if (fOutputComponents == NULL) {
170: // Free the input components
171: IOFree(fInputComponents, sizeof(IOAudioComponentImplPtr) * numInputComponents);
172: fInputComponents = NULL;
173: numInputComponents = 0;
174:
175: // Free the DMA and exit:
176: FreeStreams();
177: return false;
178: }
179:
180: // Initalizes all the components:
181: for (i = 0; i < numInputComponents; i++)
182: fInputComponents[i] = NULL;
183:
184: for (i = 0; i < numOutputComponents; i++)
185: fOutputComponents[i] = NULL;
186:
187: // Initializes the sound control register:
188: soundControlRegister = ( kSoundCtlReg_InSubFrame0 | \
189: kSoundCtlReg_OutSubFrame0 | \
190: kSoundCtlReg_Rate_44100 );
191: writeSoundControlReg(ioBaseBurgundy, soundControlRegister);
192:
193: // Set Input Source A gain to default
194: writeCodecReg( ioBaseBurgundy, kGASALReg, kGAS_Default_Gain );
195: writeCodecReg( ioBaseBurgundy, kGASARReg, kGAS_Default_Gain );
196: writeCodecReg( ioBaseBurgundy, kVGA2Reg, 0x44 );
197: writeCodecReg( ioBaseBurgundy, kGAS2LReg, 255 );
198: writeCodecReg( ioBaseBurgundy, kGAS2RReg, 255 );
199:
200: // Set mixer 1 input to Input Source A (Serial-in Subframe 0)
201: writeCodecReg( ioBaseBurgundy, kMX1Reg, kMX1Reg_Select_ISAL | kMX1Reg_Select_ISAR );
202: writeCodecReg( ioBaseBurgundy, kSDInReg, kSDInReg_ASA_From_SF0 );
203:
204: // Set mixer 0-3 outputs to default gain
205: writeCodecReg( ioBaseBurgundy, kMXEQ1LReg, kMXEQ_Default_Gain );
206: writeCodecReg( ioBaseBurgundy, kMXEQ1RReg, kMXEQ_Default_Gain );
207: writeCodecReg( ioBaseBurgundy, kMXEQ2LReg, kMXEQ_Default_Gain );
208: writeCodecReg( ioBaseBurgundy, kMXEQ2RReg, kMXEQ_Default_Gain );
209: writeCodecReg( ioBaseBurgundy, kMXEQ3LReg, kMXEQ_Default_Gain );
210: writeCodecReg( ioBaseBurgundy, kMXEQ3RReg, kMXEQ_Default_Gain );
211:
212: // Set Output Source 0 gain to default
213: writeCodecReg( ioBaseBurgundy, kGAP0LReg, kGAP_Default_Gain );
214: writeCodecReg( ioBaseBurgundy, kGAP0RReg, kGAP_Default_Gain );
215:
216: startWorkLoop();
217:
218: return true;
219: }
220:
221: void
222: PPCBurgundy::stop(IOService *provider)
223: {
224: // Releases all DMA streams:
225: FreeStreams();
226:
227: // Releases the input components
228: if (fInputComponents != NULL) {
229: IOFree(fInputComponents, sizeof(IOAudioComponentImplPtr) * numInputComponents);
230: fInputComponents = NULL;
231: numInputComponents = 0;
232: }
233:
234: // Releases the output components
235: if (fOutputComponents != NULL) {
236: IOFree(fOutputComponents, sizeof(IOAudioComponentImplPtr) * numOutputComponents);
237: fOutputComponents = NULL;
238: numOutputComponents = 0;
239: }
240: }
241:
242: void
243: PPCBurgundy::CreateAudioTopology(IOCommandQueue *queue)
244: {
245: IOAudioComponentImpl *mixerIn;
246: IOAudioComponentImpl *mixerOut;
247: IOAudioComponentImpl *microphone;
248: IOAudioComponentImpl *lineout;
249: IOAudioComponentImpl *linein;
250: IOAudioComponentImpl *headphones;
251: IOAudioComponentImpl *cd;
252: IOAudioComponentImpl *speaker;
253: IOAudioComponentImpl *passtru;
254:
255: AudioStreamIndex outputStream;
256: AudioStreamIndex inputStream;
257:
258: if (!fStreams)
259: return;
260:
261: outputStream = firstStreamAfter(kOutput, 0);
262: inputStream = firstStreamAfter(kInput, 0);
263:
264: if ((outputStream == kInvalidStreamIndex) || (inputStream == kInvalidStreamIndex)) {
265: IOLog("PPCBurgundy::CreateAudioTopology called without available DMA streams\n");
266: return;
267: }
268: else
269: IOLog("PPCBurgundy::CreateAudioTopology input stream is %d output is %d\n", inputStream, outputStream);
270:
271: mixerOut = buildComponentAndAttach(GetStream(outputStream), NULL, componentDictionaryMixerOut(), queue);
272: headphones = buildComponentAndAttach(mixerOut, NULL, componentDictionaryHeadphones(), queue);
273: speaker = buildComponentAndAttach(mixerOut, NULL, componentDictionarySpeaker(), queue);
274: lineout = buildComponentAndAttach(mixerOut, NULL, componentDictionaryLineout(), queue);
275:
276: mixerIn = buildComponentAndAttach(NULL, GetStream(inputStream), componentDictionaryMixerIn(), queue);
277: cd = buildComponentAndAttach(NULL, NULL, componentDictionaryCD(), queue);
278: linein = buildComponentAndAttach(NULL, NULL, componentDictionaryLinein(), queue);
279: microphone = buildComponentAndAttach(NULL, mixerIn, componentDictionaryMicrophone(), queue);
280:
281: passtru = buildComponentAndAttach(mixerIn, mixerOut, componentDictionaryPassThru(), queue);
282:
283: buildComponentAndAttach(mixerIn, mixerOut, componentDictionaryPassThru(), queue);
284: fInputComponents[kCD] = buildComponentAndAttach(NULL, mixerIn, componentDictionaryCD(), queue);
285:
286: // FIXME: the component connection could be done better than so
287: if (fInputComponents != NULL) {
288: fInputComponents[kMicroPhone] = microphone;
289:
290: if (numInputComponents > 1)
291: fInputComponents[kCD] = cd;
292:
293: if (numInputComponents > 2)
294: fInputComponents[kLineIn] = linein;
295: }
296:
297: if (fOutputComponents != NULL) {
298: fOutputComponents[kSpeaker] = speaker;
299:
300: if (numOutputComponents > 1)
301: fOutputComponents[kHeadphones] = headphones;
302:
303: if (numOutputComponents > 2)
304: fOutputComponents[kLineOut] = lineout;
305: }
306:
307: // Sets ups the burgundy as required by this machine wiring
308: // configuration:
309: if (!dependentSetup())
310: IOLog("PPCBurgundy::CreateAudioTopology burgundy setup failed\n");
311: }
312:
313: void
314: PPCBurgundy::DoClockTick(IOTimerEventSource *t)
315: {
316: checkStatusRegister();
317: super::DoClockTick(t);
318: }
319:
320: void
321: PPCBurgundy::calculateTickInterval(AbsoluteTime *tickInterval)
322: {
323: AbsoluteTime maxInterval;
324:
325: // We want to check the status at least one a second
326: nanoseconds_to_absolutetime(NSEC_PER_SEC, &maxInterval);
327: if(CMP_ABSOLUTETIME(&maxInterval, tickInterval) < 0) {
328: *tickInterval = maxInterval;
329: }
330: super::calculateTickInterval(tickInterval);
331: }
332:
333: IOReturn
334: PPCBurgundy::SetControl(UInt16 id, int val)
335: {
336: IOReturn res = kIOReturnSuccess;
337:
338: switch(id) {
339: case kSpeakerMute:
340: muteInternalSpeaker(val != 0);
341: muteHeadphones(val == 0);
342: break;
343:
344: case kHeadphonesMute:
345: muteHeadphones(val != 0);
346: muteInternalSpeaker(val == 0);
347: break;
348:
349: case kMicrophoneMute:
350: setMicInput(val == 0);
351: break;
352:
353: case kSpeakerVolLeft:
354: volumeInternalSpeakerLeft(val);
355: break;
356:
357: case kSpeakerVolRight:
358: volumeInternalSpeakerRight(val);
359: break;
360:
361: case kHeadphonesVolLeft:
362: volumeHeadphonesLeft(val);
363: break;
364:
365: case kHeadphonesVolRight:
366: volumeHeadphonesRight(val);
367: break;
368:
369: case kCDMute:
370: muteCDLine(val != 0);
371: break;
372:
373: case kMixerInVolLeft:
374: volumeMixerInLeft(val);
375: break;
376:
377: case kMixerInVolRight:
378: volumeMixerInRight(val);
379: break;
380:
381: case kPassThruVolLeft:
382: break;
383:
384: case kPassThruVolRight:
385: break;
386:
387: case kPassThruMute:
388: break;
389:
390: default:
391: res = kIOReturnUnsupported;
392: }
393: return res;
394: }
395:
396: /* ===============
397: * Private Methods
398: * =============== */
399:
400: // --------------------------------------------------------------------------
401: // Method: implementsBurgundy
402: //
403: // Purpose:
404: // Attempts to discover if the device implements burgundy:
405: bool
406: PPCBurgundy::implementsBurgundy(IORegistryEntry *device)
407: {
408: if (device != NULL) {
409: OSData *s = NULL;
410:
411: //IOLog("Matching burgundy compatibility with %s\n", device->getName());
412:
413: s = OSDynamicCast(OSData, device->getProperty("compatible"));
414:
415: if (s != NULL) {
416: if(s->isEqualTo("burgundy", sizeof("burgundy")-1)) {
417: return true;
418: }
419: else if(s->isEqualTo("DVD-Video and Audio/Video", sizeof("DVD-Video and Audio/Video")-1)) {
420: // also sets the isBordeaux flag
421: isBordeaux = true;
422: return true;
423: }
424: else {
425: //IOLog("PPCBurgundy::probe sound is not burgundy compatible.\n");
426: }
427: }
428: else {
429: //IOLog("PPCBurgundy::probe sound does not have a compatible property.\n");
430: }
431: }
432: else{
433: //IOLog("PPCBurgundy::probe this hardware does not have a sound chip\n");
434: }
435: return false;
436: }
437:
438: // --------------------------------------------------------------------------
439: // Method: findHostingHardware
440: //
441: // Purpose:
442: // Finds the kind of hardware we are running on. Since all the older machines
443: // do not have all the information about how burgundy is wired, knowing which
444: // machine we are running on helps to set up the driver correctly.
445: // The method recognizes more machines than the ones that use bugundy (e.g.
446: // "'AAPL,9500'" has an AWACS).
447:
448: int
449: PPCBurgundy::findHostingHardware(IOService *provider)
450: {
451: IOService *topProvider = NULL;
452:
453: // If we already found the machine the driver is running on
454: // just returns the value previously found:
455: if ((machineType >= kMachineTypeUnknown) ||
456: (machineType == 0)) {
457: // if the argument is missing I've to get from myself:
458: if (provider == NULL)
459: provider = getProvider();
460:
461: // See if we find the top of the tree (with the machine type)
462: // iterating all the way up:
463: while (provider != NULL) {
464: topProvider = provider;
465: provider = topProvider->getProvider();
466: }
467:
468: // by default the hardware is unknown:
469: machineType = kMachineTypeUnknown;
470:
471: if (topProvider != NULL) {
472: if (IODTMatchNubWithKeys(topProvider, "'AAPL,9500'"))
473: machineType = kMachine9500;
474: if (IODTMatchNubWithKeys(topProvider, "'AAPL,Gossamer'"))
475: machineType = kMachineGenericGossamer;
476: if (IODTMatchNubWithKeys(topProvider, "'AAPL,PowerMac G3'"))
477: machineType = kMachineTypeSilk;
478: else if (IODTMatchNubWithKeys(topProvider, "'AAPL,PowerBook1998'"))
479: machineType = kMachineTypeWallstreet;
480: else if (IODTMatchNubWithKeys(topProvider, "'iMac,1'"))
481: machineType = kMachineTypeiMac;
482: else if (IODTMatchNubWithKeys(topProvider, "('PowerMac1,1', 'PowerMac1,2')"))
483: machineType = kMachineTypeYosemite;
484: else if (IODTMatchNubWithKeys(topProvider, "'PowerMac3,1'"))
485: machineType = kMachineTypeSawtooth;
486: else if (IODTMatchNubWithKeys(topProvider, "'PowerBook1,1'"))
487: machineType = kMachineType101;
488: else if (IODTMatchNubWithKeys(topProvider, "'PowerBook2,1'"))
489: machineType = kMachineTypeiBook;
490: else
491: IOLog("PPCBurgundy::findHostingHardware unknown machine type\n");
492: }
493: else
494: IOLog("PPCBurgundy::findHostingHardware misses the top provider\n");
495: }
496:
497: //Just to ease up the debugging
498: //IOLog("PPCBurgundy::findHostingHardware found %d\n", machineType);
499:
500: return (machineType);
501: }
502:
503: // --------------------------------------------------------------------------
504: // Method: numberOfInputComponents
505: //
506: // Purpose:
507: // returns the number of components for the input lines
508: // usually are 2 one is the microphone and the other is
509: // microphone jack.
510: #define kCommonNumberOfInputComponents 2
511:
512: int
513: PPCBurgundy::numberOfInputComponents()
514: {
515: if(sound) {
516: OSData *t;
517:
518: t = OSDynamicCast(OSData, sound->getProperty("#-detects"));
519: if (t != NULL) {
520: return *(UInt32*)(t->getBytesNoCopy());
521: }
522: }
523:
524: return kCommonNumberOfInputComponents;
525: }
526:
527: // --------------------------------------------------------------------------
528: // Method: numberOfOutputComponents
529: //
530: // Purpose:
531: // returns the number of components for the output lines
532: // usually are 2 one is the internal speacker and the other
533: // is the headphone line.
534: #define kCommonNumberOfOutputComponents 2
535:
536: int
537: PPCBurgundy::numberOfOutputComponents()
538: {
539: if(sound) {
540: OSData *t;
541:
542: t = OSDynamicCast(OSData, sound->getProperty("#-outputs"));
543: if (t != NULL) {
544: return *(UInt32*)(t->getBytesNoCopy());
545: }
546: }
547: return kCommonNumberOfOutputComponents;
548: }
549:
550:
551: // --------------------------------------------------------------------------
552: // Method: inputFrameRate
553: //
554: // Purpose:
555: // returns the input frame rate as in the registry, if it is
556: // not found in the registry, it returns the default value.
557: #define kCommonInputFrameRate 44100
558:
559: UInt16
560: PPCBurgundy::inputFrameRate()
561: {
562: if(sound) {
563: OSData *t;
564:
565: t = OSDynamicCast(OSData, sound->getProperty("input-frame-rates"));
566: if (t != NULL) {
567: UInt16 fr = *(UInt32*)(t->getBytesNoCopy());
568:
569: #ifdef DEBUGMODE
570: IOLog( "PPCBurgundy::inputFrameRate = %d\n", fr);
571: #endif
572: return fr;
573: }
574: }
575:
576: return kCommonInputFrameRate;
577: }
578:
579:
580: // --------------------------------------------------------------------------
581: // Method: outputFrameRate
582: //
583: // Purpose:
584: // returns the output frame rate as in the registry, if it is
585: // not found in the registry, it returns the default value.
586: #define kCommonOutputFrameRate 44100
587:
588: UInt16
589: PPCBurgundy::outputFrameRate()
590: {
591: if(sound) {
592: OSData *t;
593:
594: t = OSDynamicCast(OSData, sound->getProperty("output-frame-rates"));
595: if (t != NULL) {
596: UInt16 fr = *(UInt32*)(t->getBytesNoCopy());
597:
598: #ifdef DEBUGMODE
599: IOLog( "PPCBurgundy::outputFrameRate = %d\n", fr);
600: #endif
601: return fr;
602: }
603: }
604:
605: return kCommonOutputFrameRate;
606: }
607:
608: // --------------------------------------------------------------------------
609: // Method(s): componentDictionaryXXXXXX
610: //
611: // Purpose:
612: // the next N methods return the strings for the component dictionaries
613: // for each kind of component. As stated in the AWACS driver, these should
614: // end in the driver resources.
615:
616: // NOTE: (This is important !!!) the soundControls enum in the header file is
617: // bounded to the following stings in this way:
618: // for each component the control Id in the string must have the same value
619: // of the corrispondent soundControls enum item. For example the sound control
620: // enum item kHeadphonesVolLeft has value 4, so in sHeadphones the ID of the
621: // volume left control must be 4.
622:
623: char*
624: PPCBurgundy::componentDictionarySpeaker()
625: {
626: static const char *sSpeaker =
627: "{
628: 'Type' = 'Speaker';
629: 'Channels' = 2:8;
630: 'Master' = 1:8;
631: 'Controls' = {
632: 'MuteAll' = {
633: 'Type' = 'Mute';
634: 'Id' = 0:16;
635: 'Val' = 0:8;
636: 'Min' = 0:8;
637: 'Max' = 1:8;
638: 'Chan' = 0:8;
639: };
640: 'VolumeLeft' = {
641: 'Type' = 'Volume';
642: 'Id' = 1:16;
643: 'Val' = 65535:16;
644: 'Min' = 0:16;
645: 'Max' = 65535:16;
646: 'Chan' = 1:8;
647: };
648: 'VolumeRight' = {
649: 'Type' = 'Volume';
650: 'Id' = 2:16;
651: 'Val' = 65535:16;
652: 'Min' = 0:16;
653: 'Max' = 65535:16;
654: 'Chan' = 2:8;
655: };
656: };
657: }";
658: return (char*)sSpeaker;
659: }
660:
661: char*
662: PPCBurgundy::componentDictionaryHeadphones()
663: {
664: static const char *sHeadphones =
665: "{
666: 'Type' = 'Headphones';
667: 'Channels' = 2:8;
668: 'Master' = 1:8;
669: 'Controls' = {
670: 'MuteAll' = {
671: 'Type' = 'Mute';
672: 'Id' = 3:16;
673: 'Val' = 0:8;
674: 'Min' = 0:8;
675: 'Max' = 1:8;
676: 'Chan' = 0:8;
677: };
678: 'VolumeLeft' = {
679: 'Type' = 'Volume';
680: 'Id' = 4:16;
681: 'Val' = 65535:16;
682: 'Min' = 0:16;
683: 'Max' = 65535:16;
684: 'Chan' = 1:8;
685: };
686: 'VolumeRight' = {
687: 'Type' = 'Volume';
688: 'Id' = 5:16;
689: 'Val' = 65535:16;
690: 'Min' = 0:16;
691: 'Max' = 65535:16;
692: 'Chan' = 2:8;
693: };
694: };
695: 'Inputs' = {
696: 'Jack' = {
697: 'Val' = 0:8;
698: 'Min' = 0:8;
699: 'Max' = 1:8;
700: };
701: };
702: }";
703: return (char*)sHeadphones;
704: }
705:
706: char*
707: PPCBurgundy::componentDictionaryMicrophone()
708: {
709: static const char *sMicrophone =
710: "{
711: 'Type' = 'Microphone';
712: 'Channels' = 2:8;
713: 'Controls' = {
714: 'MuteAll' = {
715: 'Type' = 'Mute';
716: 'Id' = 6:16;
717: 'Val' = 0:8;
718: 'Min' = 0:8;
719: 'Max' = 1:8;
720: 'Chan' = 0:8;
721: };
722: };
723: 'Inputs' = {
724: 'Jack' = {
725: 'Val' = 0:8;
726: 'Min' = 0:8;
727: 'Max' = 1:8;
728: };
729: };
730: }";
731: return (char*)sMicrophone;
732: }
733:
734: char*
735: PPCBurgundy::componentDictionaryLinein()
736: {
737: static const char *sLinein =
738: "{
739: 'Type' = 'LineIn';
740: 'Channels' = 2:8;
741: 'Controls' = {
742: 'MuteAll' = {
743: 'Type' = 'Mute';
744: 'Id' = 14:16;
745: 'Val' = 0:8;
746: 'Min' = 0:8;
747: 'Max' = 1:8;
748: 'Chan' = 0:8;
749: };
750: };
751: 'Inputs' = {
752: 'Jack' = {
753: 'Val' = 0:8;
754: 'Min' = 0:8;
755: 'Max' = 1:8;
756: };
757: };
758: }";
759: return (char*)sLinein;
760: }
761:
762: char*
763: PPCBurgundy::componentDictionaryLineout()
764: {
765: static const char *sLineout =
766: "{
767: 'Type' = 'LineOut';
768: 'Channels' = 2:8;
769: 'Controls' = {
770: 'MuteAll' = {
771: 'Type' = 'Mute';
772: 'Id' = 13:16;
773: 'Val' = 0:8;
774: 'Min' = 0:8;
775: 'Max' = 1:8;
776: 'Chan' = 0:8;
777: };
778: };
779: 'Inputs' = {
780: 'Jack' = {
781: 'Val' = 0:8;
782: 'Min' = 0:8;
783: 'Max' = 1:8;
784: };
785: };
786: }";
787: return (char*)sLineout;
788: }
789:
790: char*
791: PPCBurgundy::componentDictionaryCD()
792: {
793: static const char *sCD =
794: "{
795: 'Type' = 'CD';
796: 'Channels' = 2:8;
797: 'Controls' = {
798: 'MuteAll' = {
799: 'Type' = 'Mute';
800: 'Id' = 7:16;
801: 'Val' = 0:8;
802: 'Min' = 0:8;
803: 'Max' = 1:8;
804: 'Chan' = 0:8;
805: };
806: };
807: }";
808: return (char*)sCD;
809: }
810:
811: char*
812: PPCBurgundy::componentDictionaryMixerIn()
813: {
814: static const char *sMixerIn =
815: "{
816: 'Type' = 'Mixer';
817: 'Channels' = 2:8;
818: 'Controls' = {
819: 'VolumeLeft' = {
820: 'Type' = 'Volume';
821: 'Id' = 8:16;
822: 'Val' = 65535:16;
823: 'Min' = 0:16;
824: 'Max' = 65535:16;
825: 'Chan' = 1:8;
826: };
827: 'VolumeRight' = {
828: 'Type' = 'Volume';
829: 'Id' = 9:16;
830: 'Val' = 65535:16;
831: 'Min' = 0:16;
832: 'Max' = 65535:16;
833: 'Chan' = 2:8;
834: };
835: };
836: }";
837: return (char*)sMixerIn;
838: }
839:
840: char*
841: PPCBurgundy::componentDictionaryMixerOut()
842: {
843: static const char *sMixerOut =
844: "{
845: 'Type' = 'Mixer';
846: 'Channels' = 2:8;
847: }";
848: return (char*)sMixerOut;
849: }
850:
851: char*
852: PPCBurgundy::componentDictionaryPassThru()
853: {
854: static const char *sPassThru =
855: "{
856: 'Type' = 'Feature';
857: 'Channels' = 2:8;
858: 'Controls' = {
859: 'MuteAll' = {
860: 'Type' = 'Mute';
861: 'Id' = 12:16;
862: 'Val' = 1:8;
863: 'Min' = 0:8;
864: 'Max' = 1:8;
865: 'Chan' = 0:8;
866: };
867: 'VolumeLeft' = {
868: 'Type' = 'Volume';
869: 'Id' = 10:16;
870: 'Val' = 65535:16;
871: 'Min' = 0:16;
872: 'Max' = 65535:16;
873: 'Chan' = 1:8;
874: };
875: 'VolumeRight' = {
876: 'Type' = 'Volume';
877: 'Id' = 11:16;
878: 'Val' = 65535:16;
879: 'Min' = 0:16;
880: 'Max' = 65535:16;
881: 'Chan' = 2:8;
882: };
883: };
884: }";
885: return (char*)sPassThru;
886: }
887:
888: // --------------------------------------------------------------------------
889: // Method: dependentSetup
890: //
891: // Purpose:
892: // this handles the setup of the burgundy chip for each kind of
893: // hosting hardware.
894: bool
895: PPCBurgundy::dependentSetup()
896: {
897: UInt32 OSReg = 0;
898:
899: //
900: // G3-Gossamer DVD-card assignments (Bordeaux)
901: //
902: // Port 17 - Internal speaker
903: // Port 15 - Rear panel RCA Out
904: // Port 16 - Rear panel MiniJack Out
905: //
906: // Yosemite assignments
907: //
908: // Port 17 - Internal speaker
909: // Port 14 - Rear panel MiniJack Out
910: //
911: writeCodecReg( ioBaseBurgundy, kOutputLvlPort17Reg, kOutputLvl_Default );
912:
913: switch (findHostingHardware(NULL))
914: {
915: case kMachineTypeSilk:
916: // G3-Gossamer DVD-card
917: assert(isBordeaux);
918: writeCodecReg( ioBaseBurgundy, kOutputLvlPort15Reg, kOutputLvl_Default );
919: writeCodecReg( ioBaseBurgundy, kOutputLvlPort16Reg, kOutputLvl_Default );
920:
921: writeCodecReg( ioBaseBurgundy, kGAP1LReg, kGAP_Default_Gain );
922: writeCodecReg( ioBaseBurgundy, kGAP1RReg, kGAP_Default_Gain );
923:
924: currentOutputMuteReg = kOutputMuteReg_Port15L | kOutputMuteReg_Port15R |
925: kOutputMuteReg_Port16L | kOutputMuteReg_Port16R |
926: kOutputMuteReg_Port17M;
927:
928: OSReg = kOSReg_OS0_Select_MXO1 | kOSReg_OS1_Select_MXO1;
929: break;
930:
931: case kMachineTypeiMac:
932: case kMachineTypeYosemite:
933: // Yosemite: (FIXME as soon as newwolds works I should move this in the newworld handling
934: // this should be done also for the others switch statements in this file)
935: writeCodecReg( ioBaseBurgundy, kOutputLvlPort14Reg, kOutputLvl_Default );
936:
937: currentOutputMuteReg = kOutputMuteReg_Port14L | kOutputMuteReg_Port14R |
938: kOutputMuteReg_Port17M;
939:
940: OSReg = kOSReg_OS0_Select_MXO1;
941: break;
942: default:
943: // FIXME: this may be a newworld, so the registry holds
944: // all we need to know about how the burgundy is wired:
945: // Add here the code to interpret it.
946: break;
947: }
948:
949: writeCodecReg( ioBaseBurgundy, kOSReg, OSReg );
950: writeCodecReg( ioBaseBurgundy, kOutputMuteReg, currentOutputMuteReg );
951: writeCodecReg( ioBaseBurgundy, kOutputCtl0Reg, kOutputCtl0Reg_OutCtl1_High );
952:
953: // while this acts on the analog volume controls
954: writeCodecReg( ioBaseBurgundy, kOutputLvlPort13Reg, 0x00);
955: writeCodecReg( ioBaseBurgundy, kOutputLvlPort14Reg, 0x00);
956: writeCodecReg( ioBaseBurgundy, kOutputLvlPort15Reg, 0x00);
957: writeCodecReg( ioBaseBurgundy, kOutputLvlPort16Reg, 0x00);
958: writeCodecReg( ioBaseBurgundy, kOutputLvlPort17Reg, 0x00);
959:
960: // and writes the digital volumes:
961: writeCodecReg( ioBaseBurgundy, kGAP0LReg, 0xFF);
962: writeCodecReg( ioBaseBurgundy, kGAP1LReg, 0xFF);
963: writeCodecReg( ioBaseBurgundy, kGAP2LReg, 0xFF);
964: writeCodecReg( ioBaseBurgundy, kGAP3LReg, 0xFF);
965:
966: writeCodecReg( ioBaseBurgundy, kGAP0RReg, 0xFF);
967: writeCodecReg( ioBaseBurgundy, kGAP1RReg, 0xFF);
968: writeCodecReg( ioBaseBurgundy, kGAP2RReg, 0xFF);
969: writeCodecReg( ioBaseBurgundy, kGAP3RReg, 0xFF);
970: return true;
971: }
972:
973: // --------------------------------------------------------------------------
974: // Method: checkStatusRegister
975: //
976: // Purpose:
977: // if the argument is true mutes the internal speaker, otherwise
978: // it "unmutes" it.
979: void
980: PPCBurgundy::checkStatusRegister()
981: {
982: if (burgundyStatusChanged()) {
983: int i;
984:
985: OSNumber * num = OSNumber::withNumber(lastStatusRegister, 32);
986: setProperty("Status", num);
987: num->release();
988:
989: #ifdef DEBUGMODE
990: IOLog("Status changes in: 0x%08lx\n", lastStatusRegister);
991: #endif
992: // Something changed, act on it:
993: // For each sense line we call the action attached
994: // to thar sense line:
995: for (i = 0; i < numInputComponents; i++)
996: if (fInputComponents[i] != NULL)
997: fInputComponents[i]->Set(gInputsSym, gJackSym, inputComponentStatus(i));
998:
999: for (i = 0; i < numOutputComponents; i++)
1000: if (fOutputComponents[i] != NULL)
1001: fOutputComponents[i]->Set(gInputsSym, gJackSym, outputComponentStatus(i));
1002: }
1003: }
1004:
1005: // --------------------------------------------------------------------------
1006: // Method: inputComponentStatus
1007: //
1008: // Purpose:
1009: // checks the status of the jack line of the ith output component:
1010: bool
1011: PPCBurgundy::inputComponentStatus(int index)
1012: {
1013: switch(index)
1014: {
1015: case kMicroPhone: // check the microphone
1016: return microphoneInserted();
1017:
1018: case kCD: // the cd input is not associated to a jack
1019: return false;
1020:
1021: case kLineIn: // the RCA line does not have a jack
1022: return false;
1023: }
1024:
1025: return false; // by deafult there is no jack
1026: }
1027:
1028:
1029: // --------------------------------------------------------------------------
1030: // Method: outputComponentStatus
1031: //
1032: // Purpose:
1033: // checks the status of the jack line of the ith output component:
1034: bool
1035: PPCBurgundy::outputComponentStatus(int index)
1036: {
1037: switch(index)
1038: {
1039: case kSpeaker:
1040: return false; // the internal speaker does not have a jack
1041:
1042: case kHeadphones: // check the headphones:
1043: return headphonesInserted();
1044:
1045: case kLineOut:
1046: return false; // the RCA line does not have a jack
1047: }
1048:
1049: return false; // by deafult there is no jack
1050: }
1051:
1052: // --------------------------------------------------------------------------
1053: // Method: muteInternalSpeaker
1054: //
1055: // Purpose:
1056: // if the argument is true mutes the internal speaker, otherwise
1057: // it "unmutes" it.
1058:
1059: void
1060: PPCBurgundy::muteInternalSpeaker(bool mute)
1061: {
1062: UInt32 outputSourceMask = 0;
1063:
1064: switch (findHostingHardware(NULL))
1065: {
1066: case kMachineTypeSilk:
1067: // G3-Gossamer DVD-card
1068: assert(isBordeaux);
1069: outputSourceMask = kOutputMuteReg_Port17M;
1070: break;
1071:
1072: case kMachineTypeiMac:
1073: // iMac: (FIXME as soon as newwolds works I should move this in the newworld handling)
1074: outputSourceMask = kOutputMuteReg_Port14L | kOutputMuteReg_Port14R;
1075: break;
1076:
1077: case kMachineTypeYosemite:
1078: outputSourceMask = kOutputMuteReg_Port17M;
1079: break;
1080:
1081: default:
1082: // FIXME: this may be a newworld, so the registry holds
1083: // all we need to know about how the burgundy is wired:
1084: // Add here the code to interpret it.
1085: break;
1086: }
1087:
1088: if (mute)
1089: currentOutputMuteReg &= ~outputSourceMask;
1090: else
1091: currentOutputMuteReg |= outputSourceMask;
1092:
1093: writeCodecReg(ioBaseBurgundy, kOutputMuteReg, currentOutputMuteReg);
1094: }
1095:
1096: // --------------------------------------------------------------------------
1097: // Method: muteRCAOutput
1098: //
1099: // Purpose:
1100: // if the argument is true mutes the rear panel RCA, otherwise
1101: // it "unmutes" it.
1102: void
1103: PPCBurgundy::muteRCAOutput(bool mute)
1104: {
1105: UInt32 outputSourceMask = 0;
1106:
1107: switch (findHostingHardware(NULL))
1108: {
1109: case kMachineTypeSilk:
1110: // G3-Gossamer DVD-card
1111: assert(isBordeaux);
1112: outputSourceMask = kOutputMuteReg_Port15L | kOutputMuteReg_Port15R;
1113: break;
1114:
1115: case kMachineTypeYosemite:
1116: // Yosemite does not have an RCA
1117: outputSourceMask = 0;
1118: break;
1119:
1120: default:
1121: // FIXME: this may be a newworld, so the registry holds
1122: // all we need to know about how the burgundy is wired:
1123: // Add here the code to interpret it.
1124: outputSourceMask = 0;
1125: break;
1126: }
1127:
1128: if (mute)
1129: currentOutputMuteReg &= ~outputSourceMask;
1130: else
1131: currentOutputMuteReg |= outputSourceMask;
1132:
1133: writeCodecReg(ioBaseBurgundy, kOutputMuteReg, currentOutputMuteReg);
1134: }
1135:
1136: // --------------------------------------------------------------------------
1137: // Method: muteHeadphones
1138: //
1139: // Purpose:
1140: // if the argument is true mutes the rear panel mini jack, otherwise
1141: // it "unmutes" it.
1142: void
1143: PPCBurgundy::muteHeadphones(bool mute)
1144: {
1145: UInt32 outputSourceMask = 0;
1146:
1147: switch (findHostingHardware(NULL))
1148: {
1149: case kMachineTypeSilk:
1150: // G3-Gossamer DVD-card
1151: assert(isBordeaux);
1152: outputSourceMask = kOutputMuteReg_Port16L | kOutputMuteReg_Port16R;
1153: break;
1154:
1155: case kMachineTypeiMac:
1156: // iMac: (FIXME I do not know how this is wired, as soon as I have the iMac motherboard I should fix it)
1157: outputSourceMask |= kOutputMuteReg_Port15L | kOutputMuteReg_Port15R;
1158: outputSourceMask |= kOutputMuteReg_Port16L | kOutputMuteReg_Port16R;
1159: outputSourceMask |= kOutputMuteReg_Port13M | kOutputMuteReg_Port17M;
1160: break;
1161:
1162: case kMachineTypeYosemite:
1163: // Yosemite: (FIXME as soon as newwolds works I should move this in the newworld handling)
1164: outputSourceMask = kOutputMuteReg_Port14L | kOutputMuteReg_Port14R;
1165: break;
1166:
1167: default:
1168: // FIXME: this may be a newworld, so the registry holds
1169: // all we need to know about how the burgundy is wired:
1170: // Add here the code to interpret it.
1171: break;
1172: }
1173:
1174: if (mute)
1175: currentOutputMuteReg &= ~outputSourceMask;
1176: else
1177: currentOutputMuteReg |= outputSourceMask;
1178:
1179: writeCodecReg(ioBaseBurgundy, kOutputMuteReg, currentOutputMuteReg);
1180: }
1181:
1182: // --------------------------------------------------------------------------
1183: // Method: muteCDLine
1184: //
1185: // Purpose:
1186: // if the argument is true mutes the line of the cd player
1187: void
1188: PPCBurgundy::muteCDLine(bool mute)
1189: {
1190: // FIXME: Figure out how this is wired up:
1191: }
1192:
1193: // --------------------------------------------------------------------------
1194: // Method: setMicInput
1195: //
1196: // Purpose:
1197: // selects the microphone as input source (if bool = true)
1198: void
1199: PPCBurgundy::setMicInput(bool mic)
1200: {
1201: UInt32 reg;
1202:
1203: #ifdef DEBUGMODE
1204: IOLog( "PPCBurgundy::setMicInput: %s\n", (mic ? "True" : "False"));
1205: #endif
1206:
1207: if (mic) {
1208: reg = readCodecReg( ioBaseBurgundy, kMux2Reg );
1209: reg |= kMux2Reg_Mux2L_SelectPort6L | kMux2Reg_Mux2R_SelectPort6R;
1210: writeCodecReg( ioBaseBurgundy, kMux2Reg, reg );
1211:
1212: reg = readCodecReg( ioBaseBurgundy, kMX3Reg );
1213: reg |= kMX3Reg_Select_IS2L | kMX3Reg_Select_IS2R;
1214: writeCodecReg( ioBaseBurgundy, kMX3Reg, reg);
1215:
1216: reg = readCodecReg( ioBaseBurgundy, kOSReg );
1217: reg |= kOSReg_OSE_Select_MXO3;
1218: writeCodecReg( ioBaseBurgundy, kOSReg, reg );
1219:
1220: reg = readCodecReg( ioBaseBurgundy, kSDOutReg );
1221: reg |= kSDOutReg_OSE_To_SF0;
1222: writeCodecReg( ioBaseBurgundy, kSDOutReg, reg );
1223: }
1224: else {
1225: reg = readCodecReg( ioBaseBurgundy, kMux2Reg );
1226: reg &= ~(kMux2Reg_Mux2L_SelectPort6L | kMux2Reg_Mux2R_SelectPort6R);
1227: writeCodecReg( ioBaseBurgundy, kMux2Reg, reg );
1228:
1229: reg = readCodecReg( ioBaseBurgundy, kMX3Reg );
1230: reg &= ~(kMX3Reg_Select_IS2L | kMX3Reg_Select_IS2R);
1231: writeCodecReg( ioBaseBurgundy, kMX3Reg, reg);
1232:
1233: reg = readCodecReg( ioBaseBurgundy, kOSReg );
1234: reg &= ~kOSReg_OSE_Select_MXO3;
1235: writeCodecReg( ioBaseBurgundy, kOSReg, reg );
1236:
1237: reg = readCodecReg( ioBaseBurgundy, kSDOutReg );
1238: reg &= ~kSDOutReg_OSE_To_SF0;
1239: writeCodecReg( ioBaseBurgundy, kSDOutReg, reg );
1240: }
1241: }
1242:
1243:
1244: // --------------------------------------------------------------------------
1245: // Method: burgundyStatusChanged()
1246: //
1247: // Purpose:
1248: // returns true if something changed in the status register:.
1249: bool
1250: PPCBurgundy::burgundyStatusChanged()
1251: {
1252: UInt32 currentStatusRegister = readCodecSenseLines(ioBaseBurgundy);
1253: bool returnValue = (currentStatusRegister != lastStatusRegister);
1254: lastStatusRegister = currentStatusRegister;
1255:
1256: return (returnValue);
1257: }
1258:
1259: // --------------------------------------------------------------------------
1260: // Method: headphonesInserted
1261: //
1262: // Purpose:
1263: // returns true if the headphones are inserted.
1264: bool
1265: PPCBurgundy::headphonesInserted()
1266: {
1267: UInt32 codecSense;
1268: UInt32 inputSourceMask = 0;
1269:
1270: switch (findHostingHardware(NULL))
1271: {
1272: case kMachineTypeSilk:
1273: // G3-Gossamer DVD-card
1274: assert(isBordeaux);
1275: inputSourceMask = kCodecStatusReg_Sense_Headphones;
1276: break;
1277:
1278: case kMachineTypeiMac:
1279: // iMac: (FIXME as soon as newwolds works I should move this in the newworld handling)
1280: inputSourceMask = kCodecStatusReg_Sense_Headphones | kCodecStatusReg_Sense_Headphones2 | kCodecStatusReg_Sense_Bit;
1281: break;
1282:
1283: case kMachineTypeYosemite:
1284: // Yosemite: (FIXME as soon as newwolds works I should move this in the newworld handling)
1285: inputSourceMask = kCodecStatusReg_Sense_Headphones;
1286: break;
1287:
1288: default:
1289: // FIXME: this may be a newworld, so the registry holds
1290: // all we need to know about how the burgundy is wired:
1291: // Add here the code to interpret it.
1292: break;
1293: }
1294:
1295: codecSense = readCodecSenseLines(ioBaseBurgundy);
1296:
1297: #ifdef DEBUGMODE
1298: IOLog( "PPCBurgundy::headphonesInserted = %d\n\r", (codecSense & inputSourceMask) != 0);
1299: #endif
1300:
1301: return (codecSense & inputSourceMask) != 0;
1302: }
1303:
1304:
1305: // --------------------------------------------------------------------------
1306: // Method: microphoneInserted
1307: //
1308: // Purpose:
1309: // returns true if the microphone is inserted.
1310: bool
1311: PPCBurgundy::microphoneInserted()
1312: {
1313: UInt32 codecSense;
1314: UInt32 inputSourceMask = 0;
1315:
1316: switch (findHostingHardware(NULL))
1317: {
1318: case kMachineTypeSilk:
1319: // G3-Gossamer DVD-card
1320: assert(isBordeaux);
1321: inputSourceMask = kCodecStatusReg_Sense_Mic;
1322: break;
1323:
1324: case kMachineTypeiMac:
1325: // iMac: (FIXME as soon as newwolds works I should move this in the newworld handling)
1326: inputSourceMask = kCodecStatusReg_Sense_Mic;
1327: break;
1328:
1329: case kMachineTypeYosemite:
1330: // Yosemite: (FIXME as soon as newwolds works I should move this in the newworld handling)
1331: inputSourceMask = kCodecStatusReg_Sense_Mic;
1332: break;
1333:
1334: default:
1335: // FIXME: this may be a newworld, so the registry holds
1336: // all we need to know about how the burgundy is wired:
1337: // Add here the code to interpret it.
1338: break;
1339: }
1340:
1341: codecSense = readCodecSenseLines(ioBaseBurgundy);
1342:
1343: #ifdef DEBUGMODE
1344: IOLog( "PPCBurgundy::microphoneInserted = %d\n\r", (codecSense & inputSourceMask) != 0);
1345: #endif
1346:
1347: // FIXME: This should not be necessary, but since it does not work by default
1348: // I'll add this call myself:
1349: setMicInput((codecSense & inputSourceMask) != 0);
1350:
1351: return (codecSense & inputSourceMask) != 0;
1352: }
1353:
1354: // --------------------------------------------------------------------------
1355: // Method: scaleVolume
1356: //
1357: // Purpose:
1358: // Scale the volume to the range used by burgundy:
1359: // note, this considers that the volume can range from
1360: // 0 to 65536 as in the control strings above (e.g. componentDictionaryMixerIn)
1361: UInt8
1362: PPCBurgundy::scaleVolume(int vol)
1363: {
1364: int output;
1365:
1366: output = vol / 4096;
1367:
1368: if ( output > 15 )
1369: output = 15;
1370:
1371: if (output < 0 )
1372: output = 0;
1373:
1374: #ifdef DEBUGMODE
1375: IOLog("Volume input: %d, output (scaled) %d\n", vol, output);
1376: #endif
1377:
1378: return (UInt8)output;
1379: }
1380:
1381: // --------------------------------------------------------------------------
1382: // Method: volumeHeadphonesLeft & volumeHeadphonesRight
1383: //
1384: // Purpose:
1385: // sets the volume for the left and right channel of the internal
1386: // headphones.
1387: void
1388: PPCBurgundy::volumeHeadphonesLeft(int vol)
1389: {
1390: // FIXME: This sets all the output volumes, but we may wish to have
1391: // a more discriminating volume handling. As soon as I know for sure
1392: // how burgundy is wired we can do it. For now this should be fine.
1393: volumeAllLeft(vol);
1394: }
1395:
1396: void
1397: PPCBurgundy::volumeHeadphonesRight(int vol)
1398: {
1399: // FIXME: This sets all the output volumes, but we may wish to have
1400: // a more discriminating volume handling. As soon as I know for sure
1401: // how burgundy is wired we can do it. For now this should be fine.
1402: volumeAllRight(vol);
1403: }
1404:
1405: // --------------------------------------------------------------------------
1406: // Method: volumeInternalSpeakerLeft & volumeInternalSpeakerRight
1407: //
1408: // Purpose:
1409: // sets the volume for the left and right channel of the internal
1410: // speaker.
1411: void
1412: PPCBurgundy::volumeInternalSpeakerLeft(int vol)
1413: {
1414: // FIXME: This sets all the output volumes, but we may wish to have
1415: // a more discriminating volume handling. As soon as I know for sure
1416: // how burgundy is wired we can do it. For now this should be fine.
1417: volumeAllLeft(vol);
1418: }
1419:
1420: void
1421: PPCBurgundy::volumeInternalSpeakerRight(int vol)
1422: {
1423: // FIXME: This sets all the output volumes, but we may wish to have
1424: // a more discriminating volume handling. As soon as I know for sure
1425: // how burgundy is wired we can do it. For now this should be fine.
1426: volumeAllRight(vol);
1427: }
1428:
1429: // --------------------------------------------------------------------------
1430: // Method: volumeCDLineLeft & volumeCDLineRight
1431: //
1432: // Purpose:
1433: // sets the volume for the left and right channel of the CD
1434: // line.
1435: void
1436: PPCBurgundy::volumeCDLineLeft(int vol)
1437: {
1438: // FIXME: This sets all the output volumes, but we may wish to have
1439: // a more discriminating volume handling. As soon as I know for sure
1440: // how burgundy is wired we can do it. For now this should be fine.
1441: volumeAllLeft(vol);
1442: }
1443:
1444: void
1445: PPCBurgundy::volumeCDLineRight(int vol)
1446: {
1447: // FIXME: This sets all the output volumes, but we may wish to have
1448: // a more discriminating volume handling. As soon as I know for sure
1449: // how burgundy is wired we can do it. For now this should be fine.
1450: volumeAllRight(vol);
1451: }
1452:
1453: // --------------------------------------------------------------------------
1454: // Method: volumeRCAOutputLeft & volumeRCAOutputRight
1455: //
1456: // Purpose:
1457: // sets the volume for the left and right channel of the RCA
1458: // line.
1459: void
1460: PPCBurgundy::volumeRCAOutputLeft(int vol)
1461: {
1462: // FIXME: This sets all the output volumes, but we may wish to have
1463: // a more discriminating volume handling. As soon as I know for sure
1464: // how burgundy is wired we can do it. For now this should be fine.
1465: volumeAllLeft(vol);
1466: }
1467:
1468: void
1469: PPCBurgundy::volumeRCAOutputRight(int vol)
1470: {
1471: // FIXME: This sets all the output volumes, but we may wish to have
1472: // a more discriminating volume handling. As soon as I know for sure
1473: // how burgundy is wired we can do it. For now this should be fine.
1474: volumeAllRight(vol);
1475: }
1476:
1477: // --------------------------------------------------------------------------
1478: // Method: volumeAllRight & volumeAllLeft
1479: //
1480: // Purpose:
1481: // sets the volume to all the output ports. This is because I do not
1482: // really know how burgundy is wired up. (and because however the
1483: // OS has only one control for the volume).
1484: void
1485: PPCBurgundy::volumeAllLeft(int vol)
1486: {
1487: UInt8 newVol = scaleVolume(vol);
1488:
1489: // This changes all the digital volume controls (used only to mute and unmute the oputput)
1490: if (newVol > 0) {
1491: writeCodecReg( ioBaseBurgundy, kGAP0LReg, 0xFF);
1492: writeCodecReg( ioBaseBurgundy, kGAP1LReg, 0xFF);
1493: writeCodecReg( ioBaseBurgundy, kGAP2LReg, 0xFF);
1494: writeCodecReg( ioBaseBurgundy, kGAP3LReg, 0xFF);
1495: }
1496: else {
1497: writeCodecReg( ioBaseBurgundy, kGAP0LReg, 0x00);
1498: writeCodecReg( ioBaseBurgundy, kGAP1LReg, 0x00);
1499: writeCodecReg( ioBaseBurgundy, kGAP2LReg, 0x00);
1500: writeCodecReg( ioBaseBurgundy, kGAP3LReg, 0x00);
1501: }
1502:
1503: // while this acts on the analog volume controls
1504: newVol = 15 - newVol;
1505: writeCodecReg( ioBaseBurgundy, kOutputLvlPort13Reg, (readCodecReg(ioBaseBurgundy, kOutputLvlPort13Reg) & 0xF0) | (newVol & 0x0F));
1506: writeCodecReg( ioBaseBurgundy, kOutputLvlPort14Reg, (readCodecReg(ioBaseBurgundy, kOutputLvlPort14Reg) & 0xF0) | (newVol & 0x0F));
1507: writeCodecReg( ioBaseBurgundy, kOutputLvlPort15Reg, (readCodecReg(ioBaseBurgundy, kOutputLvlPort15Reg) & 0xF0) | (newVol & 0x0F));
1508: writeCodecReg( ioBaseBurgundy, kOutputLvlPort16Reg, (readCodecReg(ioBaseBurgundy, kOutputLvlPort16Reg) & 0xF0) | (newVol & 0x0F));
1509: writeCodecReg( ioBaseBurgundy, kOutputLvlPort17Reg, (readCodecReg(ioBaseBurgundy, kOutputLvlPort17Reg) & 0xF0) | (newVol & 0x0F));
1510: }
1511:
1512: void
1513: PPCBurgundy::volumeAllRight(int vol)
1514: {
1515: UInt8 newVol = scaleVolume(vol);
1516:
1517: // This changes all the digital volume controls (used only to mute and unmute the oputput)
1518: if (newVol > 0) {
1519: writeCodecReg( ioBaseBurgundy, kGAP0RReg, 0xFF);
1520: writeCodecReg( ioBaseBurgundy, kGAP1RReg, 0xFF);
1521: writeCodecReg( ioBaseBurgundy, kGAP2RReg, 0xFF);
1522: writeCodecReg( ioBaseBurgundy, kGAP3RReg, 0xFF);
1523: }
1524: else {
1525: writeCodecReg( ioBaseBurgundy, kGAP0RReg, 0x00);
1526: writeCodecReg( ioBaseBurgundy, kGAP1RReg, 0x00);
1527: writeCodecReg( ioBaseBurgundy, kGAP2RReg, 0x00);
1528: writeCodecReg( ioBaseBurgundy, kGAP3RReg, 0x00);
1529: }
1530:
1531: // while this acts on the analog volume controls
1532: newVol = (15 - newVol) << 4;
1533: writeCodecReg( ioBaseBurgundy, kOutputLvlPort13Reg, (readCodecReg(ioBaseBurgundy, kOutputLvlPort13Reg) & 0x0F) | (newVol & 0xF0));
1534: writeCodecReg( ioBaseBurgundy, kOutputLvlPort14Reg, (readCodecReg(ioBaseBurgundy, kOutputLvlPort14Reg) & 0x0F) | (newVol & 0xF0));
1535: writeCodecReg( ioBaseBurgundy, kOutputLvlPort15Reg, (readCodecReg(ioBaseBurgundy, kOutputLvlPort15Reg) & 0x0F) | (newVol & 0xF0));
1536: writeCodecReg( ioBaseBurgundy, kOutputLvlPort16Reg, (readCodecReg(ioBaseBurgundy, kOutputLvlPort16Reg) & 0x0F) | (newVol & 0xF0));
1537: writeCodecReg( ioBaseBurgundy, kOutputLvlPort17Reg, (readCodecReg(ioBaseBurgundy, kOutputLvlPort17Reg) & 0x0F) | (newVol & 0xF0));
1538: }
1539:
1540:
1541: // --------------------------------------------------------------------------
1542: // Method: volumeMixerInLeft
1543: //
1544: // Purpose:
1545: // sets the gain for the input left line
1546: void
1547: PPCBurgundy::volumeMixerInLeft(int vol)
1548: {
1549: UInt8 left = scaleVolume(vol);
1550:
1551: writeCodecReg( ioBaseBurgundy, kVGA2Reg, 0x44 );
1552: writeCodecReg( ioBaseBurgundy, kGAS2LReg, left );
1553: }
1554:
1555: // --------------------------------------------------------------------------
1556: // Method: volumeMixerInRight
1557: //
1558: // Purpose:
1559: // sets the gain for the input right line
1560: void
1561: PPCBurgundy::volumeMixerInRight(int vol)
1562: {
1563: UInt8 right = scaleVolume(vol);
1564:
1565: writeCodecReg( ioBaseBurgundy, kVGA2Reg, 0x44 );
1566: writeCodecReg( ioBaseBurgundy, kGAS2RReg, right );
1567: }
1568:
1569:
1570: /* =============================================================
1571: * VERY Private Methods used to access to the burgundy registers
1572: * ============================================================= */
1573:
1574: static void
1575: writeCodecReg( volatile UInt8 *ioBaseBurgundy, int regInfo, int value )
1576: {
1577: u_int32_t regBits;
1578: u_int32_t regValue;
1579: u_int32_t i;
1580: volatile u_int32_t CodecControlReg;
1581:
1582: struct _reg
1583: {
1584: UInt8 unused0;
1585: UInt8 size;
1586: UInt8 addr;
1587: UInt8 offset;
1588: } *reg = (struct _reg *)®Info;
1589:
1590:
1591: regBits = (kCodecCtlReg_Write | kCodecCtlReg_Reset)
1592: | ((u_int32_t) reg->addr * kCodecCtlReg_Addr_Bit)
1593: | ((u_int32_t)(reg->size + reg->offset - 1) * kCodecCtlReg_LastByte_Bit);
1594:
1595: for ( i=0; i < reg->size; i++ )
1596: {
1597: regValue = regBits | ((u_int32_t)(reg->offset + i) * kCodecCtlReg_CurrentByte_Bit) | (value & 0xFF);
1598: OSWriteLittleInt32(ioBaseBurgundy, kCodecCtlReg, regValue );
1599: eieio();
1600:
1601: #ifdef DEBUGMODE
1602: IOLog( "PPCSound(burgundy): CodecWrite = %08x\n\r", regValue );
1603: #endif
1604:
1605: value >>= 8;
1606:
1607: regBits &= ~kCodecCtlReg_Reset;
1608:
1609: do
1610: {
1611: CodecControlReg = OSReadLittleInt32( ioBaseBurgundy, kCodecCtlReg );
1612: eieio();
1613: }
1614: while ( CodecControlReg & kCodecCtlReg_Busy );
1615: }
1616: }
1617:
1618:
1619: static int
1620: readCodecReg( volatile UInt8 *ioBaseBurgundy, int regInfo )
1621: {
1622: u_int32_t regBits;
1623: u_int32_t regValue = 0;
1624: u_int32_t i,j;
1625: int value;
1626: u_int32_t byteCounter;
1627: u_int32_t currentCounter;
1628: volatile u_int32_t CodecControlReg;
1629: volatile u_int32_t CodecStatusReg;
1630:
1631:
1632: struct _reg
1633: {
1634: UInt8 unused0;
1635: UInt8 size;
1636: UInt8 addr;
1637: UInt8 offset;
1638: } *reg = (struct _reg *)®Info;
1639:
1640: value = 0;
1641:
1642: regBits = (kCodecCtlReg_Reset)
1643: | ((u_int32_t) reg->addr * kCodecCtlReg_Addr_Bit)
1644: | ((u_int32_t)(reg->size + reg->offset - 1) * kCodecCtlReg_LastByte_Bit);
1645:
1646: CodecStatusReg = OSReadLittleInt32( ioBaseBurgundy, kCodecStatusReg );
1647: eieio();
1648: byteCounter = ((CodecStatusReg & kCodecStatusReg_ByteCounter_Mask) / kCodecStatusReg_ByteCounter_Bit + 1) & 0x03;
1649:
1650: for ( i=0; i < reg->size; i++ )
1651: {
1652: regValue = regBits | ((u_int32_t)(reg->offset + i) * kCodecCtlReg_CurrentByte_Bit);
1653: OSWriteLittleInt32(ioBaseBurgundy, kCodecCtlReg, regValue );
1654: eieio();
1655: regBits &= ~kCodecCtlReg_Reset;
1656:
1657: do
1658: {
1659: CodecControlReg = OSReadLittleInt32( ioBaseBurgundy, kCodecCtlReg );
1660: eieio();
1661: }
1662: while ( CodecControlReg & kCodecCtlReg_Busy );
1663:
1664: j=0;
1665: do
1666: {
1667: CodecStatusReg = OSReadLittleInt32( ioBaseBurgundy, kCodecStatusReg );
1668: eieio();
1669: currentCounter = ((CodecStatusReg & kCodecStatusReg_ByteCounter_Mask) / kCodecStatusReg_ByteCounter_Bit) & 0x03;
1670: }
1671: while ( (byteCounter != currentCounter) && (j++ < 1000));
1672:
1673: byteCounter++;
1674:
1675: IODelay(10);
1676: CodecStatusReg = OSReadLittleInt32( ioBaseBurgundy, kCodecStatusReg );
1677:
1678: value |= ((CodecStatusReg & kCodecStatusReg_Data_Mask) / kCodecStatusReg_Data_Bit) << 8*i;
1679: }
1680:
1681: #ifdef DEBUGMODE
1682: IOLog( "PPCSound(burgundy): CodecRead = %08x %08x\n\r", regValue, value );
1683: #endif
1684:
1685: return value;
1686: }
1687:
1688: static int
1689: readCodecSenseLines( volatile UInt8 *ioBaseBurgundy )
1690: {
1691: return ((OSReadLittleInt32( ioBaseBurgundy, kCodecStatusReg ) / kCodecStatusReg_Sense_Bit) & kCodecStatusReg_Sense_Mask);
1692: }
1693:
1694:
1695: static void
1696: writeSoundControlReg( volatile UInt8 *ioBaseBurgundy, int value )
1697: {
1698:
1699: #ifdef DEBUGMODE
1700: IOLog( "PPCSound(burgundy): SoundControlReg = %08x\n", value);
1701: #endif
1702:
1703: OSWriteLittleInt32( ioBaseBurgundy, kSoundCtlReg, value );
1704: eieio();
1705: }
1706:
1707:
1708:
1709:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.