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