1/*
2 *  IOFireWireConfigDirectory.cpp
3 *  IOFireWireFamily
4 *
5 *  Created by NWG on Thu Jan 18 2001.
6 *  Copyright (c) 2000 Apple, Inc. All rights reserved.
7 *
8 */
9
10
11#import "IOFireWireLibConfigDirectory.h"
12#import "IOFireWireLibDevice.h"
13
14#import <System/libkern/OSCrossEndian.h>
15
16namespace IOFireWireLib {
17
18	ConfigDirectoryCOM::Interface 	ConfigDirectoryCOM::sInterface = {
19		INTERFACEIMP_INTERFACE,
20		1, 0, //vers, rev
21		& ConfigDirectoryCOM::SUpdate,
22		& ConfigDirectoryCOM::SGetKeyType,
23		& ConfigDirectoryCOM::SGetKeyValue_UInt32,
24		& ConfigDirectoryCOM::SGetKeyValue_Data,
25		& ConfigDirectoryCOM::SGetKeyValue_ConfigDirectory,
26		& ConfigDirectoryCOM::SGetKeyOffset_FWAddress,
27		& ConfigDirectoryCOM::SGetIndexType,
28		& ConfigDirectoryCOM::SGetIndexKey,
29		& ConfigDirectoryCOM::SGetIndexValue_UInt32,
30		& ConfigDirectoryCOM::SGetIndexValue_Data,
31		& ConfigDirectoryCOM::SGetIndexValue_String,
32		& ConfigDirectoryCOM::SGetIndexValue_ConfigDirectory,
33		& ConfigDirectoryCOM::SGetIndexOffset_FWAddress,
34		& ConfigDirectoryCOM::SGetIndexOffset_UInt32,
35		& ConfigDirectoryCOM::SGetIndexEntry,
36		& ConfigDirectoryCOM::SGetSubdirectories,
37		& ConfigDirectoryCOM::SGetKeySubdirectories,
38		& ConfigDirectoryCOM::SGetType,
39		& ConfigDirectoryCOM::SGetNumEntries
40	} ;
41
42
43	// ============================================================
44	//
45	// ConfigDirectory
46	//
47	// ============================================================
48
49	ConfigDirectory::ConfigDirectory( const IUnknownVTbl & interface, Device& userclient, UserObjectHandle inKernConfigDirectoryRef)
50	: IOFireWireIUnknown( interface ),
51	  mUserClient( userclient ),
52	  mKernConfigDirectoryRef( inKernConfigDirectoryRef )
53	{
54		mUserClient.AddRef() ;
55	}
56
57	ConfigDirectory::ConfigDirectory( const IUnknownVTbl & interface, Device& userclient )
58	: IOFireWireIUnknown( interface ),
59	  mUserClient( userclient )
60	{
61		uint32_t outputCnt = 1;
62		uint64_t outputVal = 0;
63		IOReturn err = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
64												 kConfigDirectory_Create,
65												 NULL,0,
66												 &outputVal,&outputCnt);
67		mKernConfigDirectoryRef = (UserObjectHandle) outputVal;
68		if (err)
69			throw err ;
70
71		mUserClient.AddRef() ;
72	}
73
74	ConfigDirectory::~ConfigDirectory()
75	{
76		IOReturn error = kIOReturnSuccess;
77
78		uint32_t outputCnt = 0;
79		const uint64_t inputs[1]={(const uint64_t)mKernConfigDirectoryRef};
80		error = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
81													kReleaseUserObject,
82													inputs,1,
83													NULL,&outputCnt);
84
85		DebugLogCond( error, "release config dir failed err=%x\n", error ) ;
86
87		mUserClient.Release() ;
88	}
89
90	IOReturn
91	ConfigDirectory::Update(UInt32 offset)
92	{
93		return kIOReturnUnsupported ;
94	}
95
96	IOReturn
97	ConfigDirectory::GetKeyType(int key, IOConfigKeyType& type)
98	{
99		uint32_t outputCnt = 1;
100		uint64_t outputVal = 0;
101		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, key};
102		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
103													kConfigDirectory_GetKeyType,
104													inputs,2,
105													&outputVal,&outputCnt);
106		type = (IOConfigKeyType) (outputCnt & 0xFFFFFFFF);
107		return result;
108	}
109
110	IOReturn
111	ConfigDirectory::GetKeyValue(int key, UInt32 &value, CFStringRef*& text)
112	{
113		UserObjectHandle	kernelStringRef ;
114		UInt32				stringLen ;
115
116		uint32_t outputCnt = 3;
117		uint64_t outputVal[3];
118		const uint64_t inputs[3] = {(const uint64_t)mKernConfigDirectoryRef, key,(text != nil)};
119		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
120													kConfigDirectory_GetKeyValue_UInt32,
121													inputs,3,
122													outputVal,&outputCnt);
123		value = outputVal[0] & 0xFFFFFFFF;
124		kernelStringRef = (UserObjectHandle) outputVal[1];
125		stringLen = outputVal[2] & 0xFFFFFFFF;
126
127		if (text && (kIOReturnSuccess == result))
128			result = mUserClient.CreateCFStringWithOSStringRef(kernelStringRef, stringLen, text) ;
129
130		return result ;
131	}
132
133	IOReturn
134	ConfigDirectory::GetKeyValue(int key, CFDataRef* value, CFStringRef*& text)
135	{
136		GetKeyValueDataResults results ;
137
138		uint32_t outputCnt = 0;
139		size_t outputStructSize = sizeof(results) ;
140		const uint64_t inputs[3] = {(const uint64_t)mKernConfigDirectoryRef, key, (text != nil)};
141		IOReturn error = IOConnectCallMethod(mUserClient.GetUserClientConnection(),
142											 kConfigDirectory_GetKeyValue_Data,
143											 inputs,3,
144											 NULL,0,
145											 NULL,&outputCnt,
146											 & results,&outputStructSize);
147
148		ROSETTA_ONLY(
149			{
150				results.data = (UserObjectHandle)OSSwapInt32( (UInt32)results.data );
151				results.dataLength = OSSwapInt32( results.dataLength );
152				results.textLength = OSSwapInt32( results.textLength );
153			}
154		);
155
156		if ( text && (kIOReturnSuccess == error))
157			error = mUserClient.CreateCFStringWithOSStringRef( results.text, results.textLength, text ) ;
158		if ( kIOReturnSuccess == error )
159			error = mUserClient.CreateCFDataWithOSDataRef( results.data, results.dataLength, value ) ;
160
161		return error ;
162	}
163
164	IOReturn
165	ConfigDirectory::GetKeyValue(int key, DirRef& value, REFIID iid, CFStringRef*& text)
166	{
167		UserObjectHandle			kernelStringRef ;
168		UserObjectHandle	kernelDirectoryRef ;
169		UInt32						stringLen ;
170
171
172		uint32_t outputCnt = 3;
173		uint64_t outputVal[3];
174		const uint64_t inputs[3] = {(const uint64_t)mKernConfigDirectoryRef, key,(text != nil)};
175		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
176													kConfigDirectory_GetKeyValue_ConfigDirectory,
177													inputs,3,
178													outputVal,&outputCnt);
179		kernelDirectoryRef =(UserObjectHandle) outputVal[0];
180		kernelStringRef = (UserObjectHandle) outputVal[1];
181		stringLen = outputVal[2] & 0xFFFFFFFF;
182
183		IUnknownVTbl**	iUnknown = nil ;
184		if (kIOReturnSuccess == result)
185		{
186			iUnknown = reinterpret_cast<IUnknownVTbl**>(ConfigDirectoryCOM::Alloc(mUserClient, kernelDirectoryRef)) ;
187
188			if (!iUnknown)
189				result = kIOReturnNoMemory ;
190			else
191			{
192				if (S_OK != (*iUnknown)->QueryInterface(iUnknown, iid, (void**) & value))
193					result = kIOReturnError ;
194
195				(*iUnknown)->Release(iUnknown) ;
196			}
197
198			if (text && (kIOReturnSuccess == result))
199				result = mUserClient.CreateCFStringWithOSStringRef(kernelStringRef, stringLen, text) ;
200		}
201
202		return result ;
203	}
204
205	IOReturn
206	ConfigDirectory::GetKeyOffset (
207		int					key,
208		FWAddress &			value,
209		CFStringRef * &		text)
210	{
211		GetKeyOffsetResults results ;
212		uint32_t outputCnt = 0;
213		size_t outputStructSize = sizeof(results) ;
214		const uint64_t inputs[3] = {(const uint64_t)mKernConfigDirectoryRef, key, (text != nil)};
215		IOReturn error = IOConnectCallMethod(mUserClient.GetUserClientConnection(),
216											 kConfigDirectory_GetKeyOffset_FWAddress,
217											 inputs,3,
218											 NULL,0,
219											 NULL,&outputCnt,
220											 & results,&outputStructSize);
221		ROSETTA_ONLY(
222			{
223				results.address.nodeID = OSSwapInt16( results.address.nodeID );
224				results.address.addressHi = OSSwapInt16( results.address.addressHi );
225				results.address.addressLo = OSSwapInt32( results.address.addressLo );
226				results.length = OSSwapInt32( results.length );
227			}
228		);
229
230		value = results.address ;
231
232		if (text && (kIOReturnSuccess == error))
233			error = mUserClient.CreateCFStringWithOSStringRef( results.text, results.length, text ) ;
234
235		return error ;
236	}
237
238	IOReturn
239	ConfigDirectory::GetKeyValue(int key, UserObjectHandle& value)
240	{
241		UserObjectHandle			kernelStringRef ;
242		UserObjectHandle	kernelDirectoryRef ;
243		UInt32						stringLen ;
244
245
246		uint32_t outputCnt = 3;
247		uint64_t outputVal[3];
248		const uint64_t inputs[3] = {(const uint64_t)mKernConfigDirectoryRef, key,false};
249		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
250													kConfigDirectory_GetKeyValue_ConfigDirectory,
251													inputs,3,
252													outputVal,&outputCnt);
253		kernelDirectoryRef =(UserObjectHandle) outputVal[0];
254		kernelStringRef = (UserObjectHandle) outputVal[1];
255		stringLen = outputVal[2] & 0xFFFFFFFF;
256		return result ;
257	}
258
259	IOReturn
260	ConfigDirectory::GetIndexType(int index, IOConfigKeyType &type)
261	{
262		uint32_t outputCnt = 1;
263		uint64_t outputVal;
264		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
265		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
266													kConfigDirectory_GetIndexType,
267													inputs,2,
268													&outputVal,&outputCnt);
269		type = (IOConfigKeyType)(outputVal & 0xFFFFFFFF);
270		return result;
271	}
272
273	IOReturn
274	ConfigDirectory::GetIndexKey(int index, int &key)
275	{
276		uint32_t outputCnt = 1;
277		uint64_t outputVal;
278		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
279		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
280													kConfigDirectory_GetIndexKey,
281													inputs,2,
282													&outputVal,&outputCnt);
283		key = outputVal & 0xFFFFFFFF;
284		return result;
285	}
286
287	IOReturn
288	ConfigDirectory::GetIndexValue(int index, UInt32& value)
289	{
290		uint32_t outputCnt = 1;
291		uint64_t outputVal;
292		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
293		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
294													kConfigDirectory_GetIndexValue_UInt32,
295													inputs,2,
296													&outputVal,&outputCnt);
297		value = outputVal & 0xFFFFFFFF;
298		return result;
299	}
300
301
302	IOReturn
303	ConfigDirectory::GetIndexValue(int index, CFDataRef* value)
304	{
305		UserObjectHandle	dataRef ;
306		IOByteCount		dataLen ;
307
308		uint32_t outputCnt = 2;
309		uint64_t outputVal[2];
310		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
311		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
312													kConfigDirectory_GetIndexValue_Data,
313													inputs,2,
314													outputVal,&outputCnt);
315		dataRef = (UserObjectHandle) outputVal[0];
316		dataLen = outputVal[1] & 0xFFFFFFFF;
317
318		if (kIOReturnSuccess == result)
319			result = mUserClient.CreateCFDataWithOSDataRef(dataRef, dataLen, value) ;
320
321		return result ;
322	}
323
324	IOReturn
325	ConfigDirectory::GetIndexValue(int index, CFStringRef* value)
326	{
327		UserObjectHandle		stringRef ;
328		UInt32				stringLen ;
329
330		uint32_t outputCnt = 2;
331		uint64_t outputVal[2];
332		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
333		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
334													kConfigDirectory_GetIndexValue_String,
335													inputs,2,
336													outputVal,&outputCnt);
337		stringRef = (UserObjectHandle) outputVal[0];
338		stringLen = outputVal[1] & 0xFFFFFFFF;
339
340		if (kIOReturnSuccess == result)
341			result = mUserClient.CreateCFStringWithOSStringRef(stringRef, stringLen, value) ;
342
343		return result ;
344	}
345
346#if 0
347	IOReturn
348	ConfigDirectory::GetIndexValue(int index, UserObjectHandle& value)
349	{
350		uint32_t outputCnt = 1;
351		uint64_t outputVal;
352		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
353		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
354													kConfigDirectory_GetIndexValue_ConfigDirectory,
355													inputs,2,
356													&outputVal,&outputCnt);
357		value = (UserObjectHandle) outputVal;
358		return result;
359	}
360#endif
361
362	IOReturn
363	ConfigDirectory::GetIndexValue (
364		int						index,
365		IOFireWireLibConfigDirectoryRef & value,
366		REFIID					iid)
367	{
368		UserObjectHandle	directoryRef ;
369
370		uint32_t outputCnt = 1;
371		uint64_t outputVal;
372		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
373		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
374													kConfigDirectory_GetIndexValue_ConfigDirectory,
375													inputs,2,
376													&outputVal,&outputCnt);
377		directoryRef = (UserObjectHandle) outputVal;
378
379		IUnknownVTbl** iUnknown ;
380		if (kIOReturnSuccess == result)
381		{
382			iUnknown = reinterpret_cast<IUnknownVTbl**>(ConfigDirectoryCOM::Alloc(mUserClient, directoryRef)) ;
383
384			if (!iUnknown)
385				result = kIOReturnNoMemory ;
386			else
387			{
388				if (S_OK != (*iUnknown)->QueryInterface(iUnknown, iid, (void**) & value))
389					result = kIOReturnError ;
390
391				(*iUnknown)->Release(iUnknown) ;
392			}
393		}
394
395		return result ;
396	}
397
398	IOReturn
399	ConfigDirectory::GetIndexOffset(int index, FWAddress& value)
400	{
401
402		uint32_t outputCnt = 0;
403		size_t outputStructSize = sizeof(value) ;
404		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
405		IOReturn result = IOConnectCallMethod(mUserClient.GetUserClientConnection(),
406											 kConfigDirectory_GetIndexOffset_FWAddress,
407											 inputs,2,
408											 NULL,0,
409											 NULL,&outputCnt,
410											 & value,&outputStructSize);
411		ROSETTA_ONLY(
412			{
413				value.nodeID = OSSwapInt16( value.nodeID );
414				value.addressHi = OSSwapInt16( value.addressHi );
415				value.addressLo = OSSwapInt32( value.addressLo );
416			}
417		);
418
419		return result ;
420	}
421
422	IOReturn
423	ConfigDirectory::GetIndexOffset(int index, UInt32& value)
424	{
425		uint32_t outputCnt = 1;
426		uint64_t outputVal;
427		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
428		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
429													kConfigDirectory_GetIndexOffset_UInt32,
430													inputs,2,
431													&outputVal,&outputCnt);
432		value = outputVal & 0xFFFFFFFF;
433		return result;
434	}
435
436	IOReturn
437	ConfigDirectory::GetIndexEntry(int index, UInt32 &value)
438	{
439		uint32_t outputCnt = 1;
440		uint64_t outputVal;
441		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
442		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
443													kConfigDirectory_GetIndexEntry,
444													inputs,2,
445													&outputVal,&outputCnt);
446		value = outputVal & 0xFFFFFFFF;
447		return result;
448	}
449
450	IOReturn
451	ConfigDirectory::GetSubdirectories(io_iterator_t *outIterator)
452	{
453		uint32_t outputCnt = 1;
454		uint64_t outputVal;
455		const uint64_t inputs[1]={(const uint64_t)mKernConfigDirectoryRef};
456
457		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
458													kConfigDirectory_GetSubdirectories,
459													inputs,1,
460													&outputVal,&outputCnt);
461		*outIterator = (io_iterator_t) outputVal;
462		return result;
463	}
464
465	IOReturn
466	ConfigDirectory::GetKeySubdirectories(int key, io_iterator_t *outIterator)
467	{
468		uint32_t outputCnt = 1;
469		uint64_t outputVal;
470		const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, key};
471		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
472													kConfigDirectory_GetKeySubdirectories,
473													inputs,2,
474													&outputVal,&outputCnt);
475		*outIterator = (io_iterator_t) outputVal;
476		return result;
477	}
478
479	IOReturn
480	ConfigDirectory::GetType(int *outType)
481	{
482		uint32_t outputCnt = 1;
483		uint64_t outputVal;
484		const uint64_t inputs[1]={(const uint64_t)mKernConfigDirectoryRef};
485		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
486													kConfigDirectory_GetType,
487													inputs,1,
488													&outputVal,&outputCnt);
489		*outType = outputVal & 0xFFFFFFFF;
490		return result;
491	}
492
493	IOReturn
494	ConfigDirectory::GetNumEntries(int *outNumEntries)
495	{
496		uint32_t outputCnt = 1;
497		uint64_t outputVal;
498		const uint64_t inputs[1]={(const uint64_t)mKernConfigDirectoryRef};
499		IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
500													kConfigDirectory_GetNumEntries,
501													inputs,1,
502													&outputVal,&outputCnt);
503		*outNumEntries = outputVal & 0xFFFFFFFF;
504		return result;
505	}
506
507	// ============================================================
508	//
509	// ConfigDirectoryCOM
510	//
511	// ============================================================
512
513#pragma mark -
514	ConfigDirectoryCOM::ConfigDirectoryCOM( Device& inUserClient, UserObjectHandle inDirRef )
515	: ConfigDirectory( reinterpret_cast<const IUnknownVTbl &>( sInterface ), inUserClient, inDirRef)
516	{
517	}
518
519	ConfigDirectoryCOM::ConfigDirectoryCOM( Device& inUserClient )
520	: ConfigDirectory( reinterpret_cast<const IUnknownVTbl &>( sInterface ), inUserClient)
521	{
522	}
523
524	ConfigDirectoryCOM::~ConfigDirectoryCOM()
525	{
526	}
527
528	IUnknownVTbl**
529	ConfigDirectoryCOM::Alloc( Device& inUserClient, UserObjectHandle inDirRef )
530	{
531		ConfigDirectoryCOM*	me = nil ;
532
533		try {
534			me = new ConfigDirectoryCOM(inUserClient, inDirRef) ;
535		} catch(...) {
536		}
537
538		return ( nil == me ) ? nil : reinterpret_cast<IUnknownVTbl**>(& me->GetInterface()) ;
539	}
540
541	IUnknownVTbl**
542	ConfigDirectoryCOM::Alloc(Device& inUserClient)
543	{
544		ConfigDirectoryCOM *	me = nil ;
545
546		try {
547			me = new ConfigDirectoryCOM(inUserClient) ;
548		} catch (...) {
549		}
550
551		return ( nil == me ) ? nil : reinterpret_cast<IUnknownVTbl**>(& me->GetInterface()) ;
552	}
553
554	HRESULT STDMETHODCALLTYPE
555	ConfigDirectoryCOM::QueryInterface(REFIID iid, LPVOID* ppv)
556	{
557		HRESULT		result = S_OK ;
558		*ppv = nil ;
559
560		CFUUIDRef	interfaceID	= CFUUIDCreateFromUUIDBytes(kCFAllocatorDefault, iid) ;
561
562		if ( CFEqual(interfaceID, IUnknownUUID) ||  CFEqual(interfaceID, kIOFireWireConfigDirectoryInterfaceID) )
563		{
564			*ppv = & GetInterface() ;
565			AddRef() ;
566		}
567		else
568		{
569			*ppv = nil ;
570			result = E_NOINTERFACE ;
571		}
572
573		CFRelease(interfaceID) ;
574		return result ;
575	}
576
577	// static methods:
578
579	IOReturn
580	ConfigDirectoryCOM::SUpdate(
581		IOFireWireLibConfigDirectoryRef 	inDir,
582		UInt32 								inOffset)
583	{
584		return kIOReturnUnsupported ;
585	}
586
587	IOReturn
588	ConfigDirectoryCOM::SGetKeyType(
589		IOFireWireLibConfigDirectoryRef 	inDir,
590		int 								inKey,
591		IOConfigKeyType* 					outType)
592	{
593		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeyType(inKey, *outType) ;
594	}
595
596	IOReturn
597	ConfigDirectoryCOM::SGetKeyValue_UInt32(
598		IOFireWireLibConfigDirectoryRef 	inDir,
599		int 								inKey,
600		UInt32*								outValue,
601		CFStringRef*						outText)
602	{
603		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeyValue(inKey, * outValue, outText) ;
604	}
605
606	IOReturn
607	ConfigDirectoryCOM::SGetKeyValue_Data(
608		IOFireWireLibConfigDirectoryRef 	inDir,
609		int 								inKey,
610		CFDataRef *							outValue,
611		CFStringRef*						outText)
612	{
613		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeyValue(inKey, outValue, outText) ;
614	}
615
616	IOReturn
617	ConfigDirectoryCOM::SGetKeyValue_ConfigDirectory(
618		IOFireWireLibConfigDirectoryRef 	inDir,
619		int 								inKey,
620		IOFireWireLibConfigDirectoryRef*	outValue,
621		REFIID								iid,
622		CFStringRef*						outText)
623	{
624		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeyValue(inKey, * outValue, iid, outText) ;
625	}
626
627	IOReturn
628	ConfigDirectoryCOM::SGetKeyOffset_FWAddress(
629		IOFireWireLibConfigDirectoryRef 	inDir,
630		int 								inKey,
631		FWAddress*							outValue,
632		CFStringRef* 						text)
633	{
634		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeyOffset(inKey, *outValue, text) ;
635	}
636
637	IOReturn
638	ConfigDirectoryCOM::SGetIndexType(
639		IOFireWireLibConfigDirectoryRef 	inDir,
640		int 								inIndex,
641		IOConfigKeyType*					outType)
642	{
643		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexType(inIndex, *outType) ;
644	}
645
646	IOReturn
647	ConfigDirectoryCOM::SGetIndexKey(
648		IOFireWireLibConfigDirectoryRef 	inDir,
649		int 								inIndex,
650		int *								outKey)
651	{
652		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexKey(inIndex, *outKey) ;
653	}
654
655	IOReturn
656	ConfigDirectoryCOM::SGetIndexValue_UInt32(
657		IOFireWireLibConfigDirectoryRef 	inDir,
658		int 								inIndex,
659		UInt32 *							outValue)
660	{
661		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexValue(inIndex, *outValue) ;
662	}
663
664	IOReturn
665	ConfigDirectoryCOM::SGetIndexValue_Data(
666		IOFireWireLibConfigDirectoryRef 	inDir,
667		int 								inIndex,
668		CFDataRef *							outValue)
669	{
670		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexValue(inIndex, outValue) ;
671	}
672
673	IOReturn
674	ConfigDirectoryCOM::SGetIndexValue_String(
675		IOFireWireLibConfigDirectoryRef 	inDir,
676		int 								inIndex,
677		CFStringRef*						outValue)
678	{
679		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexValue(inIndex, outValue) ;
680	}
681
682	IOReturn
683	ConfigDirectoryCOM::SGetIndexValue_ConfigDirectory(
684		IOFireWireLibConfigDirectoryRef 	inDir,
685		int 								inIndex,
686		IOFireWireLibConfigDirectoryRef*	outValue,
687		REFIID								iid)
688	{
689		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexValue(inIndex, *outValue, iid) ;
690	}
691
692	IOReturn
693	ConfigDirectoryCOM::SGetIndexOffset_FWAddress(
694		IOFireWireLibConfigDirectoryRef 	inDir,
695		int 								inIndex,
696		FWAddress*							outValue)
697	{
698		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexOffset(inIndex, *outValue) ;
699	}
700
701	IOReturn
702	ConfigDirectoryCOM::SGetIndexOffset_UInt32(
703		IOFireWireLibConfigDirectoryRef 	inDir,
704		int 								inIndex,
705		UInt32*								outValue)
706	{
707		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexOffset(inIndex, *outValue) ;
708	}
709
710	IOReturn
711	ConfigDirectoryCOM::SGetIndexEntry(
712		IOFireWireLibConfigDirectoryRef 	inDir,
713		int 								inIndex,
714		UInt32*								outValue)
715	{
716		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexEntry(inIndex, *outValue) ;
717	}
718
719	IOReturn
720	ConfigDirectoryCOM::SGetSubdirectories(
721		IOFireWireLibConfigDirectoryRef 	inDir,
722		io_iterator_t*						outIterator)
723	{
724		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetSubdirectories(outIterator) ;
725	}
726
727	IOReturn
728	ConfigDirectoryCOM::SGetKeySubdirectories(
729		IOFireWireLibConfigDirectoryRef 	inDir,
730		int 								inKey,
731		io_iterator_t *						outIterator)
732	{
733		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeySubdirectories(inKey, outIterator) ;
734	}
735
736	IOReturn
737	ConfigDirectoryCOM::SGetType(
738		IOFireWireLibConfigDirectoryRef 	inDir,
739		int *								outType)
740	{
741		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetType(outType) ;
742	}
743
744	IOReturn
745	ConfigDirectoryCOM::SGetNumEntries(
746		IOFireWireLibConfigDirectoryRef 	inDir,
747		int *								outNumEntries)
748	{
749		return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetNumEntries(outNumEntries) ;
750	}
751}
752