1/* 2 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_LICENSE_HEADER_START@ 5 * 6 * The contents of this file constitute Original Code as defined in and 7 * are subject to the Apple Public Source License Version 1.1 (the 8 * "License"). You may not use this file except in compliance with the 9 * License. Please obtain a copy of the License at 10 * http://www.apple.com/publicsource and read it before using this file. 11 * 12 * This Original Code and all software distributed under the License are 13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER 14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the 17 * License for the specific language governing rights and limitations 18 * under the License. 19 * 20 * @APPLE_LICENSE_HEADER_END@ 21 */ 22 23#ifndef _IOKIT_IOFIREWIRESBP2LIB_H_ 24#define _IOKIT_IOFIREWIRESBP2LIB_H_ 25 26#include <IOKit/firewire/IOFireWireFamilyCommon.h> 27#include <IOKit/IOMessage.h> 28 29/* A45B8156-B51B-11D4-AB4B-000A277E7234 */ 30#define kIOFireWireSBP2LibTypeID CFUUIDGetConstantUUIDWithBytes(NULL, \ 31 0xA4, 0x5B, 0x81, 0x56, 0xB5, 0x1B, 0x11, 0xD4, \ 32 0xAB, 0x4B, 0x00, 0x0A, 0x27, 0x7E, 0x72, 0x34 ) 33 34/* AE3A2684-B51B-11D4-B516-000A277E7234 */ 35#define kIOFireWireSBP2LibFactoryID CFUUIDGetConstantUUIDWithBytes(NULL, \ 36 0xAE, 0x3A, 0x26, 0x84, 0xB5, 0x1B, 0x11, 0xD4, \ 37 0xB5, 0x16, 0x00, 0x0A, 0x27, 0x7E, 0x72, 0x34 ) 38 39/* B63446A8-B51B-11D4-AAB0-000A277E7234 */ 40#define kIOFireWireSBP2LibLUNInterfaceID CFUUIDGetConstantUUIDWithBytes(NULL, \ 41 0xB6, 0x34, 0x46, 0xA8, 0xB5, 0x1B, 0x11, 0xD4, \ 42 0xAA, 0xB0, 0x00, 0x0A, 0x27, 0x7E, 0x72, 0x34 ) 43 44/* BBE32C26-BAD4-11D4-A580-000A277E7234 */ 45#define kIOFireWireSBP2LibLoginInterfaceID CFUUIDGetConstantUUIDWithBytes(NULL, \ 46 0xBB, 0xE3, 0x2C, 0x26, 0xBA, 0xD4, 0x11, 0xD4, \ 47 0xA5, 0x80, 0x00, 0x0A, 0x27, 0x7E, 0x72, 0x34 ) 48 49/* 0D818E2E-BC55-11D4-9B72-000A277E7234 */ 50#define kIOFireWireSBP2LibORBInterfaceID CFUUIDGetConstantUUIDWithBytes(NULL, \ 51 0x0D, 0x81, 0x8E, 0x2E, 0xBC, 0x55, 0x11, 0xD4, \ 52 0x9B, 0x72, 0x00, 0x0A, 0x27, 0x7E, 0x72, 0x34 ) 53 54/* ECD3E338-BDBC-11D4-A592-000A277E7234 */ 55#define kIOFireWireSBP2LibMgmtORBInterfaceID CFUUIDGetConstantUUIDWithBytes(NULL, \ 56 0xEC, 0xD3, 0xE3, 0x38, 0xBD, 0xBC, 0x11, 0xD4, \ 57 0xA5, 0x92, 0x00, 0x0A, 0x27, 0x7E, 0x72, 0x34 ) 58 59////////////////////// 60 61#define kIOMessageFWSBP2ReconnectComplete ((UInt32)iokit_fw_err(0x3E8)) 62#define kIOMessageFWSBP2ReconnectFailed ((UInt32)iokit_fw_err(0x3E9)) 63 64/*! 65 * Direction of transfer, with respect to the described memory. 66 */ 67enum IODirection 68{ 69 kIODirectionNone = 0, 70 kIODirectionIn = 1, // User land 'read' 71 kIODirectionOut = 2, // User land 'write' 72 kIODirectionOutIn = 3 73}; 74 75/*! Virtual address range for SBP2. */ 76typedef struct 77{ 78 void * address; 79 UInt32 length; 80} FWSBP2VirtualRange; 81 82////////////////////// 83 84/*! @enum Login Option Flags 85 @discussion 86 Passed to the setLoginFlags member function. 87 */ 88enum 89{ 90 kFWSBP2DontSynchronizeMgmtAgent = (1 << 0), 91 kFWSBP2ExclusiveLogin = (1 << 5) 92}; 93 94/*! @enum ORB Option Flags 95 @discussion 96 Passed to the setCommandFlags member function. 97 */ 98enum 99{ 100 kFWSBP2CommandCompleteNotify = (1 << 0), 101 kFWSBP2CommandTransferDataFromTarget = (1 << 1), 102 kFWSBP2CommandImmediate = (1 << 2), 103 104 kFWSBP2CommandNormalORB = (1 << 5), 105 kFWSBP2CommandReservedORB = (1 << 6), 106 kFWSBP2CommandVendorORB = (1 << 7), 107 kFWSBP2CommandDummyORB = (1 << 8), 108 kFWSBP2CommandCheckGeneration = (1 << 9), 109 110 kFWSBP2CommandFixedSize = (1 << 10), 111 kFWSBP2CommandVirtualORBs = (1 << 11) // handy for debugging 112}; 113 114/*! @enum SBP2 setCommandFunction values 115 @discussion 116 Passed to the setCommandFunction member function. 117 */ 118enum 119{ 120 kFWSBP2QueryLogins = 1, 121 kFWSBP2AbortTask = 0xb, 122 kFWSBP2AbortTaskSet = 0xc, 123 kFWSBP2LogicalUnitReset = 0xe, 124 kFWSBP2TargetReset = 0xf 125}; 126 127/*! @enum SBP2 Notification Events 128 @discussion 129 Passed to the setStatusNotifyProc member function. 130 */ 131enum 132{ 133 kFWSBP2NormalCommandStatus = 6, 134 kFWSBP2NormalCommandTimeout = 7, 135 kFWSBP2UnsolicitedStatus = 8, 136 kFWSBP2NormalCommandReset = 9 137}; 138 139/*! 140 @typedef FWSBP2LoginResponse 141 @param length Length of login response. 142 @param loginID Unique id representing this login. 143 @param commandBlockAgentAddressHi High 32 bits of command block agent address. 144 @param commandBlockAgentAddressLo Low 32 bits of command block agent address. 145 @param reserved Reserved. 146 @param reconnectHold Reconnect timeout encoded as 2^reconnectHold seconds. 147*/ 148 149typedef struct 150{ 151 UInt16 length; 152 UInt16 loginID; 153 UInt32 commandBlockAgentAddressHi; 154 UInt32 commandBlockAgentAddressLo; 155 UInt16 reserved; 156 UInt16 reconnectHold; 157} FWSBP2LoginResponse; 158 159/*! 160 @typedef FWSBP2StatusBlock 161 @param details Src, Resp, D, Len fields of status block format 162 @param sbpStatus SBP2 specific status 163 @param orbOffsetHi High 32 bits of address of orb status is for. 164 @param orbOffsetLo Low 32 bits of address of orb status is for. 165 @param status Up to 48 bytes of additional data. Length is determined by len field. 166*/ 167 168typedef struct 169{ 170 UInt8 details; 171 UInt8 sbpStatus; 172 UInt16 orbOffsetHi; 173 UInt32 orbOffsetLo; 174 UInt32 status[6]; 175} FWSBP2StatusBlock; 176 177// struct sent to login complete handler 178 179/*! 180 @typedef FWSBP2LoginCompleteParams 181 @param refCon refCon set on login object. 182 @param generation FireWire generation value. 183 @param status Status of login attempt. 184 @param loginResponse Pointer to login response struct. 185 @param statusBlock Pointer to status block buffer. 186 @param statusBlockLength Length of entire status block. 187*/ 188 189typedef struct 190{ 191 void * refCon; // refCon from login object 192 UInt32 generation; // generation this login was attempted in 193 IOReturn status; // status of login attempt 194 FWSBP2LoginResponse * loginResponse; // pointer to loginResponse buffer 195 FWSBP2StatusBlock * statusBlock; // pointer to statusBlock buffer 196 UInt32 statusBlockLength; // size of statusBlock buffer 197} FWSBP2LoginCompleteParams; 198 199// struct sent to logout complete handler 200 201/*! 202 @typedef FWSBP2LogoutCompleteParams 203 @param refCon refCon set on login object. 204 @param generation FireWire generation value. 205 @param status Status of login attempt. 206 @param statusBlock Pointer to status block buffer. 207 @param statusBlockLength Length of entire status block. 208*/ 209 210typedef struct 211{ 212 void * refCon; // refCon from login object 213 UInt32 generation; // generation this login was attempted in 214 IOReturn status; // status of login attempt 215 FWSBP2StatusBlock * statusBlock; // pointer to statusBlock buffer 216 UInt32 statusBlockLength; // size of statusBlock buffer 217} FWSBP2LogoutCompleteParams; 218 219// struct sent with reconnect notification 220 221/*! 222 @typedef FWSBP2ReconnectParams 223 @param refCon refCon set on LUN object. 224 @param generation FireWire generation value. 225 @param status Status of reconnect attempt. 226 @param reconnectStatusBlock Pointer to status block buffer. 227 @param reconnectStatusBlockLength Length of entire status block. 228*/ 229 230typedef struct 231{ 232 void * refCon; // refCon from lun object 233 UInt32 generation; // generation this login was attempted in 234 235 IOReturn status; // status of reconnect attempt 236 237 FWSBP2StatusBlock * reconnectStatusBlock; // pointer to statusBlock buffer 238 UInt32 reconnectStatusBlockLength; // size of statusBlock buffer 239} FWSBP2ReconnectParams; 240 241/*! 242 @typedef FWSBP2NotifyParams 243 @param refCon refCon set on Login object for unsolicited status or refCon set ORB for normal status. 244 @param notificationEvent Type of event we are being notified of. 245 @param message buffer containing message. 246 @param length length of message field. 247 @param generation FireWire generation value. 248*/ 249 250typedef struct 251{ 252 void * refCon; // refCon from ORB object 253 UInt32 notificationEvent; 254 const void * message; 255 UInt32 length; 256 UInt32 generation; 257} FWSBP2NotifyParams; 258 259////////////////////// 260 261typedef void (*IOFWSBP2MessageCallback)( void * refCon, UInt32 type, void * arg ); 262 263/*! 264 @typedef IOFWSBP2LoginCallback 265 @param refCon Reference constant supplied when the notification was registered. 266 @param params Structure containing additional information about the status of the login. 267*/ 268 269typedef void (*IOFWSBP2LoginCallback)( void * refCon, FWSBP2LoginCompleteParams * params ); 270 271/*! 272 @typedef IOFWSBP2LogoutCallback 273 @param refCon Reference constant supplied when the notification was registered. 274 @param params Structure containing additional information about the status of the logout. 275*/ 276 277typedef void (*IOFWSBP2LogoutCallback)( void * refCon, FWSBP2LogoutCompleteParams * params ); 278 279/*! 280 @typedef IOFWSBP2ORBAppendCallback 281 @param refCon Reference constant supplied when the notification was registered. 282 @param status Indicates success or failure of operation. 283 @param orb refCon set on management orb. 284*/ 285 286typedef void (*IOFWSBP2ORBAppendCallback)( void * refCon, IOReturn status, void * orb ); 287 288/*! 289 @typedef IOFWSBP2ORBCompleteCallback 290 @param refCon Reference constant supplied when the notification was registered. 291 @param status Indicates success or failure of operation. 292 @param orb refCon set on management orb. 293*/ 294 295typedef void (*IOFWSBP2ORBCompleteCallback)( void * refCon, IOReturn status, void * orb ); 296 297/*! 298 @typedef IOFWSBP2NotifyCallback 299 @param refCon Reference constant supplied when the notification was registered. 300 @param params FWSBP2NotifyParams containing notification information. 301*/ 302 303typedef void (*IOFWSBP2NotifyCallback)(void * refCon, FWSBP2NotifyParams * params); 304 305/*! 306 @typedef IOFWSBP2StatusCallback 307 @param refCon Reference constant supplied when the notification was registered. 308 @param status Indicates success or failure of operation. 309*/ 310 311typedef void (*IOFWSBP2StatusCallback)(void * refCon, IOReturn status); 312 313/*! 314 @typedef IOFWSBP2FetchAgentWriteCallback 315 @param refCon Reference constant supplied when the notification was registered. 316 @param status Indicates success or failure of operation. 317 @param orbRefCon refCon from last orb in chain. 318*/ 319 320typedef void (*IOFWSBP2FetchAgentWriteCallback)(void * refCon, IOReturn status, void * orbRefCon ); 321 322////////////////////// 323 324 325/*! 326 @class IOFireWireSBP2LibLUNInterface 327 @abstract Initial interface disovered for all drivers. 328 @discussion The IOFireWireSBP2LibLUNInterface is the initial interface discovered by most drivers. It supplies the methods that control the operation of the LUN as a whole. Methods that control the behavior and execution of an SBP2 login session are supplied in a separate IOFireWireSBP2LibLoginInterface object. The LUN can be used to create one of these login objects. 329 The LUN can also create IOFireWireSBP2LibManagementORBInterfaces for configuring and appending non-login related management functions. Login related management functions (ie. Login, Logout, Reconnect) are supplied by the IOFireWireSBP2LibLoginInterface. 330 Finally the LUN can supply a reference to the IOFireWireUnit. This can be useful if a driver wishes to access the standard FireWire APIs. 331*/ 332typedef struct 333{ 334 335 IUNKNOWN_C_GUTS; 336 337 UInt16 version; 338 UInt16 revision; 339 340 /*! 341 @function open 342 @abstract Exclusively opens a connection to the in-kernel device. 343 @discussion Exclusively opens a connection to the in-kernel device. As long as the in-kernel 344 device object is open, no other drivers will be able to open a connection to the device. When 345 open the device on the bus may disappear, but the in-kernel object representing it will stay 346 instantiated and can begin communicating with the device again if it ever reappears. 347 @param self Pointer to IOFireWireSBP2LibLUNInterface. 348 @result Returns kIOReturnSuccess on success. 349 */ 350 351 IOReturn (*open)( void * self ); 352 353 /*! 354 @function openWithSessionRef 355 @abstract Opens a connection to a device that is already open. 356 @discussion Sometimes it is desirable to open multiple user clients on a device. In the case 357 of FireWire sometimes we wish to have both the FireWire User Client and the SBP2 User Client 358 open at the same time. 359 <p>The technique to arbitrate this is as follows :</p> 360 <p>First open normally the device furthest from the root in the IORegistry.</p> 361 <p>Second, get its sessionRef with the getSessionRef call.</p> 362 <p>Third open the device further up the chain by calling this method and passing the sessionRef returned from the call in step 2.</p> 363 @param sessionRef SessionRef returned from getSessionRef call. 364 @param self Pointer to IOFireWireSBP2LibLUNInterface. 365 @result Returns kIOReturnSuccess on success. 366 */ 367 368 IOReturn (*openWithSessionRef)( void * self, IOFireWireSessionRef sessionRef ); 369 370 /*! 371 @function getSessionRef 372 @abstract Returns the session reference to an already open device. 373 @discussion Sometimes it is desirable to open multiple user clients on a device. In the case 374 of FireWire sometimes we wish to have both the FireWire User Client and the SBP2 User Client 375 open at the same time. 376 <p>The technique to arbitrate this is as follows:</p> 377 <p>First open normally the device furthest from the root in the IORegistry.</p> 378 <p>Second, get its sessionRef with a call to this method.</p> 379 <p>Third open the device further up the chain by calling openWithSessionRef and passing the sessionRef returned from this call.</p> 380 @param self Pointer to IOFireWireSBP2LibLUNInterface. 381 @result Returns a sessionRef on success. 382 */ 383 384 IOFireWireSessionRef (*getSessionRef)(void * self); 385 386 /*! 387 @function close 388 @abstract Opens a connection to a device that is not already open. 389 @discussion Closes an exclusive access to the device. When a device is closed it may be 390 unloaded by the kernel. If it is unloaded and then later reappears it will be represented 391 by a different object. You won't be able to use this user client on the new object. The 392 new object will have to be looked up in the IORegistry and a new user client will have to 393 be opened on it. 394 @param self Pointer to IOFireWireSBP2LibLUNInterface. 395 */ 396 397 void (*close)( void * self ); 398 399 /*! 400 @function addCallbackDispatcherToRunLoop 401 @abstract Adds a dispatcher for kernel callbacks to the specified runloop. 402 @discussion The user space portions of the SBP2 api communicate with the in-kernel services by 403 messaging the kernel. Similarly, the kernel messages the user space services in response. 404 These responses need to be picked up by a piece of code. This call adds that code to the specified 405 runloop. Most drivers will call this method on the runloop that was created when your task was 406 created. To avoid deadlock you must avoid sleeping (or spin waiting) the runloop to wait for 407 SBP2 response. If you do this the dispatcher will never get to run and you will wait forever. 408 @param self Pointer to IOFireWireSBP2LibLUNInterface. 409 @param cfRunLoopRef Reference to a runloop 410 @result Returns kIOReturnSuccess on success. 411 */ 412 413 IOReturn (*addCallbackDispatcherToRunLoop)( void *self, CFRunLoopRef cfRunLoopRef ); 414 415 /*! 416 @function removeCallbackDispatcherFromRunLoop 417 @abstract Removes a dispatcher for kernel callbacks from the specified runloop. 418 @discussion Undoes the work of addCallbackDispatcherToRunLoop. 419 @param self Pointer to IOFireWireSBP2LibLUNInterface. 420 */ 421 422 void (*removeCallbackDispatcherFromRunLoop)( void * self ); 423 424 /*! 425 @function setMessageCallback 426 @abstract Set callback for user space message routine. 427 @discussion In FireWire & SBP2 bus status messages are delivered via IOKit's message routine. 428 This routine is emulated in user space for SBP2 & FireWire messages via this callback. You should 429 register here for bus reset, and reconnect messages. 430 @param self Pointer to IOFireWireSBP2LibLUNInterface. 431 @param refCon RefCon to be returned as first argument of completion routine 432 @param callback Address of completion routine. 433 */ 434 435 void (*setMessageCallback)( void *self, void * refCon, IOFWSBP2MessageCallback callback); 436 437 /*! 438 @function setRefCon 439 @abstract Sets the ORB refCon. 440 @discussion Sets a user defined value on the ORB that can be retrieved later with the 441 method getRefCon. 442 @param self Pointer to IOFireWireSBP2LibLUNInterface. 443 @param refCon a user defined value. 444 */ 445 446 void (*setRefCon)( void * self, void * refCon ); 447 448 /*! 449 @function getRefCon 450 @abstract Returns the refCon set with setRefCon. 451 @discussion Returns the user defined value previously stored in the ORB with setRefCon. 452 @param self Pointer to IOFireWireSBP2LibLUNInterface. 453 @result Returns the previously stored user defined value. 454 */ 455 456 void * (*getRefCon)( void * self); 457 458 /*! 459 @function createLogin 460 @abstract Creates a new IOFireWireSBP2LibLoginInterface object. 461 @discussion Creates a new IOFireWireSBP2LibLoginInterface object for the LUN. Login 462 objects supply most of the SBP2 APIs related to login maintenance and Normal 463 Command ORB execution. 464 @param self Pointer to IOFireWireSBP2LibLUNInterface. 465 @param iid UUID for desired type of IOFireWireSBP2LibLoginInterface. 466 @result Returns a pointer to a new IOFireWireSBP2LibLoginInterface. 467 */ 468 469 IUnknownVTbl** (*createLogin)( void * self, REFIID iid ); 470 471 /*! 472 @function createMgmtORB 473 @abstract Creates a new IOFireWireSBP2LibMgmntORBInterface object. 474 @discussion Creates a new IOFireWireSBP2LibMgmtORBInterface object. Management objects let you 475 execute commands like QueryLogins, LogicalUnitReset, and AbortTask. These commands are 476 configured after they are created here. When they are done executing (after a call to submit) 477 the supplied completion routine will be called with the supplied refcon. Usually this refCon 478 is the "this" pointer of completion method's object. 479 @param self Pointer to IOFireWireSBP2LibLUNInterface. 480 @param iid UUID for desired type of IOFireWireSBP2LibMgmtORBInterface. 481 @result Returns a pointer to a new IOFireWireSBP2Login. 482 */ 483 484 IUnknownVTbl** (*createMgmtORB)( void * self, REFIID iid ); 485 486} IOFireWireSBP2LibLUNInterface; 487 488 489 490/*! 491 @class IOFireWireSBP2LibORBInterface 492 @abstract Represents an SBP2 normal command ORB. Supplies the APIs for configuring normal 493 command ORBs. This includes setting the command block and writing the page tables for I/O. 494 The ORBs are executed using the submitORB method in IOFireWireSBP2LibLoginInterface. 495*/ 496typedef struct 497{ 498 499 IUNKNOWN_C_GUTS; 500 501 UInt16 version; 502 UInt16 revision; 503 504 /*! 505 @function setRefCon 506 @abstract Sets the ORB refCon. 507 @discussion Sets a user defined value on the ORB that can be retrieved later with the 508 method getRefCon. 509 @param self Pointer to IOFireWireSBP2LibORBInterface. 510 @param refCon a user defined value. 511 */ 512 513 void (*setRefCon)( void * self, void * refCon ); 514 515 /*! 516 @function getRefCon 517 @abstract Returns the refCon set with setRefCon. 518 @discussion Returns the user defined value previously stored in the ORB with setRefCon. 519 @param self Pointer to IOFireWireSBP2LibORBInterface. 520 @result Returns the previously stored user defined value. 521 */ 522 523 void * (*getRefCon)( void * self ); 524 525 /*! 526 @function setCommandFlags 527 @abstract Sets configuration flags for the ORB. 528 @discussion Sets the configuration flags for the ORB. These can be any of the following: 529 <p>kFWSBP2CommandCompleteNotify - Set the notify bit as specified in SBP2 standard. Set to receive completion/timeout notification on this ORB. You almost always want to set this.</p> 530 <p>kFWSBP2CommandTransferDataFromTarget - Transfer direction as specified in SBP2 standard. Set if data is to be written by the device into the host's memory.</p> 531 <p>kFWSBP2CommandImmediate - Immediate Append. ORB address will be written to fetch agent and not chained. It is only legal to have one immediate ORB in progress at a time.</p> 532 <p>kFWSBP2CommandNormalORB - ORB format 0 - Format specified by SBP2 standard. Set this for most ORBs.</p> 533 <p>kFWSBP2CommandReservedORB - ORB format 1 - Format reserved by SBP2 standard for future standardization.</p> 534 <p>kFWSBP2CommandVendorORB - ORB format 2 - Format specified by SBP2 standard for vendor dependent ORBs.</p> 535 <p>kFWSBP2CommandDummyORB - ORB format 3 - Format specified by SBP2 standard for dummy ORBs.</p> 536 <p>kFWSBP2CommandCheckGeneration - If set upon submitORB, the ORB will only be appended if generation set with setCommandGeneration() matches the current generation. Pretty much all SBP2 drivers need sophisticated logic to track login state, so this is generally not used. </p> 537 <p>kFWSBP2CommandFixedSize - Do not allocate more memory for page table if needed. If there is not enough space in the currently allocated page table, the setCommandBuffers call will fail. This is important to set if your device is the backing store, as we don't want to cause memory allocations on the paging path. </p> 538 <p>kFWSBP2CommandVirtualORBs - Normally ORBs are backed by physical address spaces. Setting this flag makes this ORB backed by a pseudo address space. This can make ORBs easier to see in a bus trace. Virtual ORBs will have an address in the form of ffcX.XXXX.0000.0000. Pseudo address space backed ORBs are slower, so you won't want to set for deployment builds.</p> 539 @param self Pointer to IOFireWireSBP2LibORBInterface. 540 @param flags The flags to be set. 541 */ 542 543 void (*setCommandFlags)( void * self, UInt32 flags ); 544 545 /*! 546 @function setMaxORBPayloadSize 547 @abstract Sets max payload size for the ORB. 548 @discussion This sets the maximum payload size for this ORB only. This size is clipped by 549 the global max payload size set in the login object. 550 @param self Pointer to IOFireWireSBP2LibORBInterface. 551 @param size The maximum payload size in bytes. 552 */ 553 554 void (*setMaxORBPayloadSize)( void * self, UInt32 size ); 555 556 /*! 557 @function setCommandTimeout 558 @abstract Sets the timeout of the ORB. 559 @discussion This sets the timeout for the ORB in milliseconds. Note that ORBs without timeouts 560 can be "lost." You will obviously not recieve timeout notification for timeouts of zero. But 561 perhaps less obviously you will not recieve orb reset notification, which is really a sort of 562 accelerated timeout notification for bus reset situations. 563 @param self Pointer to IOFireWireSBP2LibORBInterface. 564 @param timeout The timeout duration in milliseconds. 565 */ 566 567 void (*setCommandTimeout)( void * self, UInt32 timeout ); 568 569 /*! 570 @function setCommandGeneration 571 @abstract Sets the command generation. 572 @discussion This sets the bus generation this ORB should be appended in. It is only meaningful 573 when combined with the kFWSBP2CommandCheckGeneration flags above. 574 @param self Pointer to IOFireWireSBP2LibORBInterface. 575 @param generation The bus generation for command execution. 576 */ 577 578 void (*setCommandGeneration)( void * self, UInt32 generation ); 579 580 /*! 581 @function setCommandBuffersAsRanges 582 @abstract Creates a page table from a list of ranges. 583 @discussion Creates a page table with the given parameters. Any addresses mapped by this method 584 must remain valid until setCommandBuffers is called again or releaseCommandBuffers is called. 585 The SBP2 services do not release references to the command buffers just because the command 586 has completed. 587 @param self Pointer to IOFireWireSBP2LibORBInterface. 588 @param ranges An array of ranges representing the data to be transfered. 589 @param withCount The number of ranges in the ranges array. 590 @param withDirection An IODirection indicating the direction of data transfer. 591 @param offset Offset in bytes into data to begin writing table at. 592 @param length Number of bytes of data to map from offset. 593 @result Returns KIOReturnSuccess if the page table was written successfully. 594 */ 595 596 IOReturn (*setCommandBuffersAsRanges)( void * self, FWSBP2VirtualRange * ranges, UInt32 withCount, 597 UInt32 withDirection, UInt32 offset, 598 UInt32 length ); 599 600 /*! 601 @function releaseCommandBuffers 602 @abstract Releases SBP2's reference to the command buffers. 603 @discussion When you create a page table with one of the variants of setCommandBuffers. 604 SBP2 holds on to a reference to the buffers until this method is called. This means that 605 if a command completed and you released the buffers 606 without calling this method you could leave FW in an inconsistent state. 607 @param self Pointer to IOFireWireSBP2LibORBInterface. 608 @result Returns KIOReturnSuccess if the page table was cleared successfully. 609 */ 610 611 IOReturn (*releaseCommandBuffers)( void * self ); 612 613 /*! 614 @function setCommandBlock 615 @abstract Sets the command block portion of the ORB. 616 @discussion Copys the data provided in the buffer to the command block portion of the ORB. 617 @param self Pointer to IOFireWireSBP2LibORBInterface. 618 @param buffer Pointer to buffer to copy command block from. 619 @param length Number of bytes of data to copy. 620 @result Returns KIOReturnSuccess if the command block was updated successfully. 621 */ 622 623 IOReturn (*setCommandBlock)( void * self, void * buffer, UInt32 length ); 624 625 /*! 626 @function LSIWorkaroundSetCommandBuffersAsRanges 627 @abstract Creates a page table with the LSI workaround from a list of ranges. 628 @discussion Creates an LSI workaround page table with the given parameters. Any addresses 629 mapped by this method routine must remain valid until setCommandBuffers is called again 630 or releaseCommandBuffers is called. The SBP2 services do not release references to the 631 command buffers just because the command has completed. 632 @param self Pointer to IOFireWireSBP2LibORBInterface. 633 @param ranges An array of ranges representing the data to be transfered. 634 @param withCount The number of ranges in the ranges array. 635 @param withDirection An IODirection indicating the direction of data transfer. 636 @param offset Offset in bytes into data to begin writing table at. 637 @param length Number of bytes of data to map from offset. 638 @result Returns KIOReturnSuccess if the page table was written successfully. 639 */ 640 641 IOReturn (*LSIWorkaroundSetCommandBuffersAsRanges)( void * self, FWSBP2VirtualRange * ranges, UInt32 withCount, 642 UInt32 withDirection, UInt32 offset, 643 UInt32 length ); 644 645 /*! 646 @function LSIWorkaroundSyncBuffersForOutput 647 @abstract Synchronize the buffers for output. 648 @discussion Since double buffering may be invovled in the workaround. The driver needs to 649 indicate when these buffers should be syncronized with the original descriptor. For data 650 that will be output LSIWorkaroundSyncBuffersForOutput should be called before submiting the ORB. 651 @param self Pointer to IOFireWireSBP2LibORBInterface. 652 @result Returns kIOReturnSuccess if sync was successful. 653 */ 654 655 IOReturn (*LSIWorkaroundSyncBuffersForOutput)( void * self ); 656 657 /*! 658 @function LSIWorkaroundSyncBuffersForInput 659 @abstract Synchronize the buffers for input. 660 @discussion Since double buffering may be invovled in the workaround. The driver needs to 661 indicate when these buffers should be syncronized with the original descriptor. For data 662 that will be input LSIWorkaroundSyncBuffersForInput should be called after receiving completion status 663 for the ORB. 664 @param self Pointer to IOFireWireSBP2LibORBInterface. 665 @result Returns kIOReturnSuccess if sync was successful. 666 */ 667 668 IOReturn (*LSIWorkaroundSyncBuffersForInput)( void * self ); 669 670} IOFireWireSBP2LibORBInterface; 671 672 /*! 673 @class IOFireWireSBP2LibLoginInterface 674 @abstract Supplies the login maintenance and Normal Command ORB execution portions of the API. 675 @discussion Supplies APIs for login maintenance and command execution. Drivers can use this 676 object to create IOFireWireSBP2LibORBInterface objects and execute them. Solicited and unsolicited status 677 callback routines can be registered and the SBP2 services will notify the driver when the 678 appropriate status arrives. 679 This class also handles login maintenance. Supplies APIs for logging in and logging out and 680 attempts to reconnect to the LUN after bus resets. The base FireWire services deliver bus 681 reset notification via the IOKit message routine. The SBP2 services build on this behavior 682 and deliver reconnectFailed and reconnectComplete through the message routine as well. 683*/ 684typedef struct 685 { 686 687 IUNKNOWN_C_GUTS; 688 689 UInt16 version; 690 UInt16 revision; 691 692 /*! 693 @function submitLogin 694 @abstract Attempts to login to the LUN. 695 @discussion This call begins the login process. The login object should be configured prior 696 to this call. If kIOReturnSuccess is returned from this call then the loginCompletion routine 697 will be called when the login completes (successfully or unsuccesfully). 698 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 699 @result Returns kIOReturnSuccess login has successlly begun. 700 */ 701 702 IOReturn (*submitLogin)( void * self ); 703 704 /*! 705 @function submitLogout 706 @abstract Attempts to logout of the LUN. 707 @discussion This call begins the logout process. If kIOReturnSuccess is returned from this call then 708 the logoutCompletion routine will be called when the logout completes (successfully or unsuccesfully). 709 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 710 @result Returns kIOReturnSuccess if logout has successfully begun. 711 */ 712 713 IOReturn (*submitLogout)( void * self ); 714 715 /*! 716 @function setLoginFlags 717 @abstract Sets login configuration flags. 718 @discussion Configures the login behavior according to the provided flags. Currently two 719 flags are defined for this API. kFWSBP2ExclusiveLogin sets the exclusive login bit in the 720 login ORB. kFWSBP2DontSynchronizeMgmtAgent allows simultaneous logins or reconnects to LUNs 721 with a common management agent (ie LUNs in the same unit directory). 722 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 723 @param flags the login configuration flags. 724 */ 725 726 void (*setLoginFlags)( void * self, UInt32 flags ); 727 728 /*! 729 @function setLoginCallback 730 @abstract Sets the callback to be called when a login attempt is complete. 731 @discussion The supplied callback is called when a login attempt has completed. "status" in the 732 callback's params should be checked to determine the success or failure of the login attempt. 733 The "refCon" field in the params will return the refcon set with setRefCon. 734 If "statusBlock" is non-null then login status was written and it has been supplied here. If 735 the login attempt was successful then the login response will be supplied in the "loginResponse" 736 buffer. Note: all buffers supplied to callbacks are only valid for the duration of the callback. 737 Also, you are not to modify the contents of any supplied buffer. 738 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 739 @param refCon refCon passed to callback. 740 @param callback address of callback method of type FWSBP2LoginCallback. 741 */ 742 743 void (*setLoginCallback)( void * self, void * refCon, IOFWSBP2LoginCallback callback ); 744 745 /*! 746 @function setLogoutCallback 747 @abstract Sets the callback to be called when a logout attempt is complete. 748 @discussion The supplied callback is called when a logout attempt has completed. "status" in the 749 callback's params should be checked to determine the success or failure of the logout attempt. 750 The "refCon" field in the params will return the refcon set with setRefCon. 751 If "statusBlock" is non-null then logout status was written and it has been supplied here. 752 Note: all buffers supplied to callbacks are only valid for the duration of the callback. 753 Also, you are not to modify the contents of any supplied buffer. 754 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 755 @param refCon refCon passed to callback. 756 @param callback address of callback method of type FWSBP2LogoutCallback. 757 */ 758 759 void (*setLogoutCallback)( void * self, void * refCon, IOFWSBP2LogoutCallback callback ); 760 761 /*! 762 @function setRefCon 763 @abstract Sets the login refCon. 764 @discussion Sets a user defined value on the login that can be retrieved later with the 765 method getRefCon. 766 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 767 @param refCon a user defined value. 768 */ 769 770 void (*setRefCon)( void * self, void * refCon ); 771 772 /*! 773 @function getRefCon 774 @abstract Returns the refCon set with setRefCon. 775 @discussion Returns the user defined value previously stored in the login with setRefCon. 776 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 777 @result Returns the previously stored user defined value. 778 */ 779 780 void * (*getRefCon)( void * self); 781 782 /*! 783 @function getMaxCommandBlockSize 784 @abstract Returns the maximum command block size. 785 @discussion The device publishes an upper limit on the size of command block that it can 786 accept. That value can be accessed via this method. 787 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 788 @result Returns a UInt32 containing the maximum command block size. 789 */ 790 791 UInt32 (*getMaxCommandBlockSize)( void * self); 792 793 /*! 794 @function getLoginID 795 @abstract Returns the current login ID. 796 @discussion When we successfully login to a device. The device gives us a unique login id. 797 This is used internally for reconnecting to the device after bus resets and for certain other 798 management ORBs. Most drivers are probably not interested in this value. 799 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 800 @result Returns a UInt32 containing the current login ID. 801 */ 802 803 UInt32 (*getLoginID)( void * self); 804 805 /*! 806 @function setMaxPayloadSize 807 @abstract Sets the maximum data transfer length for a normal command ORB. 808 @discussion Sets the maximum data transfer length for a normal command ORB. This value is 809 the maximum for all ORBs sent to this LUN. This can be trimmed further on an ORB by ORB basis, 810 by a similar call in the IOFireWireSBP2ORB itself. 811 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 812 @param size The desired maximum payload size in bytes. 813 */ 814 815 void (*setMaxPayloadSize)( void * self, UInt32 size ); 816 817 /*! 818 @function setReconnectTime 819 @abstract Sets the desired reconnect duration. 820 @discussion The target and initiator arbitrate the duration of the reconnect timeout. Here 821 the initiator specifies its desired timeout time in 2^reconnectTime seconds. After a 822 successful login the device returns the actual timeout value it wishes to use. This value 823 may be less than the reconnect timeout that the intiator specified if this is all that the 824 device can support. 825 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 826 @param time The desired reconnect timeout encoded as 2^reconnectTime seconds. 827 */ 828 829 void (*setReconnectTime)( void * self, UInt32 time ); 830 831 /*! 832 @function createORB 833 @abstract Creates a new IOFireWireSBP2ORB for this login. 834 @discussion Create a new IOFireWireSBP2ORB for this login. It can be configured 835 with it's accessors and executed with submitORB below. 836 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 837 @param iid UUID for the desired type of IOFireWireSBP2LibLoginInterface. 838 @result Returns a pointer to the new ORB object. 839 */ 840 841 IUnknownVTbl** (*createORB)( void * self, REFIID iid ); 842 843 /*! 844 @function submitORB 845 @abstract Submits the given orb 846 @discussion Starts execution of the given ORB. If the ORB is an immediate ORB it's 847 addresss is written to the fetch agent. If it is a non immediate orb its address 848 is appended to the last orb of the currently processing chain. The doorbell is not 849 rung automatically it must be run manually with the ringDoorbell command described below. 850 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 851 @param orb The orb to be executed. 852 @result Returns kIOReturnSuccess if the ORB has been started successfully. 853 */ 854 855 IOReturn (*submitORB)( void * self, IOFireWireSBP2LibORBInterface ** orb ); 856 857 /*! 858 @function setUnsolicitedStatusNotify 859 @abstract Sets the callback to be called on normal command status. 860 @discussion The supplied callback is called when unsolicited status is recieved. 861 "notificationEvent" in the callback's params will indicate what happened. In this 862 case it will be set to kFWSBP2UnsolicitedStatus. If "len" is 863 non-zero then "message" contains the data written to the status block. Note: any buffers 864 returned by callbacks are only valid for the duration of the login and should not have 865 their contents modified. The "refCon" field in the callback's 866 params will return the refcon set with setRefCon. 867 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 868 @param refCon refCon passed to callback. 869 @param callback address of callback method of type FWSBP2NotifyCallback. 870 */ 871 872 void (*setUnsolicitedStatusNotify)( void * self, void * refCon, IOFWSBP2NotifyCallback callback ); 873 874 /*! 875 @function setStatusNotify 876 @abstract Sets the callback to be called on normal command status. 877 @discussion The supplied callback is called when normal command status is recieved, when 878 a normal command times out, or when a normal command is aborted. 879 "notificationEvent" in the callback's params will indicate what happened. 880 It will be set to one of the following values: kFWSBP2NormalCommandReset, kFWSBP2NormalCommandStatus, 881 or kFWSBP2NormalCommandTimeout. If the event type is kFWSBP2NormalCommandTimeout and "len" is 882 non-zero then "message" contains the data written to the status block. 883 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 884 @param refCon refCon passed to callback. 885 @param callback Address of callback method of type FWSBP2NotifyCallback. 886 */ 887 888 void (*setStatusNotify)( void * self, void * refCon, IOFWSBP2NotifyCallback callback ); 889 890 /*! 891 @function setFetchAgentResetCallback 892 @abstract Sets the callback to be called when a fetch agent reset completes. 893 @discussion The fetch agent state machine on the device can be reset by a write to a specific 894 register. The SBP2 services offer a utility method to reset the fetch agent. You can register 895 a callback routine here to be notified when this rest write completes. 896 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 897 @param refCon refCon passed to callback. 898 @param callback address of callback method of type FWSBP2FetchAgentWriteCallback. 899 */ 900 901 void (*setFetchAgentResetCallback)( void * self, void * refCon, IOFWSBP2StatusCallback callback ); 902 903 /*! 904 @function submitFetchAgentReset 905 @abstract Resets the LUN's fetch agent. 906 @discussion The fetch agent state machine on the device can be reset by a write to a specific 907 register. This reset can be intiated by a call to this method. Notification of the completion 908 of this write can be had by registering a callback with the setFetchAgentResetCallback method. 909 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 910 @result Returns kIOReturnSuccess if the reset started successfully. 911 */ 912 913 IOReturn (*submitFetchAgentReset)( void * self ); 914 915 /*! 916 @function setFetchAgentWriteCallback 917 @abstract Sets the callback to be called when the fetch agent write completes. 918 @discussion When an immediate orb is executed with submitORB, it's address is written to a 919 specific address on the device. This address is called the fetch agent. The device the 920 reads that orb from the Mac's memory and executes it. With this call you can register to 921 be called back when this write to the fetch agent completes. The SBP2 services guarantee 922 that the fetch agent write will be complete before status is reported for an ORB, so for 923 most drivers this notification is not required. 924 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 925 @param refCon refCon passed to callback. 926 @param callback address of callback method of type FWSBP2FetchAgentWriteCallback. 927 */ 928 929 void (*setFetchAgentWriteCallback)( void * self, void * refCon, IOFWSBP2FetchAgentWriteCallback callback ); 930 931 /*! 932 @function ringDoorbell 933 @abstract Rings the doorbell on the LUN. 934 @discussion Non-immediate appends to the ORB chain may require the fetch agent state machine 935 to be notified of the new ORB's presence. This is accomplished by writing to the so called 936 doorbell register. This method begins one of those writes. 937 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 938 @result Returns kIOReturnSuccess if the ring started successfully. 939 */ 940 941 IOReturn (*ringDoorbell)( void * self ); 942 943 /*! 944 @function enableUnsolicitedStatus 945 @abstract Enables unsolicited status. 946 @discussion After unsolicited is sent the device will not send any additional unsolicited status 947 until a specific register is written. This serves as a sort of flow-control for unsolicited status. 948 After unsolicited status is recieved and processed drivers will want to reenable the delivery 949 of unsolicted status by a call to this method. 950 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 951 @result Returns kIOReturnSuccess if the status enable write started successfully. 952 */ 953 954 IOReturn (*enableUnsolicitedStatus)( void * self ); 955 956 /*! 957 @function setBusyTimeoutRegisterValue 958 @abstract Sets the value to be written to the BUSY_TIMEOUT register. 959 @discussion 1394-1995 defines a register known as the BUSY_TIMEOUT register. This register 960 controls the busy retry behavior of your device. The initial value for this register is 961 0x00000000. Which means busied transactions will not be retried. Since most devices want 962 their transactions retired on busy acks, the SBP2 service automatically updates the 963 BUSY_TIMEOUT register with the value specified here whenever necessary. Most drivers should 964 set this value to 0x0000000f. 965 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 966 @param timeout desired value of the BUSY_TIMEOUT register. 967 */ 968 969 IOReturn (*setBusyTimeoutRegisterValue)( void * self, UInt32 timeout ); 970 971 /*! 972 @function setPassword 973 @abstract Sets the login password. 974 @discussion Sets the login password using a buffer and a length. An alternate version exists 975 that accepts an IOMemoryDescriptor. If the password length is 8 or less the password is copied 976 directly into the login orb. If the length is greater than 8 the buffer is referenced by address 977 in the login ORB. In this case the buffer is not copied and should remain allocated for the 978 duration of the login attempt. 979 @param self Pointer to IOFireWireSBP2LibLoginInterface object. 980 @param buffer a pointer to the password buffer. 981 @param length the length in bytes of the password buffer. 982 @result Returns kIOReturnSuccess on success. 983 */ 984 985 IOReturn (*setPassword)( void * self, void * buffer, UInt32 length ); 986 987} IOFireWireSBP2LibLoginInterface; 988 989 990/*! 991 @class IOFireWireSBP2LibMgmtORBInterface 992 @abstract Supplies non login related management ORBs. Management ORBs can be executed independent 993 of a login, if necessary. Management ORBs are created using the IOFireWireSBP2LibLUNInterface. 994*/ 995typedef struct 996{ 997 998 IUNKNOWN_C_GUTS; 999 1000 UInt16 version; 1001 UInt16 revision; 1002 1003 /*! 1004 @function submitORB 1005 @abstract Submits this ORB for execution. 1006 @discussion Submits this ORB for execution 1007 @param self Pointer to a IOFireWireSBP2LibMgmtORBInterface. 1008 */ 1009 1010 IOReturn (*submitORB)( void * self ); 1011 1012 /*! 1013 @function setORBCompleteCallback 1014 @abstract Sets the ORB completion routine. 1015 @discussion Sets the completion routine to be called when the ORB finishes execution. The refCon 1016 set with setRefCon will also be passed as the third argument to the completion handler. 1017 @param self Pointer to a IOFireWireSBP2LibMgmtORBInterface. 1018 @param refCon refCon passed as first argument to completion routine 1019 */ 1020 1021 void (*setORBCompleteCallback)( void * self, void * refCon, 1022 IOFWSBP2ORBCompleteCallback callback ); 1023 /*! 1024 @function setRefCon 1025 @abstract Sets the login refCon. 1026 @discussion Sets a user defined value on the login that can be retrieved later with the 1027 method getRefCon. 1028 @param self Pointer to a IOFireWireSBP2LibMgmtORBInterface. 1029 @param refCon a user defined value. 1030 */ 1031 1032 void (*setRefCon)( void * self, void * refCon ); 1033 1034 /*! 1035 @function getRefCon 1036 @abstract Returns the current function of the management ORB. 1037 @discussion Returns the function of the management ORB. This is the same value that was 1038 set with setCommandFunction. 1039 @param self Pointer to a IOFireWireSBP2LibMgmtORBInterface. 1040 @result Returns the function of the management ORB. 1041 */ 1042 1043 void * (*getRefCon)( void * self); 1044 1045 /*! 1046 @function setCommandFunction 1047 @abstract Sets the function of the management ORB. 1048 @discussion Sets the the function of the management ORB. Legal values are kFWSBP2QueryLogins, 1049 kFWSBP2AbortTask, kFWSBP2AbortTaskSet, kFWSBP2LogicalUnitReset, and kFWSBP2TargetReset. 1050 @param self Pointer to a IOFireWireSBP2LibMgmtORBInterface. 1051 @param function a value indicating the desired management function. 1052 @result Returns kIOReturnSuccess if function was a legal function. 1053 */ 1054 1055 IOReturn (*setCommandFunction)( void * self, UInt32 function ); 1056 1057 /*! 1058 @function setManageeORB 1059 @abstract Sets the command to be managed by the management ORB. 1060 @discussion All management functions except kFWSBP2QueryLogins require a reference to an ORB of 1061 some sort. kFWSBP2AbortTask requires a reference to the ORB to be aborted. 1062 This method allows you to set the Normal Command ORB to be managed. 1063 @param self Pointer to a IOFireWireSBP2LibMgmtORBInterface. 1064 @param command a reference to an IOFireWireSBP2Login or an IOFireWireSBP2ORB. 1065 @result Returns kIOReturnSuccess on a success. 1066 */ 1067 1068 IOReturn (*setManageeORB)( void * self, void * command ); 1069 1070 /*! 1071 @function setManageeLogin 1072 @abstract Sets the command to be managed by the management ORB. 1073 @discussion All management functions except kFWSBP2QueryLogins require a reference to an ORB of 1074 some sort. kFWSBP2AbortTaskSet, kFWSBP2LogicalUnitReset, and kFWSBP2TargetReset require a 1075 reference to the login ORB. 1076 This method allows you to set the login ORB to be managed. 1077 @param self Pointer to a IOFireWireSBP2LibMgmtORBInterface. 1078 @param command a reference to an IOFireWireSBP2Login or an IOFireWireSBP2ORB. 1079 @result Returns kIOReturnSuccess on a success. 1080 */ 1081 1082 IOReturn (*setManageeLogin)( void * self, void * command ); 1083 1084 /*! 1085 @function setResponseBuffer 1086 @abstract Sets the response buffer for the management ORB. 1087 @discussion Sets the response buffer for the management ORB. kFWSBP2QueryLogins returns 1088 a response to its query and needs to write it somewhere. This routine allows you to 1089 specify the location. 1090 @param self Pointer to a IOFireWireSBP2LibMgmtORBInterface. 1091 @param buf backing store for buffer 1092 @param len length of buffer. 1093 @result Returns kIOReturnSuccess on a success. 1094 */ 1095 1096 IOReturn (*setResponseBuffer)( void * self, void * buf, UInt32 len ); 1097 1098} IOFireWireSBP2LibMgmtORBInterface; 1099 1100#endif 1101