Chameleon

Chameleon Svn Source Tree

Root/branches/rewrite/i386/include/IOKit/bluetooth/IOBluetoothHCIController.h

Source at commit 1146 created 12 years 11 months ago.
By azimutz, Sync with trunk (r1145). Add nVidia dev id's, 0DF4 for "GeForce GT 450M" (issue 99) and 1251 for "GeForce GTX 560M" (thanks to oSxFr33k for testing).
1/*␊
2␉File:␉␉IOBluetoothHCIController.h␊
3␉Contains:␉Bluetooth Host Controller base class.␊
4␉Copyright:␉(c) 2001-2008 by Apple, all rights reserved.␊
5*/␊
6␊
7␊
8#pragma once␊
9␊
10//====================================================================================================␊
11// Imports␊
12//====================================================================================================␊
13␊
14#import <IOKit/IOService.h>␊
15#import <IOKit/system.h>␊
16#import <IOKit/system.h>␊
17#import <kern/thread_call.h>␊
18␊
19#import </usr/include/AvailabilityMacros.h>␊
20␊
21#include <IOKit/pwr_mgt/RootDomain.h>␊
22␊
23#import <IOKit/bluetooth/Bluetooth.h>␊
24␊
25#import <IOKit/bluetooth/IOBluetoothTypes.h>␊
26#import <IOKit/bluetooth/IOBluetoothInternal.h>␊
27␊
28//====================================================================================================␊
29// Forward declarations␊
30//====================================================================================================␊
31␊
32class OSSet;␊
33class IOWorkLoop;␊
34class IOCommandGate;␊
35class IOWorkQueue;␊
36class IOBluetoothDevice;␊
37class IOBluetoothHCIRequest;␊
38class IOBluetoothHCIController;␊
39class IOBluetoothACLMemoryDescriptor;␊
40class IOTimerEventSource;␊
41class IOBluetoothInactivityTimerEventSource;␊
42class IOBluetoothHCIPacketLogUserClient;␊
43␊
44//====================================================================================================␊
45// defines, typdefs, etc.␊
46//====================================================================================================␊
47␊
48#define kNoReturnParam␉␉␉␉␉NULL␊
49␊
50typedef␉uint16_t␉DevicePublishNotificationStateType;␊
51enum DevicePublishNotificationStateTypes␊
52{␊
53␉kHasNotRegisteredForDevicePublishNotification␉␉= 0x0001,␊
54␉kHasRegisteredForDevicePublishNotification␉␉␉= 0x0002,␊
55␉kDevicePublishNotificationCalled␉␉␉␉␉= 0x0004,␊
56␉kDevicePublishNotificationProcessed␉␉␉␉␉= 0x0008␊
57};␊
58␊
59typedef UInt32 HCIDataHandlerType;␊
60enum HCIDataHandlerTypes␊
61{␊
62␉kTransportDataTypeHCIEvents,␊
63␉kTransportDataTypeACL,␊
64␉kTransportDataTypeSCO␊
65};␊
66␊
67typedef IOReturn (*IOBluetoothIncomingDataAction) ( IOBluetoothHCIController *hciController, UInt8 *inDataPtr, UInt32 inDataSize, UInt32 inSequenceNumber );␊
68typedef IOReturn (*IOBluetoothHCIControllerDataHandler) ( void * contextPtr, const UInt8 * data, UInt32 dataSize );␊
69␊
70typedef struct HCIDataHandler␉HCIDataHandler;␊
71struct HCIDataHandler␊
72{␊
73␉IOBluetoothHCIControllerDataHandler␉␉procPtr;␊
74␉void * ␉␉␉␉␉␉␉␉␉contextPtr;␊
75};␊
76␊
77typedef struct HCIEventNotificationListener␉HCIEventNotificationListener;␊
78struct HCIEventNotificationListener␊
79{␊
80␉task_t␉␉␉␉owningTask;␉␉// Used to ID these things when adding/removing them from our listener pool.␊
81␉mach_port_t␉␉␉port;␉␉␉// Mach port to send out the notificaton.␊
82␉void * ␉␉␉␉refCon;␉␉␉// RefCon for the port's use.␊
83};␊
84␊
85#define POWER_STATE_CHANGE_IN_PROGRESS()␉( mCurrentInternalPowerState != mPendingInternalPowerState )␊
86#define␉IS_POWERING_DOWN()␉( POWER_STATE_CHANGE_IN_PROGRESS() && ( mPendingInternalPowerState == kIOBluetoothHCIControllerInternalPowerStateOff ) )␊
87␊
88//====================================================================================================␊
89// Callback structure for data:␊
90//====================================================================================================␊
91␊
92typedef struct SendDataContext␊
93{␊
94␉// Data sent:␊
95␉IOMemoryDescriptor *memoryDescriptorPointer;␊
96␉␊
97␉// Referece to the device that sent the data:␊
98␉IOBluetoothDevice *devicePointer;␊
99␉void *devicePointerContextInfo0;␊
100␉void *devicePointerContextInfo1;␊
101␉␊
102␉// And the controller that received it:␊
103␉IOBluetoothHCIController *hciController;␊
104␉void *controllerPointerContextInfo0;␊
105␉void *controllerPointerContextInfo1;␊
106␉␊
107␉// ReturnValue:␊
108␉IOReturn sendingWasSuccessful;␊
109} SendDataContext;␊
110␊
111␊
112//====================================================================================================␊
113// Keep track of hearing devices␊
114//====================================================================================================␊
115typedef struct HearingDeviceListType␊
116{␊
117␉BluetoothDeviceAddress␉␉␉␉␉mDeviceAddress;␊
118␉bool␉␉␉␉␉␉␉␉␉mRemoveDeviceCalled;␊
119␉DevicePublishNotificationStateType␉␉mDevicePublishNotificationState;␊
120␉HearingDeviceListType *␉␉␉␉␉mNextDevice;␊
121␉HearingDeviceListType *␉␉␉␉␉mPreviousDevice;␊
122} HearingDeviceListType;␊
123␊
124//====================================================================================================␊
125// IOBluetoothHCIController␊
126//====================================================================================================␊
127␊
128class IOBluetoothHCIController : public IOService␊
129{␊
130␉// We don't make many friends, but at least we have a few...␊
131␊
132 friend class IOBluetoothHCIPacketLogUserClient;␊
133 friend class IOBluetoothSerialManager;␊
134 friend class IOBluetoothHCIUserClient;␊
135 friend class IOBluetoothDevice;␊
136␉friend class IOBluetoothHCIRequest;␊
137␉␊
138␉// IOKit stuff.␊
139␉␊
140 OSDeclareDefaultStructors( IOBluetoothHCIController )␊
141␊
142protected:␊
143␊
144␉IOWorkLoop *␉␉␉␉␉mWorkLoop;␊
145␉IOCommandGate *␉␉␉␉␉mCommandGate;␊
146␉IOWorkQueue *␉␉␉␉␉mWorkQueue;␊
147␉IOTimerEventSource *␉␉␉mTimerEventSource;␊
148␉Boolean␉␉␉␉␉␉␉mShouldRunInactivityTimer;␊
149␉␊
150␉// Data and request queue stuff.␊
151␉␊
152␉HCIEventNotificationListener*␉mHCIEventListenersList;␊
153␉size_t␉␉␉␉␉␉␉mHCIEventListenersListSize;␊
154 ␉HCIDataHandler*␉␉␉␉␉mHCIEventDataHandlerList;␊
155␉size_t␉␉␉␉␉␉␉mHCIEventDataHandlerListSize;␊
156␉HCIDataHandler*␉␉␉␉␉mACLDataHandlerList;␊
157␉size_t␉␉␉␉␉␉␉mACLDataHandlerListSize;␊
158␉HCIDataHandler*␉␉␉␉␉mSCODataHandlerList;␊
159␉size_t␉␉␉␉␉␉␉mSCODataHandlerListSize;␊
160␉␊
161␉IOBluetoothHCIRequest *␉ ␉␉mBusyQueueHead;␊
162␉IOBluetoothHCIRequest *␉ ␉␉mWaitQueueHead;␊
163␉IOBluetoothHCIRequest **␉␉mHCIRequestList;␊
164␊
165 IOBluetoothDevice *␉␉␉␉mDeviceListHead;␊
166␉␊
167␉OSSet *␉␉␉␉␉␉␉mPacketLogClients;␊
168␉UInt8 *␉␉␉␉␉␉␉mPacketLogBuffer;␊
169␉UInt32␉␉␉␉␉␉␉mPacketLogBufferSize;␊
170 ␊
171␉uint8_t *␉␉␉␉␉␉mEventDataBuffer;␉␉␉// Events without matching requests will use this.␊
172␉size_t␉␉␉␉␉␉␉mEventDataBufferSize;␊
173␉␊
174 // This keeps track of the ACL packets we actually sent:␊
175 BluetoothHCIBufferSize␉␉␉mHCIBufferSize;␊
176 UInt16␉␉␉␉␉␉␉mNumOutstandingACLPackets;␊
177 ␊
178 OSArray *␉␉␉␉␉␉mAllowedIncomingL2CAPChannels;␊
179 ␊
180 UInt32␉␉␉␉␉␉␉mNextAvailableSequenceNumber;␊
181 UInt32␉␉␉␉␉␉␉mCurrentlyExecutingSequenceNumber;␊
182 UInt16␉␉␉␉␉␉␉mActiveConnections;␊
183␉␊
184␉// Packet Queue description:␊
185␉typedef struct QueuePacketHolder {␊
186␉␉IOMemoryDescriptor␉␉␉␉␉␉␉␉*memDescriptor;␉// The data we need to send␊
187␉␉SendDataContext *␉␉␉␉␉␉␉␉contextPtr;␉␉// Context pointer for the sent data.␊
188␉␉IOBluetoothDevice *␉␉␉␉␉␉␉␉inTargetDevice;␉// The device that enqueued the data.␊
189␉␉struct QueuePacketHolder␉␉␉␉␉␉*next;␉␉␉// The next block in the queue.␊
190␉} QueuePacketHolder;␊
191 QueuePacketHolder *mACLQueueHead, *mACLQueueTail;␊
192␉␊
193␉// Counters to limit the number of packets in the queue (we do not want to go out of memory)␊
194␉UInt32 mNumberOfPacketsInQueue;␊
195␊
196␉// The allowed RFCOMM channels␊
197 OSArray *mAllowedIncomingRFCOMMChannels;␊
198 ␊
199␉IOBluetoothHCIControllerInternalPowerState␉mCurrentInternalPowerState;␊
200␉IOBluetoothHCIControllerInternalPowerState␉mPendingInternalPowerState;␊
201␉Boolean␉␉␉␉␉␉␉␉␉␉mAsyncPowerStateChangeInProgress;␊
202␉UInt32␉␉␉␉␉␉␉␉␉␉mPendingPowerStateChangeOptions;␊
203␉IOBluetoothHCIControllerPowerOptions␉␉mControllerPowerOptions;␊
204␉Boolean␉␉␉␉␉␉␉␉␉␉mPowerStateChangeIsUserEnforced;␊
205␉␊
206␉Boolean␉␉␉␉␉␉␉␉␉␉mHardwareSetupComplete;␊
207␉␊
208␉IOBluetoothHCIControllerConfigState␉␉mControllerConfigState;␊
209␉IOBluetoothHCIControllerConfigState␉␉mPreviousControllerConfigState;␊
210␉␊
211␉IOBluetoothHCIControllerFeatureFlags␉mControllerFeatureFlags;␊
212␊
213␉// Overrides.␊
214␊
215␉bool ␉␉␉␉start( IOService * provider );␊
216␊
217␉bool␉␉ ␉␉init( OSDictionary* dictionary );␊
218␊
219 virtual void␉␉free();␊
220␊
221#if defined( MAC_OS_X_VERSION_10_5 )␊
222 virtual void␉␉systemWillShutdown( IOOptionBits specifier );␊
223#endif␊
224␊
225 static IOReturn␉␉initHardwareAction(␉OSObject␉*owner,␊
226 void␉␉*arg1,␊
227 void␉␉*arg2,␊
228 void␉␉*arg3,␊
229 void␉␉*arg4 );␊
230 ␊
231 virtual bool␉␉initHardware( IOService * provider );␊
232␉␊
233 static IOReturn␉␉setupHardwareAction(␉OSObject␉*owner,␊
234␉␉␉␉␉␉␉␉␉␉␉␉void␉␉*arg1,␊
235␉␉␉␉␉␉␉␉␉␉␉␉void␉␉*arg2,␊
236␉␉␉␉␉␉␉␉␉␉␉␉void␉␉*arg3,␊
237␉␉␉␉␉␉␉␉␉␉␉␉void␉␉*arg4 );␊
238 ␊
239␉virtual IOReturn␉setupHardware( IOService* provider );␊
240␊
241 virtual void␉␉hardwareSetupComplete( IOReturn status );␊
242 ␊
243␉virtual␉void␉␉setConfigState( IOBluetoothHCIControllerConfigState configState );␊
244␉virtual␉bool␉␉terminate( IOOptionBits options = 0 );␊
245␉virtual bool␉␉willTerminate( IOService * provider, IOOptionBits options );␊
246␉virtual bool␉␉didTerminate( IOService * provider, IOOptionBits options, bool * defer );␊
247␉␊
248␉void ␉␉␉␉stop( IOService * provider );␊
249␉␊
250␉IOReturn␉␉␉newUserClient(␉task_t ␉␉␉␉owningTask,␊
251␉␉␉␉␉␉␉␉␉␉void *␉␉␉␉securityID,␊
252␉␉␉␉␉␉␉␉␉␉UInt32 ␉␉␉␉type,␊
253␉␉␉␉␉␉␉␉␉␉IOUserClient **␉␉handler );␊
254␉␊
255␉uint32_t␉␉␉CountExistingHCIControllers();␊
256␊
257␉virtual IOReturn␉powerStateWillChangeTo(␉IOPMPowerFlags␉powerFlags,␊
258␉␉␉␉␉␉␉␉␉␉␉␉unsigned long␉powerState,␊
259␉␉␉␉␉␉␉␉␉␉␉␉IOService *␉␉from );␊
260␊
261␉virtual␉unsigned long␉maxCapabilityForDomainState( IOPMPowerFlags domainState );␊
262␊
263␉virtual unsigned long␉initialPowerStateForDomainState ( IOPMPowerFlags powerFlags );␊
264␊
265␉// Our protected custom stuff.␊
266␉␊
267 static IOReturn␉␉DetachUserClientsAction(␉OSObject *owner,␊
268 void *arg1,␊
269 void *arg2,␊
270 void *arg3,␊
271 void *arg4 );␊
272␊
273 virtual void␉␉DetachUserClients();␊
274␉␊
275 static IOReturn␉␉setPropertiesAction( OSObject␉*owner, ␊
276 void␉␉*arg1, ␊
277 void␉␉*arg2, ␊
278 void␉␉*arg3, ␊
279 void␉␉*arg4 );␊
280 ␊
281 virtual IOReturn␉setPropertiesWL( OSObject * properties );␊
282␊
283 static IOReturn␉␉AddPacketLogUserClientAction(␉OSObject *owner, ␊
284 void *arg1, ␊
285 void *arg2, ␊
286 void *arg3, ␊
287 void *arg4 );␊
288␊
289 virtual IOReturn␉AddPacketLogUserClient( IOBluetoothHCIPacketLogUserClient *newPacketLogUserClient );␊
290␉␊
291␉virtual bool␉␉PacketLogFillBufferedData();␊
292␉␊
293 virtual void␉␉PacketLogClientClosed( IOBluetoothHCIPacketLogUserClient *packetLogClient );␊
294␉␊
295 virtual void␉␉LogPacket( UInt8 packetType, void *packetData, size_t packetSize );␊
296␊
297␉static IOReturn␉␉LogPacketAction( OSObject *owner, void *arg1, void *arg2, void *arg3, void *arg4 );␊
298␊
299␉virtual␉void␉␉DesyncIncomingData( IOBluetoothIncomingDataAction action, UInt8 *inDataPtr, UInt32 inDataSize );␊
300 ␊
301␉static␉void␉␉DesyncIncomingDataAction( IOBluetoothHCIController *hciController, IOBluetoothIncomingDataAction action, void *inDataPtr, UInt32 inDataSize, UInt32 sequenceNumber );␊
302␉␊
303 virtual void␉␉SynchronizePacketSequence( UInt32 sequenceNumber );␊
304 ␊
305 virtual IOReturn␉AddDevice( IOBluetoothDevice *inDevice );␊
306 ␊
307 virtual IOReturn␉RemoveDevice( IOBluetoothDevice *inDevice );␊
308 ␊
309 virtual IOReturn␉CreateDeviceFromConnectionResults( BluetoothHCIEventConnectionCompleteResults *connectionResults );␊
310 ␊
311 virtual IOReturn␉DestroyDeviceWithDisconnectionResults( BluetoothHCIEventDisconnectionCompleteResults *disconnectionResults );␊
312 ␊
313 virtual IOReturn␉DestroyDevice( IOBluetoothDevice *inDevice );␊
314 ␊
315 virtual IOReturn␉DestroyAllDevices();␊
316␊
317 virtual void␉␉FlushDeviceACLPackets( IOBluetoothDevice *inDevice );␊
318 ␊
319 virtual void␉␉DecrementOutstandingACLPackets( UInt16 delta );␊
320 ␊
321 virtual void␉␉ProcessFlushOccurredEvent( BluetoothHCIEventFlushOccurredResults *inFlushResults );␊
322 ␊
323 virtual void␉␉ProcessNumCompletedPacketsEvent( UInt8 *inDataPtr );␊
324 ␊
325 virtual void␉␉ProcessHCIControllerResetEvent();␊
326 ␊
327 virtual IOReturn␉DispatchIncomingACLData( UInt8 *inDataPtr, UInt32 inDataSize );␊
328␊
329␉// Common methods for L2CAP and RFCOMM channel managment:␊
330␉virtual void␉␉MergeChannelDescription(OSDictionary *destination , OSDictionary *source);␊
331␉virtual void␉␉RemoveChannelRestrictions(OSDictionary *toChange , OSDictionary *removeRule, const char *key);␊
332␉virtual Boolean␉␉IsAllowedDevice(OSDictionary *description , IOBluetoothDevice *device);␊
333␉virtual void␉␉RemoveAllRules();␊
334␊
335␉// L2CAP channel managment methods:␊
336 virtual void␉␉RemoveAllowedIncomingL2CAPChannel( OSObject *channelID );␊
337␉virtual IOReturn ␉AddAllowedIncomingL2CAPChannel( OSDictionary *channelDescription );␊
338␉virtual OSDictionary *GetIncomingL2CAPChannelDescription( OSNumber *psmNumber );␊
339␊
340␉// L2CAP channel accessory methods:␊
341 virtual void␉␉AddAllowedIncomingL2CAPChannel( BluetoothL2CAPPSM incomingPSM );␊
342 virtual void␉␉AddAllowedIncomingL2CAPChannel( OSNumber *psmNumber );␊
343 virtual void ␉␉RemoveAllowedIncomingL2CAPChannel( BluetoothL2CAPPSM incomingPSM );␊
344␊
345␉// RFCOMM channel managment methods:␊
346␉virtual OSDictionary *GetIncomingRFCOMMChannelDescription( OSNumber *channelIDNumber );␊
347␉virtual IOReturn ␉AddAllowedIncomingRFCOMMChannel( OSDictionary *channelDescription );␊
348 virtual void␉␉RemoveAllowedIncomingRFCOMMChannel( OSObject *channelID );␊
349␊
350␉// RFCOMM channel accessory methods:␊
351 virtual void␉␉AddAllowedIncomingRFCOMMChannel( BluetoothRFCOMMChannelID incomingChannelID );␊
352 virtual void␉␉AddAllowedIncomingRFCOMMChannel( OSNumber *channelIDNumber );␊
353 virtual void␉␉AddSecureIncomingRFCOMMChannel( BluetoothRFCOMMChannelID incomingChannelID );␊
354 virtual void␉␉AddSecureIncomingRFCOMMChannel( OSNumber *channelIDNumber );␊
355 virtual void ␉␉RemoveAllowedIncomingRFCOMMChannel( BluetoothRFCOMMChannelID incomingChannelID );␊
356␉␉␊
357␉virtual IOReturn␉TransferACLPacketToHW(IOMemoryDescriptor *memDescriptor,␊
358␉␉␉␉␉␉␉␉␉␉␉␉␉SendDataContext *␉␉␉␉␉␉␉␉contextPtr);␊
359␉␊
360␉// ACL Packet queue:␊
361␉virtual IOReturn␉EnqueuePacket(␉IOMemoryDescriptor␉*memDescriptor,␊
362␉␉␉␉␉␉␉␉␉␉SendDataContext␉␉*contextPtr,␊
363␉␉␉␉␉␉␉␉␉␉IOBluetoothDevice␉*inTargetDevice);␊
364␉␉␉␉␉␉␉␉␉␉␊
365␉virtual IOReturn␉DequeuePacket();␊
366␉␊
367␉virtual IOReturn␉RemoveAllPacketsBelongingTo(IOBluetoothDevice␉*inTargetDevice);␊
368␊
369public:␊
370␊
371 // IOWorkLoop and IOCommandGate accessors␊
372 ␊
373 virtual IOWorkLoop *getWorkLoop() const;␊
374 ␊
375 virtual IOCommandGate *getCommandGate() const;␊
376 ␊
377 virtual IOReturn setProperties( OSObject * properties );␊
378␊
379␉// Subclasses must implement these for it to be a working transport␊
380␉// in the Bluetooth Family world.␊
381␉␊
382␉virtual␉IOReturn␉SendHCIRequest(␉UInt8 * ␉␉␉␉␉buffer,␊
383␉␉␉␉␉␉␉␉␉␉IOByteCount␉␉␉␉␉bufferSize );␊
384␊
385␉static␉IOReturn␉SendACLCompletedAction ( OSObject *owner, void *arg1, void *arg2, void *arg3, void *arg4, void *arg5, void *arg6 );␊
386␉␊
387␉virtual␉void␉␉SendACLCompleted(␉SendDataContext␉*contextPtr);␊
388␉␉␊
389␉virtual␉IOReturn␉SendACLData(␉IOMemoryDescriptor␉␉␉␉␉␉*memDescriptor,␊
390␉␉␉␉␉␉␉␉␉␉SendDataContext *␉␉␉␉␉␉contextPtr );␊
391␊
392␉virtual␉IOReturn␉GetTransportInfo( BluetoothTransportInfo *␉infoStruct );␊
393␉␊
394␉static␉IOReturn␉SendSCOCompletedAction ( OSObject *owner, void *arg1, void *arg2, void *arg3, void *arg4, void *arg5, void *arg6 );␊
395␉␊
396␉// Override to do something custom with the data. Otherwise, the registered data handler␊
397␉// will get a peek at it.␊
398␉␊
399 // The ProcessXXXData() functions are safe to be called from anywhere.␊
400 // They call ProcessXXXDataWL() on the workloop using ProcessXXXDataAction()␊
401 ␊
402␉virtual␉void␉ ␉ProcessEventData( UInt8 * inDataPtr, UInt32 inDataSize );␊
403␉␉␊
404␉virtual␉void␉ ␉ProcessACLData( UInt8 * data, UInt32 dataSize );␊
405␉␊
406␉virtual␉void␉ ␉ProcessSCOData( UInt8 * data, UInt32 dataSize, UInt32 inMissingData, AbsoluteTime inTimestamp, Boolean copyData );␊
407 ␊
408␉virtual␉void␉ ␉ProcessEventDataWL( UInt8 * inDataPtr, UInt32 inDataSize, UInt32 sequenceNumber );␊
409␉␉␊
410␉virtual␉void␉ ␉ProcessACLDataWL( UInt8 * data, UInt32 dataSize, UInt32 sequenceNumber );␊
411␉␊
412␉virtual␉void␉ ␉ProcessSCODataWL( UInt8 * data, UInt32 dataSize, UInt32 inMissingData, AbsoluteTime inTimestamp, Boolean copyData );␊
413 ␊
414␉static␉IOReturn␉ProcessEventDataAction( IOBluetoothHCIController *␉hciController,␊
415␉␉␉␉␉␉␉␉␉␉␉␉UInt8 *␉␉␉␉␉␉incomingDataPtr,␊
416␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉inDataSize,␊
417␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉inSequenceNumber );␊
418␉␉␊
419␉static␉IOReturn␉ProcessACLDataAction(␉IOBluetoothHCIController *␉hciController,␊
420␉␉␉␉␉␉␉␉␉␉␉␉UInt8 *␉␉␉␉␉␉incomingDataPtr,␊
421␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉inDataSize,␊
422␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉inSequenceNumber );␊
423␊
424␉// The following is only a "ghost" call and exists only to make the compiler happy, its implementation ␊
425␉// does not do anything.␊
426␉static␉IOReturn␉ProcessSCODataAction( IOBluetoothHCIController *␉hciController,␊
427␉␉␉␉␉␉␉␉␉␉␉␉UInt8 *␉␉␉␉␉␉incomingDataPtr,␊
428␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉inDataSize,␊
429␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉inMissingData,␊
430␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉inTimestampHi,␊
431␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉inTimestampLo,␊
432␉␉␉␉␉␉␉␉␉␉␉␉Boolean␉␉␉␉␉␉inCopyData );␊
433␉␉␉␉␉␉␉␉␉␉␉␉␊
434␉static␉IOReturn␉ProcessSCODataActionAT( IOBluetoothHCIController *␉hciController,␊
435␉␉␉␉␉␉␉␉␉␉␉␉UInt8 *␉␉␉␉␉␉incomingDataPtr,␊
436␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉inDataSize,␊
437␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉inMissingData,␊
438␉␉␉␉␉␉␉␉␉␉␉␉AbsoluteTime*␉␉␉␉inTimestamp,␊
439␉␉␉␉␉␉␉␉␉␉␉␉Boolean␉␉␉␉␉␉inCopyData );␊
440␊
441␉// Data processing helpers.␊
442␊
443 virtual bool␉␉GetCompleteCodeForCommand(␉BluetoothHCICommandOpCode␉inOpCode,␊
444 BluetoothHCIEventCode␉␉*outEventCode );␊
445 ␊
446␉virtual␉bool␉␉GetOpCodeAndEventCode(␉UInt8 * ␉␉␉␉␉␉inDataPtr,␊
447␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCICommandOpCode * ␉outOpCode,␊
448␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIEventCode * ␉␉eventCode,␊
449 BluetoothHCIEventStatus *␉␉outStatus,␊
450 BluetoothDeviceAddress *␉␉outDeviceAddress,␊
451 BluetoothConnectionHandle *␉␉outConnectionHandle );␊
452␉␉␉␉␉␉␉␉␉␊
453␉virtual␉IOReturn␉FindConnectionCompleteType( BluetoothHCICommandOpCode *␉␉outOpCode );␊
454␉␉␉␉␉␉␉␉␉␉␉␉␉␊
455␉virtual␉IOReturn␉HandleSpecialOpcodes( BluetoothHCICommandOpCode opCode );␊
456␊
457␉// This is a hook for other interested parties to get HCI event notifications. When a user client is created,␊
458␉// that mach_port_t will be passed on to us via these calls so that their port will get HCI events that aren't␊
459␉// specifically tied to a requst object, but occur due to requests they make.␊
460␉␊
461␉virtual␉IOReturn␉AddHCIEventNotification( task_t inOwningTask, mach_port_t inPort, void * refCon );␊
462␉␊
463␉virtual␉void␉␉BroadcastEventNotification(␉BluetoothHCIRequestID␉␉inID,␊
464␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIEventCode␉␉inEventCode,␊
465␉␉␉␉␉␉␉␉␉␉␉␉␉IOReturn␉␉␉␉␉eventStatus,␊
466␉␉␉␉␉␉␉␉␉␉␉␉␉UInt8 *␉␉␉␉␉␉inDataToSendPtr, ␊
467␉␉␉␉␉␉␉␉␉␉␉␉␉IOByteCount ␉␉␉␉inDataSize,␊
468 BluetoothHCICommandOpCode␉inOpCode );␊
469␉␉␉␉␉␉␉␉␉␉␉␉␊
470␉virtual void␉␉BroadcastConfigStateChangeNotification(␉IOBluetoothHCIControllerConfigState oldState,␊
471␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉IOBluetoothHCIControllerConfigState newState );␊
472␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
473␉virtual IOReturn␉RemoveHCIEventNotification( task_t inOwningTask );␊
474␊
475␉// This is a hook for other interested parties to get data from transports. They will register itself␊
476␉// with these to receive the raw data from the transport, bypassing HCI code.␊
477␉␊
478␉virtual␉IOReturn␉AddDataClient(␉HCIDataHandlerType␉␉ ␉␉␉inType,␊
479␉␉␉␉␉␉␉␉␉␉IOBluetoothHCIControllerDataHandler inProcPtr,␊
480␉␉␉␉␉␉␉␉␉␉void * ␉␉␉␉␉␉␉␉inContextPtr );␊
481␉␉␉␉␉␉␉␉␉␉␊
482␉virtual IOReturn␉NotifyDataClients( HCIDataHandlerType inType, UInt8 * inDataPtr, UInt32 inDataSize );␊
483␉␊
484␉virtual IOReturn␉RemoveDataClient( HCIDataHandlerType inType, IOBluetoothHCIControllerDataHandler inProcPtr );␊
485␊
486␉// Request creation, deletion and other data processing stuff.␊
487␊
488␉virtual␉IOReturn ␉HCIRequestCreate(␉BluetoothHCIRequestID * ␉␉␉outRequestID,␊
489␉␉␉␉␉␉␉␉␉␉␉bool ␉␉␉␉␉␉␉␉inDoAsyncNotify ␉= TRUE,␊
490␉␉␉␉␉␉␉␉␉␉␉UInt32 ␉␉␉␉␉␉␉␉inTimeout ␉␉␉= 5,␊
491␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIRequestCallbackInfo * ␉inCallbackInfo ␉␉= NULL,␊
492␉␉␉␉␉␉␉␉␉␉␉task_t␉␉␉␉␉␉␉␉inTaskID␉␉␉= 0,␊
493␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉␉␉␉inControlFlags␉␉= 0 );␊
494␉␉␉␉␉␉␉␉␉␉␉␊
495␉virtual␉IOReturn␉HCIRequestDelete( task_t inTask, BluetoothHCIRequestID inID );␊
496␉␊
497␉virtual␉IOReturn ␉LookupRequest( BluetoothHCIRequestID inID, IOBluetoothHCIRequest ** outRequestPtr );␊
498␊
499 virtual IOReturn␉PrepareRequestForNewCommand(␉BluetoothHCIRequestID␉␉␉inID,␊
500 const BluetoothDeviceAddress *␉inDeviceAddress,␊
501 BluetoothConnectionHandle␉␉inConnectionHandle );␊
502 ␊
503␉virtual␉IOReturn␉EnqueueRequest( IOBluetoothHCIRequest * inRequestPtr );␊
504␊
505␉virtual␉IOReturn␉FindQueuedRequest(␉BluetoothHCICommandOpCode␉opCode,␊
506 BluetoothDeviceAddress *␉inDeviceAddress,␊
507 BluetoothConnectionHandle␉inConnectionHandle,␊
508 Boolean␉␉␉␉␉␉inUseAttributes,␊
509 IOBluetoothHCIRequest **␉outRequestPtr );␊
510␊
511␉virtual␉IOReturn␉DequeueRequest( IOBluetoothHCIRequest * inRequestPtr );␊
512␊
513␉virtual␉IOReturn ␉EnqueueWaitRequest( IOBluetoothHCIRequest * inRequestPtr );␊
514␊
515␉virtual␉IOReturn␉FindQueuedWaitRequest( BluetoothHCICommandOpCode opCode, IOBluetoothHCIRequest ** outRequestPtr );␊
516␊
517␉virtual IOReturn␉DequeueWaitRequest( IOBluetoothHCIRequest * inRequestPtr );␊
518␊
519␉virtual␉IOReturn␉AbortRequest( IOBluetoothHCIRequest * inRequestPtr );␊
520␊
521␉virtual␉IOReturn␉FindNextExpiringRequest( BluetoothHCICommandOpCode opCode, IOBluetoothHCIRequest ** outRequestPtr );␊
522␉␊
523␉virtual␉IOReturn␉ProcessWaitingRequests();␊
524␉␊
525␉inline␉IOBluetoothHCIRequest*␉GetNextWaitRequest() { return( mWaitQueueHead ); }␊
526␊
527␉inline␉IOBluetoothHCIRequest*␉GetNextBusyRequest() { return( mBusyQueueHead ); }␊
528␉␉␉␊
529␉virtual␉void␉␉TakeAHexDump( const void *inData, UInt32 inDataSize );␊
530␉␉␉␊
531␉virtual␉IOReturn␉DumpStats();␊
532 ␊
533␉virtual IOBluetoothHCIControllerPowerOptions␉␉GetControllerPowerOptions();␊
534␉virtual IOBluetoothHCIControllerInternalPowerState␉GetControllerPowerState();␊
535␉virtual IOReturn␉WaitForControllerPowerState( IOBluetoothHCIControllerInternalPowerState powerState );␊
536␉␊
537␉virtual IOReturn␉RequestPowerStateChange( IOBluetoothHCIControllerInternalPowerState newPowerState );␊
538␊
539␉virtual IOReturn␉SendHCIRequestFormatted( BluetoothHCIRequestID␉␉inID, ␊
540␉␉␉␉␉␉␉␉␉␉␉␉ BluetoothHCICommandOpCode ␉inOpCode,␊
541␉␉␉␉␉␉␉␉␉␉␉␉ IOByteCount␉␉␉␉outResultsSize, ␊
542␉␉␉␉␉␉␉␉␉␉␉␉ void *␉␉␉␉␉␉outResultsPtr,␊
543␉␉␉␉␉␉␉␉␉␉␉␉ const char *␉␉␉␉inFormat, ␊
544␉␉␉␉␉␉␉␉␉␉␉␉ ... );␊
545␊
546␉static␉void␉␉RequestExpired( OSObject *owner, IOTimerEventSource *sender );␊
547␊
548␉// Misc stuff.␊
549␉␊
550␉␉␉IOReturn␉DisposeRequestsForTaskID( task_t inTaskID );␊
551␉␊
552␉␉␉IOReturn␉KillAllPendingRequests( Boolean destroy, Boolean includeIdleRequests );␊
553 void␉SendingRequest( IOBluetoothHCIRequest *requestPtr );␊
554 void␉DecrementActiveConnections( );␊
555␊
556␉virtual␉void␉ActiveConnectionsInProgress( );␊
557␉virtual␉void␉AllConnectionsGone( );␊
558␉␉␉␊
559␉virtual IOReturn␉SendRawHCICommand(␉BluetoothHCIRequestID␉inID,␊
560␉␉␉␉␉␉␉␉␉␉␉char * ␉␉ ␉␉␉buffer,␊
561␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉bufferSize );␊
562␉␊
563␉// Vendor Specific stuff.␊
564␊
565␉virtual␉IOReturn␉VendorCommand(␉BluetoothHCIRequestID␉ ␉␉␉inID, ␊
566␉␉␉␉␉␉␉␉␉␉BluetoothHCIVendorCommandSelector␉inSelector,␊
567␉␉␉␉␉␉␉␉␉␉UInt8 *␉␉␉␉␉␉␉␉inCommandData,␊
568␉␉␉␉␉␉␉␉␉␉IOByteCount␉␉␉␉␉␉␉inCommandDataSize,␊
569␉␉␉␉␉␉␉␉␉␉IOByteCount ␉␉␉␉␉␉outBufferSize,␊
570␉␉␉␉␉␉␉␉␉␉UInt8 * ␉␉␉␉␉␉␉outBuffer );␊
571␊
572␉// IOBluetoothDevice object management␊
573 ␊
574 virtual IOBluetoothDevice *␉FindDeviceWithHandle( BluetoothConnectionHandle inConnectionHandle );␊
575 ␊
576 virtual IOBluetoothDevice * FindDeviceWithAddress( const BluetoothDeviceAddress *inDeviceAddress );␊
577␊
578 virtual IOReturn␉SendACLPacket(␉IOBluetoothACLMemoryDescriptor␉␉␉␉*memDescriptor,␊
579 SendDataContext *␉␉␉␉␉␉␉␉contextPtr,␊
580 IOBluetoothDevice *␉␉␉␉␉␉inTargetDevice = NULL );␊
581 ␊
582␊
583 // API for the serial manager to open a new connection␊
584␊
585 virtual IOBluetoothDevice *OpenDeviceConnection( const BluetoothDeviceAddress *inDeviceAddress );␊
586␊
587 static IOReturn OpenDeviceConnectionAction(␉OSObject␉*owner,␊
588 void ␉␉*arg1,␊
589 void␉␉*arg2,␊
590 void␉␉*arg3,␊
591 void␉␉*arg4 );␊
592 ␊
593 virtual IOBluetoothDevice *OpenDeviceConnectionWL( const BluetoothDeviceAddress *inDeviceAddress );␊
594␊
595 // API to track the secure state of RFCOMM channels␊
596 virtual Boolean IsSecureIncomingRFCOMMChannel( BluetoothRFCOMMChannelID incomingChannelID );␊
597 virtual Boolean IsSecureIncomingRFCOMMChannel( OSNumber *channelIDNumber );␊
598 ␊
599␉// API to track allowed incoming L2CAP and RFCOMM channels given a device:␊
600␉virtual Boolean IsAllowedIncomingL2CAPChannelForDevice( BluetoothL2CAPPSM incomingPSM, IOBluetoothDevice *device );␊
601␉virtual Boolean IsAllowedIncomingRFCOMMChannelForDevice( BluetoothRFCOMMChannelID incomingChannelID, IOBluetoothDevice *device );␊
602␊
603␉// Enabled state for RFCOMM channels:␊
604␉virtual void SetEnabledIncomingRFCOMMChannel( OSNumber *channelIDNumber, bool ShouldBeEnabled);␊
605␉virtual void SetEnabledIncomingRFCOMMChannel( BluetoothRFCOMMChannelID incomingChannelID, bool ShouldBeEnabled);␊
606␊
607 virtual Boolean ShouldRunInactivityTimer(); // NOT USED: See StartIdleTimer␊
608 virtual void␉SetRunInactivityTimer( Boolean shouldRun ); // NOT USED: See StopIdleTimer␊
609␊
610␉//============================␊
611␊
612␉// From here on out, we implement each of the commands in the HCI spec. You can work around␊
613␉// hardware bugs by overriding any of these functions if necessary.␊
614␉␊
615␉␊
616␉// Link Control Commands.␊
617␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
618␉virtual IOReturn␉BluetoothHCIInquiry(␉BluetoothHCIRequestID␉ ␉␉inID, ␊
619␉␉␉␉␉␉␉␉␉␉␉␉BluetoothLAP␉␉␉␉␉inLAP, ␊
620␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIInquiryLength␉␉inInquiryLength, ␊
621␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIResponseCount␉␉inMaxResponseCount, ␊
622␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIInquiryResults *␉outResults );␊
623␊
624␉virtual IOReturn␉BluetoothHCIInquiryCancel( BluetoothHCIRequestID␉␉ inID );␊
625␊
626␉virtual IOReturn␉BluetoothHCIPeriodicInquiryMode(␉BluetoothHCIRequestID␉ ␉inID, ␊
627␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIInquiryLength␉inMaxPeriodLength, ␊
628␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIInquiryLength␉inMinPeriodLength, ␊
629␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothLAP␉␉␉␉inLAP, ␊
630␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIInquiryLength␉inInquiryLength, ␊
631␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIResponseCount␉inMaxResponses,␊
632 BluetoothHCIInquiryResults *␉outResults );␊
633␊
634␉virtual IOReturn␉BluetoothHCIExitPeriodicInquiryMode( BluetoothHCIRequestID␉inID );␊
635␊
636␉virtual IOReturn␉BluetoothHCICreateConnection(␉BluetoothHCIRequestID␉␉␉␉␉␉inID, ␊
637␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉␉␉inAddressPtr, ␊
638␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothPacketType␉␉␉␉␉␉␉inPacketType, ␊
639␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothPageScanRepetitionMode␉␉␉␉inPageScanRepetitionMode, ␊
640␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothPageScanMode␉␉␉␉␉␉inPageScanMode, ␊
641␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothClockOffset␉␉␉␉␉␉inClockOffset, ␊
642␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothAllowRoleSwitch␉␉␉␉␉inAllowRoleSwitch, ␊
643␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIEventConnectionCompleteResults *outConnectionHandle );␊
644␊
645␉virtual IOReturn␉BluetoothHCIDisconnect( BluetoothHCIRequestID␉␉␉inID, ␊
646␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉ ␉inConnectionHandle, ␊
647␉␉␉␉␉␉␉␉␉␉␉␉BluetoothReasonCode␉␉␉␉inReason,␊
648 BluetoothHCIEventDisconnectionCompleteResults *␉outResults );␊
649␊
650␉virtual IOReturn␉BluetoothHCIAddSCOConnection(␉BluetoothHCIRequestID␉␉inID, ␊
651␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inACLConnectionHandle, ␊
652␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothPacketType ␉␉inPacketType );␊
653␊
654␉virtual IOReturn␉BluetoothHCIAcceptConnectionRequest(␉BluetoothHCIRequestID␉␉␉␉inID, ␊
655␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉inAddressPtr, ␊
656␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothRole␉␉␉␉␉␉inRole );␊
657␊
658␉virtual IOReturn␉BluetoothHCIRejectConnectionRequest(␉BluetoothHCIRequestID␉␉␉inID, ␊
659␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉inAddressPtr, ␊
660␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothReasonCode␉␉␉␉inReason );␊
661␊
662␉virtual IOReturn␉BluetoothHCILinkKeyRequestReply(␉BluetoothHCIRequestID␉␉␉inID, ␊
663␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉inAddressPtr, ␊
664␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothKey *␉␉␉inKeyPtr,␊
665␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress *␉␉outAddress );␊
666␊
667␉virtual IOReturn␉BluetoothHCILinkKeyRequestNegativeReply( ␉BluetoothHCIRequestID␉␉␉inID, ␊
668␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉inAddressPtr,␊
669␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress *␉␉outAddress );␊
670␊
671␉virtual IOReturn␉BluetoothHCIPINCodeRequestReply(␉BluetoothHCIRequestID␉␉␉␉inID, ␊
672␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉inAddressPtr, ␊
673␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉IOByteCount␉␉␉␉␉␉␉inPINCodeSize, ␊
674␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothPINCode *␉␉␉inPINCode,␊
675␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress *␉␉outAddress );␊
676␊
677␉virtual IOReturn␉BluetoothHCIPINCodeRequestNegativeReply(␉BluetoothHCIRequestID␉␉␉inID, ␊
678␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉inAddressPtr,␊
679␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress *␉␉outAddress );␊
680␊
681␉virtual IOReturn␉BluetoothHCIChangeConnectionPacketType( BluetoothHCIRequestID␉␉inID, ␊
682␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inConnectionHandle, ␊
683␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothPacketType␉␉␉inPacketType );␊
684␊
685␉virtual IOReturn␉BluetoothHCIAuthenticationRequested(␉BluetoothHCIRequestID␉␉inID, ␊
686␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inConnectionHandle );␊
687␊
688␉virtual IOReturn␉BluetoothHCISetEncryptionEnable(␉BluetoothHCIRequestID␉␉inID, ␊
689␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inConnectionHandle, ␊
690␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothEncryptionEnable␉inEncryptionEnable );␊
691␊
692␉virtual IOReturn␉BluetoothHCIChangeConnectionLinkKey(␉BluetoothHCIRequestID␉␉inID, ␊
693␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inConnectionHandle );␊
694␊
695␉virtual IOReturn␉BluetoothHCIMasterLinkKey(␉BluetoothHCIRequestID␉inID, ␊
696␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothKeyFlag␉␉inKeyFlag );␊
697␊
698␉virtual IOReturn␉BluetoothHCIRemoteNameRequest(␉BluetoothHCIRequestID␉␉␉␉␉␉inID, ␊
699␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉␉␉inAddressPtr, ␊
700␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothPageScanRepetitionMode ␉␉␉inPageScanRepetitionMode, ␊
701␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothPageScanMode␉␉␉␉␉␉inPageScanMode, ␊
702␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothClockOffset␉␉␉␉␉␉inClockOffset,␊
703␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIEventRemoteNameRequestResults *␉outName );␊
704␊
705␉virtual IOReturn␉BluetoothHCIReadRemoteSupportedFeatures(␉BluetoothHCIRequestID␉␉␉inID, ␊
706␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉inConnectionHandle,␊
707␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIEventReadRemoteSupportedFeaturesResults *␉outFeatures );␊
708␊
709␉virtual IOReturn␉BluetoothHCIReadRemoteVersionInformation(␉BluetoothHCIRequestID␉␉inID, ␊
710␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inConnectionHandle, ␊
711␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIEventReadRemoteVersionInfoResults *␉outVersionInfo );␊
712␊
713␉virtual IOReturn␉BluetoothHCIReadClockOffset(␉BluetoothHCIRequestID␉␉inID, ␊
714␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inConnectionHandle,␊
715␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothClockOffset *␉␉outClockOffset );␊
716␊
717␉// Link Policy commands.␊
718␉␊
719␉virtual␉IOReturn␉BluetoothHCIHoldMode(␉BluetoothHCIRequestID␉ ␉␉inID,␊
720␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉inConnectionHandle,␊
721␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIModeInterval␉␉inHoldModeMaxInterval,␊
722␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIModeInterval␉␉inHoldModeMinInterval );␊
723␉␉␉␉␉␉␉␉␉␉␉␉␊
724␉virtual␉IOReturn␉BluetoothHCISniffMode(␉BluetoothHCIRequestID␉ ␉␉inID,␊
725␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉inConnectionHandle,␊
726␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIModeInterval␉␉inSniffModeMaxInterval,␊
727␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIModeInterval␉␉inSniffModeMinInterval,␊
728␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCISniffAttemptCount␉inSniffAttemptCount,␊
729␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCISniffTimeout␉␉inSniffModeTimeout );␊
730␉␉␉␉␉␉␉␉␉␉␉␉␊
731␉virtual␉IOReturn␉BluetoothHCIExitSniffMode(␉BluetoothHCIRequestID␉ ␉inID,␊
732␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inConnectionHandle );␊
733␊
734␉virtual␉IOReturn␉BluetoothHCIParkMode(␉BluetoothHCIRequestID␉ ␉␉␉inID,␊
735␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉␉inConnectionHandle,␊
736␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIParkModeBeaconInterval␉inMaxInterval,␊
737␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIParkModeBeaconInterval␉inMinInterval );␊
738␉␉␉␉␉␉␉␉␉␉␉␉␊
739␉virtual␉IOReturn␉BluetoothHCIExitParkMode(␉BluetoothHCIRequestID␉ ␉␉inID,␊
740␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉inConnectionHandle );␊
741␉␉␉␉␉␉␉␉␉␉␉␉␉␊
742␉virtual␉IOReturn␉BluetoothHCIQualityOfServiceSetup(␉BluetoothHCIRequestID␉ ␉␉␉␉␉inID,␊
743␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉␉␉␉inConnectionHandle,␊
744␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIQualityOfServiceSetupParams * ␉inSetupPtr );␊
745␉␉␊
746␉virtual␉IOReturn␉BluetoothHCIRoleDiscovery(␉BluetoothHCIRequestID␉␉␉inID, ␊
747␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉inConnectionHandle,␊
748␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIRoleInfo *␉␉␉outRoleInfo );␊
749␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
750␉virtual␉IOReturn␉BluetoothHCISwitchRole(␉BluetoothHCIRequestID␉␉inID, ␊
751␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress * ␉inAddressPtr,␊
752␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIRole␉␉␉inNewRole );␊
753␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
754␉virtual␉IOReturn␉BluetoothHCIReadLinkPolicySettings(␉BluetoothHCIRequestID␉␉␉␉␉inID, ␊
755␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉␉␉inConnectionHandle,␊
756␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCILinkPolicySettingsInfo *␉outSettingsInfo );␊
757␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
758␉virtual␉IOReturn␉BluetoothHCIWriteLinkPolicySettings(␉BluetoothHCIRequestID␉␉␉␉inID,␊
759␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉␉inConnectionHandle,␊
760␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCILinkPolicySettings␉␉inSettings,␊
761␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle *␉␉␉outConnectionHandle );␊
762␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
763␉// Host controller and baseband commands.␊
764␊
765␉virtual␉IOReturn␉BluetoothHCISetEventMask(␉BluetoothHCIRequestID␉inID,␊
766␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothSetEventMask *␉inMask );␊
767␉␉␉␉␉␉␉␉␉␉␉␊
768␉virtual␉IOReturn␉BluetoothHCIReset( BluetoothHCIRequestID␉inID );␊
769␊
770␉virtual␉IOReturn␉BluetoothHCISetEventFilter( BluetoothHCIRequestID␉inID );␊
771␊
772␉virtual␉IOReturn␉BluetoothHCIFlush(␉BluetoothHCIRequestID␉ ␉inID,␊
773␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inHandle );␊
774␊
775␉virtual␉IOReturn␉BluetoothHCIReadPINType(␉BluetoothHCIRequestID␉inID,␊
776␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothPINType *␉␉outType );␊
777␊
778␉virtual␉IOReturn␉BluetoothHCIWritePINType(␉BluetoothHCIRequestID␉inID,␊
779␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothPINType␉␉inType );␊
780␊
781␉virtual␉IOReturn␉BluetoothHCICreateNewUnitKey( BluetoothHCIRequestID␉inID );␊
782␊
783␉virtual␉IOReturn␉BluetoothHCIReadStoredLinkKey(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
784␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress *␉␉␉␉targetDevice,␊
785␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIReadStoredLinkKeysFlag * ␉inFlags,␊
786␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIStoredLinkKeysInfo *␉␉outKeysInfo );␊
787␊
788␉virtual␉IOReturn␉BluetoothHCIWriteStoredLinkKey( BluetoothHCIRequestID␉␉␉␉inID,␊
789␉␉␉␉␉␉␉␉␉␉␉␉␉␉IOItemCount ␉␉␉␉␉␉inNumKeysToWrite,␊
790␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress␉␉␉␉inDeviceAddresses[],␊
791␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothKey␉␉␉␉␉␉inLinkKeys[],␊
792␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCINumLinkKeysToWrite * ␉outNumKeysWritten );␊
793␊
794␉virtual␉IOReturn␉BluetoothHCIDeleteStoredLinkKey(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
795␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress␉*␉␉␉␉targetDevice,␊
796␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIDeleteStoredLinkKeyFlag *␉inFlag,␊
797␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCINumLinkKeysDeleted *␉␉outNumDeleted );␊
798␊
799␉virtual␉IOReturn␉BluetoothHCIReadLocalName(␉BluetoothHCIRequestID␉inID,␊
800␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceName␉␉name );␊
801␊
802␉virtual␉IOReturn␉BluetoothHCIChangeLocalName( BluetoothHCIRequestID␉␉inID,␊
803␉␉␉␉␉␉␉␉␉␉␉␉␉ BluetoothDeviceName␉␉newName );␊
804␊
805␉virtual␉IOReturn␉BluetoothHCIReadConnectionAcceptTimeout( ␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
806␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIConnectionAcceptTimeout *␉outTimeout );␊
807␊
808␉virtual␉IOReturn␉BluetoothHCIWriteConnectionAcceptTimeout(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
809␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIConnectionAcceptTimeout␉␉inTimeout );␊
810␊
811␉virtual␉IOReturn␉BluetoothHCIReadPageTimeout(␉BluetoothHCIRequestID␉ ␉inID,␊
812␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIPageTimeout * ␉outDataPtr );␊
813␊
814␉virtual␉IOReturn␉BluetoothHCIWritePageTimeout(␉BluetoothHCIRequestID␉ ␉inID,␊
815␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIPageTimeout ␉inTimeout );␊
816␊
817␉virtual␉IOReturn␉BluetoothHCIReadScanEnable( BluetoothHCIRequestID␉ ␉␉␉inID,␊
818␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIPageScanEnableState *␉outState );␊
819␊
820␉virtual␉IOReturn␉BluetoothHCIWriteScanEnable( ␉BluetoothHCIRequestID␉␉␉␉inID,␊
821␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIPageScanEnableState␉␉inState );␊
822␊
823␉virtual␉IOReturn␉BluetoothHCIReadPageScanActivity(␉BluetoothHCIRequestID ␉␉inID,␊
824␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIScanActivity *␉outActivityInfo );␊
825␊
826␉virtual␉IOReturn␉BluetoothHCIWritePageScanActivity(␉BluetoothHCIRequestID␉ ␉inID,␊
827␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIScanActivity *␉inActivityInfo );␊
828␊
829␉virtual␉IOReturn␉BluetoothHCIReadInquiryScanActivity(␉BluetoothHCIRequestID ␉␉inID,␊
830␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIScanActivity *␉outActivityInfo );␊
831␊
832␉virtual␉IOReturn␉BluetoothHCIWriteInquiryScanActivity(␉BluetoothHCIRequestID␉ ␉inID,␊
833␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIScanActivity *␉inActivityInfo );␊
834␊
835␉virtual␉IOReturn␉BluetoothHCIReadAuthenticationEnable(␉BluetoothHCIRequestID␉ ␉␉␉inID,␊
836␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIAuthenticationEnable *␉outAuthenticationState );␊
837␉␊
838␉virtual␉IOReturn␉BluetoothHCIWriteAuthenticationEnable(␉BluetoothHCIRequestID␉ ␉␉␉inID,␊
839␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIAuthenticationEnable␉inAuthenticationState );␊
840␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
841␉virtual␉IOReturn␉BluetoothHCIReadEncryptionMode(␉BluetoothHCIRequestID␉ ␉␉inID,␊
842␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIEncryptionMode *␉outEncryptionState );␊
843␊
844␉virtual␉IOReturn␉BluetoothHCIWriteEncryptionMode(␉BluetoothHCIRequestID␉␉ ␉inID,␊
845␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIEncryptionMode␉␉inEncryptionMode );␊
846␊
847␉virtual␉IOReturn␉BluetoothHCIReadClassOfDevice(␉BluetoothHCIRequestID␉␉inID,␊
848␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothClassOfDevice *␉outClassOfDevice );␊
849␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
850␉virtual␉IOReturn␉BluetoothHCIWriteClassOfDevice(␉BluetoothHCIRequestID␉␉inID,␊
851␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothClassOfDevice␉␉inClassOfDevice );␊
852␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
853␉virtual␉IOReturn␉BluetoothHCIReadVoiceSetting(␉BluetoothHCIRequestID␉ ␉inID,␊
854␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIVoiceSetting *␉outVoiceSetting );␊
855␊
856␉virtual␉IOReturn␉BluetoothHCIWriteVoiceSetting(␉BluetoothHCIRequestID␉␉inID,␊
857␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIVoiceSetting␉inVoiceSetting );␊
858␊
859␉virtual␉IOReturn␉BluetoothHCIReadAutomaticFlushTimeout(␉BluetoothHCIRequestID␉ ␉␉␉␉inID,␊
860␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉␉␉inConnectionHandle,␊
861␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIAutomaticFlushTimeoutInfo *␉outAutomaticFlushTimeoutInfo );␊
862␊
863␊
864␉virtual␉IOReturn␉BluetoothHCIWriteAutomaticFlushTimeout(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
865␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIAutomaticFlushTimeoutInfo *␉inAutomaticFlushTimeoutInfo,␊
866␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle *␉␉␉␉outConnectionHandle );␊
867␊
868␉virtual␉IOReturn␉BluetoothHCIReadNumBroadcastRetransmissions(␉BluetoothHCIRequestID␉ ␉␉␉␉␉inID,␊
869␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCINumBroadcastRetransmissions *␉outNumRetrans );␊
870␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
871␉virtual␉IOReturn␉BluetoothHCIWriteNumBroadcastRetransmissions(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
872␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCINumBroadcastRetransmissions␉inNumRetrans );␊
873␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
874␉virtual␉IOReturn␉BluetoothHCIReadHoldModeActivity(␉BluetoothHCIRequestID␉ ␉␉inID,␊
875␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIHoldModeActivity *␉outState );␊
876␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
877␉virtual␉IOReturn␉BluetoothHCIWriteHoldModeActivity(␉BluetoothHCIRequestID␉␉␉inID,␊
878␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIHoldModeActivity␉inState );␊
879␊
880␉virtual␉IOReturn␉BluetoothHCIReadTransmitPowerLevel(␉BluetoothHCIRequestID␉ ␉␉␉␉inID,␊
881␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉␉␉inHandle,␊
882␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCITransmitPowerLevelType␉␉inType,␊
883␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCITransmitPowerLevelInfo *␉outLevelInfo );␊
884␊
885␉virtual␉IOReturn␉BluetoothHCIReadSCOFlowControlEnable(␉BluetoothHCIRequestID␉ ␉␉inID,␊
886␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIFlowControlState *␉outState );␊
887␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
888␉virtual␉IOReturn␉BluetoothHCIWriteSCOFlowControlEnable(␉BluetoothHCIRequestID␉␉␉inID,␊
889␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIFlowControlState␉inState );␊
890␊
891␉virtual␉IOReturn␉BluetoothHCISetHostControllerToHostFlowControl(␉BluetoothHCIRequestID␉␉␉inID,␊
892␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIFlowControlState␉inState );␊
893␊
894␉virtual␉IOReturn␉BluetoothHCIHostBufferSize(␉BluetoothHCIRequestID␉ ␉inID,␊
895␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIBufferSize * ␉inSize );␊
896␊
897␉virtual␉IOReturn␉BluetoothHCIHostNumberOfCompletePackets( BluetoothHCIRequestID inID );␊
898␊
899␉virtual␉IOReturn␉BluetoothHCIReadLinkSupervisionTimeout(␉BluetoothHCIRequestID ␉␉␉␉␉inID,␊
900␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉␉␉inHandle,␊
901␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCILinkSupervisionTimeout *␉outInfo );␊
902␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
903␉virtual␉IOReturn␉BluetoothHCIWriteLinkSupervisionTimeout(␉BluetoothHCIRequestID ␉␉␉␉␉inID,␊
904␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCILinkSupervisionTimeout *␉inInfo,␊
905␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle *␉␉␉␉outHandle );␊
906␊
907␉virtual␉IOReturn␉BluetoothHCIReadNumberOfSupportedIAC(␉BluetoothHCIRequestID ␉␉inID,␊
908␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCISupportedIAC *␉outNumSupported );␊
909␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
910␉virtual␉IOReturn␉BluetoothHCIReadCurrentIACLAP(␉BluetoothHCIRequestID inID );␊
911␊
912␉virtual␉IOReturn␉BluetoothHCIWriteCurrentIACLAP(␉BluetoothHCIRequestID inID );␊
913␊
914␉virtual␉IOReturn␉BluetoothHCIReadPageScanPeriodMode(␉BluetoothHCIRequestID ␉␉␉␉inID,␊
915␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIPageScanPeriodMode *␉outMode );␊
916␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
917␉virtual␉IOReturn␉BluetoothHCIWritePageScanPeriodMode(␉BluetoothHCIRequestID ␉␉␉inID,␊
918␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIPageScanPeriodMode␉inMode );␊
919␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
920␉virtual␉IOReturn␉BluetoothHCIReadPageScanMode(␉BluetoothHCIRequestID ␉␉inID,␊
921␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIPageScanMode *␉outMode );␊
922␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
923␉virtual␉IOReturn␉BluetoothHCIWritePageScanMode(␉BluetoothHCIRequestID ␉␉inID,␊
924␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIPageScanMode␉inMode );␊
925␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
926␉// Informational commands.␊
927␉␊
928␉virtual␉IOReturn␉BluetoothHCIReadLocalVersionInformation( BluetoothHCIRequestID␉␉inID,␊
929␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉ BluetoothHCIVersionInfo *␉outVersionInfo );␊
930␊
931␉virtual␉IOReturn␉BluetoothHCIReadLocalSupportedFeatures( BluetoothHCIRequestID␉␉␉␉inID,␊
932␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCISupportedFeatures␉ *␉outFeatures );␊
933␉␊
934␉virtual␉IOReturn␉BluetoothHCIReadBufferSize( BluetoothHCIRequestID␉ ␉inID,␊
935␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIBufferSize * ␉outSize );␊
936␊
937␉virtual␉IOReturn␉BluetoothHCIReadCountryCode(␉BluetoothHCIRequestID␉ ␉inID,␊
938␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCICountryCode * ␉outCountryCode );␊
939␊
940␉virtual␉IOReturn␉BluetoothHCIReadDeviceAddress(␉BluetoothHCIRequestID␉ ␉inID, ␊
941␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress *␉outAddress );␊
942␊
943␉// Status commands.␊
944␉␊
945␉virtual␉IOReturn␉BluetoothHCIReadFailedContactCounter(␉BluetoothHCIRequestID␉ ␉␉␉inID,␊
946␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉␉inConnectionHandle,␊
947␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIFailedContactInfo *␉␉outFailedContactCount );␊
948␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
949␉virtual␉IOReturn␉BluetoothHCIResetFailedContactCounter(␉BluetoothHCIRequestID␉ ␉inID,␊
950␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inConnectionHandle );␊
951␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
952␉virtual␉IOReturn␉BluetoothHCIGetLinkQuality(␉BluetoothHCIRequestID␉ ␉␉inID,␊
953␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉inConnectionHandle,␊
954␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCILinkQualityInfo *␉outLinkQualityInfo );␊
955␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␊
956␉virtual␉IOReturn␉BluetoothHCIReadRSSI(␉BluetoothHCIRequestID␉ ␉inID,␊
957␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉inConnectionHandle,␊
958␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIRSSIInfo *␉␉outRSSIInfo );␊
959␉␊
960␉// Testing Commands.␊
961␊
962␉virtual␉IOReturn␉BluetoothHCIReadLoopbackMode(␉BluetoothHCIRequestID␉ ␉inID,␊
963␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCILoopbackMode *␉inLoopbackMode );␊
964␊
965␉virtual␉IOReturn␉BluetoothHCIWriteLoopbackMode(␉BluetoothHCIRequestID␉␉inID, ␊
966␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCILoopbackMode␉inLoopbackMode );␊
967␊
968␉virtual␉IOReturn␉BluetoothHCIEnableDeviceUnderTestMode( BluetoothHCIRequestID␉inID );␊
969␉␊
970␉virtual IOBluetoothHCIControllerFeatureFlags␉GetControllerFeatureFlags();␊
971␊
972protected:␊
973␊
974␉// Power managment functions:␊
975␊
976␉virtual bool␉␉configurePM(IOService *provider);␊
977␊
978␉virtual␉IOReturn␉setPowerState( unsigned long powerStateOrdinal, IOService* whatDevice );␊
979␉static␉IOReturn␉setPowerStateAction( OSObject *owner, void *arg1, void *arg2, void *arg3, void *arg4 );␊
980␉virtual␉IOReturn␉setPowerStateWL( unsigned long powerStateOrdinal, IOService* whatDevice );␊
981 ␊
982␉virtual void␉␉UpdatePowerStateProperty( IOBluetoothHCIControllerInternalPowerState powerState );␊
983␉␊
984␉virtual void␉␉SetControllerPowerOptions( IOBluetoothHCIControllerPowerOptions controllerPowerOptions );␊
985␉virtual IOReturn␉PerformPowerStateChange(␉IOBluetoothHCIControllerInternalPowerState oldPowerState,␊
986␉␉␉␉␉␉␉␉␉␉␉␉␉IOBluetoothHCIControllerInternalPowerState newPowerState,␊
987␉␉␉␉␉␉␉␉␉␉␉␉␉UInt32 powerStateOptions,␊
988␉␉␉␉␉␉␉␉␉␉␉␉␉UInt32 *microsecondsUntilComplete );␊
989␉virtual void␉␉CompletePowerStateChange();␊
990␉␊
991␉virtual void␉␉SetControllerFeatureFlags( IOBluetoothHCIControllerFeatureFlags featureFlags );␊
992␊
993␉virtual IOReturn␉setAggressiveness( unsigned long type, unsigned long newLevel );␊
994␊
995␉// Enablers for future Changes.␊
996␊
997 typedef struct ExpansionData ␊
998␉{␊
999␉␉void␉*mUnsedPointer1, *mUnsedPointer2;␊
1000␊
1001␉␉// Max number of HCI command allowed;␊
1002␉␉UInt8␉␉␉␉␉␉␉␉␉mNumberOfCommandsAllowedByHardware;␊
1003␉␉UInt8␉␉␉␉␉␉␉␉␉mNumConfiguredHIDDevices;␊
1004␉␉UInt8␉␉␉␉␉␉␉␉␉mControllerSleepFlags;␊
1005␉␉␊
1006␉␉// This pointer is depreacted and free for future uses.␊
1007␉␉void*␉␉␉␉␉␉␉␉␉mUnusedPointer;␊
1008␊
1009␉␉// AFH support:␊
1010␉␉// the mask for the channels to use:␊
1011␉␉UInt8␉␉␉␉␉␉␉␉␉mMaskByte[10];␊
1012␊
1013␉␉// AirPort changes notifications:␊
1014␉␉IONotifier ␉␉␉␉␉␉␉␉*windowServerNotifier;␊
1015␉␉IONotifier ␉␉␉␉␉␉␉␉*mAirPortPCI;␊
1016␉␉Boolean␉␉␉␉␉␉␉␉␉mProcessingConnectionRequest;␊
1017␉␉Boolean␉␉␉␉␉␉␉␉␉mWaitingForCompletedACLPacketsToSleep;␊
1018␊
1019 // SCO Support␊
1020␉␉UInt8␉␉␉␉␉␉␉␉␉mNumSCOConnections;␊
1021␉␉UInt8␉␉␉␉␉␉␉␉␉*mSCOPacketBuffer;␊
1022␉␉UInt16␉␉␉␉␉␉␉␉␉mNumBufferedSCOBytes;␊
1023␉␉AbsoluteTime␉␉␉␉␉␉␉mBufferedSCOPacketTimestamp;␊
1024␉␉␊
1025␉␉// Repository for the packets when logging at boot␊
1026␉␉OSArray␉␉␉␉␉␉␉␉␉*mRepositoryForBoot;␊
1027␉␉UInt16␉␉␉␉␉␉␉␉␉mMaxNumberOfBootPackets;␊
1028␉␉␊
1029␉␉IOService␉␉␉␉␉␉␉␉*mOverriddenControllerProvider;␊
1030␉␉␊
1031␉␉size_t␉␉␉␉␉␉␉␉␉mHCIRequestListSize;␊
1032␉␉uint32_t␉␉␉␉␉␉␉␉mNewRequestIndex;␊
1033␉␉␊
1034␉␉IOBluetoothInactivityTimerEventSource␉*mIdleTimer;␊
1035␉␉Boolean␉␉␉␉␉␉␉␉␉mSystemOnTheWayToSleep;␊
1036␊
1037␉␉// New Airport notifications:␊
1038␉␉IONotifier ␉␉␉␉␉␉␉␉*mIO80211Interface;␊
1039␊
1040␉␉UInt32␉␉␉␉␉␉␉␉␉mNextAvailableSCOSequenceNumber;␊
1041␉␉UInt32␉␉␉␉␉␉␉␉␉mCurrentlyExecutingSCOSequenceNumber;␊
1042␉␉␊
1043␉␉Boolean␉␉␉␉␉␉␉␉␉mNeedToCleanUpWaitForAckQueue;␊
1044␉␉Boolean␉␉␉␉␉␉␉␉␉mResettingDevice;␊
1045␉␉␊
1046␉␉HearingDeviceListType ␉␉␉␉␉*mConnectedHearingDeviceListHead;␊
1047␉␉HearingDeviceListType ␉␉␉␉␉*mConnectedHearingDeviceListTail;␊
1048␊
1049␉} ExpansionData;␊
1050␊
1051␉ExpansionData*␉␉mExpansionData;␊
1052␉␊
1053#define␉mConnectedHearingDeviceListTail␉␉␉IOBluetoothHCIController::mExpansionData->mConnectedHearingDeviceListTail␊
1054#define␉mConnectedHearingDeviceListHead␉␉␉IOBluetoothHCIController::mExpansionData->mConnectedHearingDeviceListHead␊
1055#define␉mResettingDevice␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mResettingDevice␊
1056#define␉mNeedToCleanUpWaitForAckQueue␉␉␉IOBluetoothHCIController::mExpansionData->mNeedToCleanUpWaitForAckQueue␊
1057#define mNextAvailableSCOSequenceNumber␉␉␉IOBluetoothHCIController::mExpansionData->mNextAvailableSCOSequenceNumber␊
1058#define mCurrentlyExecutingSCOSequenceNumber␉IOBluetoothHCIController::mExpansionData->mCurrentlyExecutingSCOSequenceNumber␊
1059␊
1060#define mNumberOfCommandsAllowedByHardware␉␉IOBluetoothHCIController::mExpansionData->mNumberOfCommandsAllowedByHardware␊
1061#define␉mNumConfiguredHIDDevices␉␉␉␉IOBluetoothHCIController::mExpansionData->mNumConfiguredHIDDevices␊
1062#define mControllerSleepFlags␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mControllerSleepFlags␊
1063#define mSleepWakeNotifier␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mSleepWakeNotifier␊
1064␊
1065#define mMaskByte␉␉␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mMaskByte␊
1066#define windowServerNotifier␉␉␉␉␉IOBluetoothHCIController::mExpansionData->windowServerNotifier␊
1067#define mAirPortPCI␉␉␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mAirPortPCI␊
1068#define mProcessingConnectionRequest␉␉␉IOBluetoothHCIController::mExpansionData->mProcessingConnectionRequest␊
1069#define mWaitingForCompletedACLPacketsToSleep IOBluetoothHCIController::mExpansionData->mWaitingForCompletedACLPacketsToSleep␊
1070␊
1071#define␉mNumSCOConnections␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mNumSCOConnections␊
1072#define mSCOPacketBuffer␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mSCOPacketBuffer␊
1073#define mNumBufferedSCOBytes␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mNumBufferedSCOBytes␊
1074#define mBufferedSCOPacketTimestamp␉␉␉␉IOBluetoothHCIController::mExpansionData->mBufferedSCOPacketTimestamp␊
1075#define mRepositoryForBoot␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mRepositoryForBoot␊
1076#define mMaxNumberOfBootPackets␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mMaxNumberOfBootPackets␊
1077#define mOverriddenControllerProvider␉␉␉IOBluetoothHCIController::mExpansionData->mOverriddenControllerProvider␊
1078#define mHCIRequestListSize␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mHCIRequestListSize␊
1079#define mNewRequestIndex␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mNewRequestIndex␊
1080#define mIdleTimer␉␉␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mIdleTimer␊
1081#define mSystemOnTheWayToSleep␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mSystemOnTheWayToSleep␊
1082#define mIO80211Interface␉␉␉␉␉␉IOBluetoothHCIController::mExpansionData->mIO80211Interface␊
1083␊
1084␉enum {␊
1085␉␉kIOBluetoothHCIControllerSleepFlagInquiryScanWasEnabled␉= 0x01␊
1086␉};␊
1087␊
1088␉␊
1089private:␊
1090␊
1091␉// Command Packet Queue:␊
1092␉virtual IOReturn␉EnqueueRequestForController( IOBluetoothHCIRequest *requestPtr );␉// Was OSMetaClassDeclareReservedUnused(␉IOBluetoothHCIController, 0 )␊
1093␉virtual IOReturn␉DequeueAndSendRequests();␉␉␉␉␉␉␉␉␉␉␉// Was OSMetaClassDeclareReservedUnused(␉IOBluetoothHCIController, 1 )␊
1094␉virtual IOReturn␉RemoveAllRequestsFromQueue();␉␉␉␉␉␉␉␉␉␉// Was OSMetaClassDeclareReservedUnused(␉IOBluetoothHCIController, 2 )␊
1095␊
1096␉// New Device creation upon connection:␊
1097␉IOReturn CreateDeviceFromConnectionResults( BluetoothHCIEventConnectionCompleteResults *connectionResults, bool isInitiator);␊
1098␊
1099␉// Expanded version of OpenDeviceConnection MUST BE CALLED IN THE WORKLOOP␊
1100 virtual IOBluetoothDevice *OpenDeviceConnection( const BluetoothDeviceAddress *inDeviceAddress, BluetoothHCIPageTimeout pageTimeoutValue, bool authenticationRequired);␊
1101␊
1102␉// sleepWakeHandler DEPRECATED METHOD RETURNS kIOReturnUnsupported ALL THE TIME␉!␊
1103␉static␉IOReturn sleepWakeHandler( void *target, void *refCon, UInt32 messageType, IOService *service, void *messageArgument, vm_size_t argSize );␊
1104␉␊
1105␉static␉IOReturn␉restartShutdownAction( OSObject *owner, void *arg1, void *arg2, void *arg3, void *arg4 );␊
1106␉static␉IOReturn␉systemSleepWakeAction( OSObject *owner, void *arg1, void *arg2, void *arg3, void *arg4 );␊
1107␊
1108public:␉␊
1109␉virtual␉IOReturn ␉restartShutdownWL( UInt32 messageType, void *reserved);␊
1110␉␊
1111␉// AFH support:␊
1112␉virtual␉UInt8 *rangeForChannel(UInt16 channel);␊
1113␉virtual IOReturn handleAirPortChangesChannelWL(IOService *serviceForAirport);␊
1114␊
1115␉// Version of stop in the workloop␊
1116␉virtual void stopWL( IOService * provider );␊
1117 ␊
1118private:␊
1119␉static bool staticAirPortDriverNotification(void *us, void *unused, IOService * yourDevice);␊
1120␉static IOReturn handleAirPortChangesChannelAction( OSObject *owner, void *castMeToServiceForAirport, void *arg2, void *arg3, void *arg4, void *arg5, void *arg6 );␊
1121␊
1122␉static bool windowServerDidAppear( void * target, void * refCon, IOService * newService, IONotifier * notifier );␊
1123␉static IOReturn windowServerDidAppearAction( OSObject *owner, void *arg1, void *arg2, void *arg3, void *arg4, void *arg5, void *arg6 );␊
1124␊
1125␉// Expansion slots:␊
1126␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 0 );␊
1127␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 1 );␊
1128␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 2 );␊
1129␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 3 );␊
1130␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 4 );␊
1131␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 5 );␊
1132␊
1133␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 6 );␊
1134␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 7 );␊
1135␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 8 );␊
1136␊
1137␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 9 );␊
1138␉virtual void SetNumSCOConnections( UInt8 numSCOConnections );␊
1139␉␊
1140␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 10 );␊
1141␉virtual void UpdateSCOConnections( UInt8 numSCOConnections );␊
1142␉␊
1143␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 11 );␊
1144␉virtual IOBluetoothDevice *FindDeviceWithSCOHandle( BluetoothConnectionHandle inConnectionHandle );␊
1145␉␊
1146␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 12 );␊
1147␉virtual IOReturn SendSCOData(␉IOMemoryDescriptor␉*scoDataDescriptor,␊
1148␉␉␉␉␉␉␉␉␉SendDataContext␉␉*scoDataContext );␊
1149␊
1150protected:␊
1151␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 13 );␊
1152␉virtual␉void␉SendSCOCompleted( SendDataContext *contextPtr, AbsoluteTime timestamp );␊
1153␊
1154␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 14 );␊
1155␉virtual IOReturn DispatchIncomingSCOData( UInt8 *inDataPtr, UInt32 inDataSize, UInt32 inMissingData, AbsoluteTime inTimestamp );␊
1156 ␊
1157 OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 15 );␊
1158 virtual bool willTerminateWL( IOService * provider, IOOptionBits options );␊
1159␊
1160␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 16 );␊
1161␉virtual bool shouldOverrideExistingController( IOBluetoothHCIController *controller );␊
1162␊
1163␉static void idleTimerFired( OSObject *owner, IOTimerEventSource *timerEventSource );␊
1164␉␊
1165␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 17 );␊
1166␉virtual void handleIdleTimeout();␊
1167␊
1168␉static IOReturn terminateAction(␉OSObject␉*owner, ␊
1169␉␉␉␉␉␉␉␉␉␉void␉␉*arg1, ␊
1170␉␉␉␉␉␉␉␉␉␉void␉␉*arg2, ␊
1171␉␉␉␉␉␉␉␉␉␉void␉␉*arg3, ␊
1172␉␉␉␉␉␉␉␉␉␉void␉␉*arg4 );␊
1173␉␊
1174␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 18 );␊
1175␉virtual IOReturn terminateWL( IOOptionBits options );␊
1176␊
1177␉// Support for dynamic channel width␊
1178␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 19 );␊
1179␉virtual␉UInt8 *rangeForChannel(UInt16 channel, SInt16 width);␊
1180␊
1181public:␊
1182␊
1183␉// v1.2 + v2.1 commands␊
1184␉␊
1185␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 20 );␊
1186␉virtual␉IOReturn␉BluetoothHCIReadExtendedInquiryResponse(␉BluetoothHCIRequestID␉␉␉␉␉␉␉␉inID,␊
1187␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIReadExtendedInquiryResponseResults *␉outData );␊
1188␊
1189␊
1190␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 21 );␊
1191␉virtual␉IOReturn␉BluetoothHCIWriteExtendedInquiryResponse(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
1192␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIFECRequired␉␉␉␉␉inFECRequired,␊
1193␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIExtendedInquiryResponse *␉inData );␊
1194␊
1195␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 22 );␊
1196␉virtual␉IOReturn␉BluetoothHCIReadInquiryMode(␉BluetoothHCIRequestID␉␉inID,␊
1197␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIInquiryMode␉*␉outMode );␊
1198␊
1199␊
1200␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 23 );␊
1201␉virtual␉IOReturn␉BluetoothHCIWriteInquiryMode(␉BluetoothHCIRequestID␉␉inID,␊
1202␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIInquiryMode␉␉inMode );␊
1203␊
1204␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 24 );␊
1205␉virtual␉IOReturn␉BluetoothHCIReadSimplePairingMode(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1206␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCISimplePairingMode␉*␉outMode );␊
1207␊
1208␊
1209␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 25 );␊
1210␉virtual␉IOReturn␉BluetoothHCIWriteSimplePairingMode(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1211␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCISimplePairingMode␉␉inMode );␊
1212␊
1213␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 26 );␊
1214␉virtual IOReturn␉BluetoothHCIIOCapabilityRequestReply(␉BluetoothHCIRequestID␉␉␉␉␉inID, ␊
1215␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉␉inAddress,␊
1216␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothIOCapability␉␉␉␉␉inIOCapability,␊
1217␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothOOBDataPresence␉␉␉␉inOOBDataPresence,␊
1218␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothAuthenticationRequirements␉␉inAuthenticationRequirements );␊
1219␊
1220␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 27 );␊
1221␉virtual␉IOReturn␉BluetoothHCIReadLocalOOBData(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
1222␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIReadLocalOOBDataResults *␉outData␉);␊
1223␊
1224␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 28 );␊
1225␉virtual␉IOReturn␉BluetoothHCIReadInquiryResponseTransmitPower(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1226␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCITransmitPowerLevel *␉outData␉);␊
1227␊
1228␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 29 );␊
1229␉virtual␉IOReturn␉BluetoothHCIWriteInquiryResponseTransmitPower(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1230␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCITransmitPowerLevel␉␉inData );␊
1231␊
1232␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 30 );␊
1233␉virtual␉IOReturn␉BluetoothHCIUserConfirmationRequestReply(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1234␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉inAddress );␊
1235␊
1236␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 31 );␊
1237␉virtual␉IOReturn␉BluetoothHCIUserConfirmationRequestNegativeReply(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1238␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉inAddress );␊
1239␊
1240␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 32 );␊
1241␉virtual␉IOReturn␉BluetoothHCIUserPasskeyRequestReply(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
1242␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉␉inAddress,␊
1243␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothPasskey␉␉␉␉␉␉inPasskey);␊
1244␊
1245␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 33 );␊
1246␉virtual␉IOReturn␉BluetoothHCIUserPasskeyRequestNegativeReply(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
1247␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉␉inAddress );␊
1248␊
1249␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 34 );␊
1250␉virtual␉IOReturn␉BluetoothHCIRemoteOOBDataRequestReply(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1251␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉inAddress,␊
1252␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCISimplePairingOOBData *␉hash,␊
1253␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCISimplePairingOOBData *␉randomizer );␊
1254␊
1255␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 35 );␊
1256␉virtual␉IOReturn␉BluetoothHCIRemoteOOBDataRequestNegativeReply(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1257␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉inAddress );␊
1258␊
1259␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 36 );␊
1260␉virtual␉IOReturn␉BluetoothHCIWriteSimplePairingDebugMode(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
1261␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothSimplePairingDebugMode␉␉␉inData␉);␊
1262␊
1263␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 37 );␊
1264␉virtual␉IOReturn␉BluetoothHCISendKeypressNotification(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
1265␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉␉␉inAddress,␊
1266␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothKeypressNotificationType␉␉inData␉);␊
1267␊
1268protected:␊
1269␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 38 );␊
1270␉virtual␉IOReturn␉systemSleepWakeWL( UInt32 messageType, void *reserved);␊
1271␊
1272public:␊
1273␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 39 );␊
1274␉virtual␉IOReturn␉BluetoothHCIReadLocalExtendedFeatures(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1275␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉ BluetoothHCIPageNumber␉␉␉␉inPageNumber,␊
1276␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉ BluetoothHCIExtendedFeaturesInfo *␉outFeatures );␊
1277␉␊
1278␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 40 );␊
1279␉virtual IOReturn␉BluetoothHCIReadRemoteExtendedFeatures(␉BluetoothHCIRequestID␉␉␉␉inID, ␊
1280␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉␉inConnectionHandle,␊
1281␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIPageNumber␉␉␉␉inPageNumber,␊
1282␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIEventReadRemoteExtendedFeaturesResults *␉outFeatures );␊
1283␊
1284␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 41 );␊
1285␉virtual␉IOReturn␉BluetoothHCIReadAFHChannelAssessmentMode(␉BluetoothHCIRequestID␉␉␉␉␉inID,␊
1286␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIAFHChannelAssessmentMode *␉outData );␊
1287␉␊
1288␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 42 );␊
1289␉virtual IOReturn␉BluetoothHCIWriteAFHChannelAssessmentMode(␉BluetoothHCIRequestID␉␉␉␉␉␉inID,␊
1290␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothHCIAFHChannelAssessmentMode␉␉inData );␊
1291␊
1292␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 43 );␊
1293␉virtual IOReturn␉BluetoothHCISetAFHHostChannelClassification(␉BluetoothHCIRequestID␉␉␉␉␉␉inID,␊
1294␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉uint8_t␉ *␉␉␉␉␉␉␉␉␉inDataPtr,␊
1295␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉uint8_t␉␉␉␉␉␉␉␉␉␉inDataLength );␊
1296␉␊
1297private:␊
1298␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 44 );␊
1299␉virtual IOReturn␉BluetoothHCIReadAFHChannelMap(␉BluetoothHCIRequestID␉ ␉␉inID,␊
1300␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothConnectionHandle␉␉inConnectionHandle,␊
1301␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothAFHResults *␉␉␉outData );␊
1302␊
1303␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 45 );␊
1304 virtual void␉␉SynchronizeSCOPacketSequence( UInt32 sequenceNumber );␊
1305␊
1306␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 46 );␊
1307␉virtual IOReturn␉BluetoothHCICreateConnectionCancel(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1308␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉inAddressPtr,␊
1309␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress *␉␉outAddress );␊
1310␊
1311␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 47 );␊
1312 virtual IOReturn␉BluetoothHCIRemoteNameRequestCancel(␉BluetoothHCIRequestID␉␉␉␉inID,␊
1313␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉const BluetoothDeviceAddress *␉inAddressPtr,␊
1314␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉BluetoothDeviceAddress *␉␉outAddress );␊
1315␊
1316␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 48 );␊
1317␉void␉␉␉␉StartIdleTimer( uint32_t milliseconds );␊
1318␉␊
1319␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 49 );␊
1320␉void␉␉␉␉StopIdleTimer();␊
1321␊
1322public:␊
1323␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 50 );␊
1324␉virtual␉IOReturn␉setUnackQueueCompletionCalled(void * memoryDescriptor);␊
1325␊
1326protected:␊
1327␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 51 );␊
1328␉virtual IOReturn␉RemovePacket(IOMemoryDescriptor␉*memDescriptor);␊
1329␊
1330public:␊
1331␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 52 );␊
1332␉IOReturn ␉␉␉exitHIDSniff(bool␉ exitSniff);␊
1333␉␊
1334public:␊
1335␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 53 );␊
1336␉virtual IOReturn␉WaitForControllerPowerStateWithTimeout( IOBluetoothHCIControllerInternalPowerState␉powerState,␊
1337␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉ UInt32␉␉␉␉␉␉␉␉␉␉waitTimeInMicroSecond);␊
1338public:␊
1339␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 54 );␊
1340␉void␉␉␉␉SetHCIDriverExistsVariableTo( bool isLoaded );␊
1341␉␊
1342public:␊
1343␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 55 );␊
1344␉virtual␉IOReturn␉ToggleLMPLogging( );␊
1345␉␊
1346public:␊
1347␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 56 );␊
1348␉virtual␉HearingDeviceListType * ␉FindHearingDeviceWithAddress( const BluetoothDeviceAddress *inDeviceAddress );␊
1349␉␊
1350public:␊
1351␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 57 );␊
1352␉virtual␉IOReturn␉AddHearingDevice( IOBluetoothDevice *inDevice );␊
1353␉␊
1354public:␊
1355␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 58 );␊
1356␉virtual␉IOReturn␉RemoveHearingDevice( IOBluetoothDevice *inDevice, bool all );␊
1357␉␊
1358public:␊
1359␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 59 );␊
1360␉virtual␉IOReturn␉SetDevicePublishNotificationState( const BluetoothDeviceAddress *inDeviceAddress, DevicePublishNotificationStateType state );␊
1361␉␊
1362public:␊
1363␉OSMetaClassDeclareReservedUsed(␉IOBluetoothHCIController, 60 );␊
1364␉virtual␉DevicePublishNotificationStateType *␉GetDevicePublishNotificationState( const BluetoothDeviceAddress *inDeviceAddress );␊
1365␉␊
1366private:␊
1367␉OSMetaClassDeclareReservedUnused(␉IOBluetoothHCIController, 61 );␊
1368␉OSMetaClassDeclareReservedUnused(␉IOBluetoothHCIController, 62 );␊
1369␉OSMetaClassDeclareReservedUnused(␉IOBluetoothHCIController, 63 );␊
1370};␊
1371

Archive Download this file

Revision: 1146