Chameleon

Chameleon Svn Source Tree

Root/branches/rewrite/i386/include/IOKit/firewire/IOFireWireController.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 * Copyright (c) 1998-2002 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 * Copyright (c) 1999-2002 Apple Computer, Inc. All rights reserved.␊
24 *␊
25 * HISTORY␊
26 *␊
27 */␊
28␊
29#ifndef _IOKIT_IOFIREWIRECONTROLLER_H␊
30#define _IOKIT_IOFIREWIRECONTROLLER_H␊
31␊
32#ifndef FIREWIREPRIVATE␊
33#warning Please do not include this file. Include IOFireWireBus.h instead.␊
34#endif␊
35␊
36#include <IOKit/IOEventSource.h>␊
37#include <IOKit/firewire/IOFireWireBus.h>␊
38#include <IOKit/firewire/IOFireWireFamilyCommon.h>␊
39#include <IOKit/firewire/IOFireWireIRMAllocation.h>␊
40#include <IOKit/firewire/IOFWPHYPacketListener.h>␊
41#include <IOKit/firewire/IOFireWireMultiIsochReceive.h>␊
42␊
43class OSData;␊
44class IOWorkLoop;␊
45class IOEventSource;␊
46class IOFWQEventSource;␊
47class IOTimerEventSource;␊
48class IOMemoryDescriptor;␊
49class IOFireWireController;␊
50class IOFWAddressSpace;␊
51class IOFWPseudoAddressSpace;␊
52class IOFireWireNub;␊
53class IOFireWireDevice;␊
54class IOFireWireDeviceAux;␊
55class IOFireWireUnit;␊
56class IODCLProgram;␊
57class IOLocalConfigDirectory;␊
58class IOFireWireLink;␊
59class IOFireWireSBP2ORB;␊
60class IOFireWireSBP2Login;␊
61class IOFireWireROMCache;␊
62class IOFireWireLocalNode;␊
63class IOFWWorkLoop;␊
64class IOFireWireIRM;␊
65class IOFireWirePowerManager;␊
66class IOFWSimplePhysicalAddressSpace;␊
67class IOFWSimpleContiguousPhysicalAddressSpace;␊
68class IOFWAsyncStreamReceiver;␊
69class IOFWAsyncStreamListener;␊
70class IOFWUserVectorCommand;␊
71class IOFWAsyncPHYCommand;␊
72class IOFWPHYPacketListener;␊
73class IOFWUserPHYPacketListener;␊
74␊
75#if FIRELOGCORE␊
76class IOFireLog;␊
77class IOFireLogPublisher;␊
78#endif␊
79␊
80const UInt32 kMaxWaitForValidSelfID = 20; // Still invalid SelfID after 20 retries␊
81␊
82// Phy packet defs.␊
83␊
84enum␊
85{␊
86␉kFWPhyPacketID␉␉␉␉␉= FWBitRange (0, 1),␊
87␉kFWPhyPacketIDPhase␉␉␉␉= FWBitRangePhase (0, 1),␊
88␊
89␉kFWPhyPacketPhyID␉␉␉␉= FWBitRange (2, 7),␊
90␉kFWPhyPacketPhyIDPhase␉␉␉= FWBitRangePhase (2, 7)␊
91};␊
92␊
93enum␊
94{␊
95␉kSelfIDPacketSize␉␉␉␉= 8,␊
96␉kMaxSelfIDs␉␉␉␉␉␉= 4␉// SelfID 0,1,3,8␊
97};␊
98␊
99enum␊
100{␊
101␉kFWConfigurationPacketID␉␉= 0,␊
102␉kFWLinkOnPacketID␉␉␉␉= 1,␊
103␉kFWSelfIDPacketID␉␉␉␉= 2␊
104};␊
105␊
106enum␊
107{␊
108␉kFWPhyConfigurationR␉␉␉␉␉= FW_BIT(8),␊
109␉kFWPhyConfigurationT␉␉␉␉␉= FW_BIT(9),␊
110␉kFWPhyConfigurationGapCnt␉␉␉␉= FWBitRange (10, 15),␊
111␉kFWPhyConfigurationGapCntPhase␉␉␉= FWBitRangePhase (10, 15)␊
112};␊
113␊
114enum␊
115{␊
116␉kFWSelfIDPortStatusChild␉␉␉␉= 3,␊
117␉kFWSelfIDPortStatusParent␉␉␉␉= 2,␊
118␉kFWSelfIDPortStatusNotConnected␉␉␉= 1,␊
119␉kFWSelfIDPortStatusNotPresent␉␉␉= 0,␊
120␊
121␉kFWSelfIDNoPower␉␉␉␉␉␉= 0,␊
122␉kFWSelfIDSelfPowered15W␉␉␉␉␉= 1,␊
123␉kFWSelfIDSelfPowered30W␉␉␉␉␉= 2,␊
124␉kFWSelfIDSelfPowered45W␉␉␉␉␉= 3,␊
125␉kFWSelfIDBusPowered1W␉␉␉␉␉= 4,␊
126␉kFWSelfIDBusPowered3W␉␉␉␉␉= 5,␊
127␉kFWSelfIDBusPowered6W␉␉␉␉␉= 6,␊
128␉kFWSelfIDBusPowered10W␉␉␉␉␉= 7,␊
129␊
130␉kFWSelfIDPhyID␉␉␉␉␉␉␉= kFWPhyPacketPhyID,//zzz do we need or want this?␊
131␉kFWSelfIDPhyIDPhase␉␉␉␉␉␉= kFWPhyPacketPhyIDPhase,␊
132␉kFWSelfIDM␉␉␉␉␉␉␉␉= FW_BIT(31),␊
133␊
134␉kFWSelfID0L␉␉␉␉␉␉␉␉= FW_BIT(9),␊
135␉kFWSelfID0GapCnt␉␉␉␉␉␉= FWBitRange (10, 15),␊
136␉kFWSelfID0GapCntPhase␉␉␉␉␉= FWBitRangePhase (10, 15),␊
137␉kFWSelfID0SP␉␉␉␉␉␉␉= FWBitRange (16, 17),␊
138␉kFWSelfID0SPPhase␉␉␉␉␉␉= FWBitRangePhase (16, 17),␊
139␉kFWSelfID0Del␉␉␉␉␉␉␉= FWBitRange (18, 19),␊
140␉kFWSelfID0DelPhase␉␉␉␉␉␉= FWBitRangePhase (18, 19),␊
141␉kFWSelfID0C␉␉␉␉␉␉␉␉= FW_BIT(20),␊
142␉kFWSelfID0Pwr␉␉␉␉␉␉␉= FWBitRange (21, 23),␊
143␉kFWSelfID0PwrPhase␉␉␉␉␉␉= FWBitRangePhase (21, 23),␊
144␉kFWSelfID0P0␉␉␉␉␉␉␉= FWBitRange (24, 25),␊
145␉kFWSelfID0P0Phase␉␉␉␉␉␉= FWBitRangePhase (24, 25),␊
146␉kFWSelfID0P1␉␉␉␉␉␉␉= FWBitRange (26, 27),␊
147␉kFWSelfID0P1Phase␉␉␉␉␉␉= FWBitRangePhase (26, 27),␊
148␉kFWSelfID0P2␉␉␉␉␉␉␉= FWBitRange (28, 29),␊
149␉kFWSelfID0P2Phase␉␉␉␉␉␉= FWBitRangePhase (28, 29),␊
150␉kFWSelfID0I␉␉␉␉␉␉␉␉= FW_BIT(30),␊
151␊
152␉kFWSelfIDPacketType␉␉␉␉␉␉= FW_BIT(8),␊
153␉kFWSelfIDNN␉␉␉␉␉␉␉␉= FWBitRange (9, 11),␊
154␉kFWSelfIDNNPhase␉␉␉␉␉␉= FWBitRangePhase (9, 11),␊
155␉kFWSelfIDNPa␉␉␉␉␉␉␉= FWBitRange (14, 15),␊
156␉kFWSelfIDNPaPhase␉␉␉␉␉␉= FWBitRangePhase (14, 15),␊
157␉kFWSelfIDNPb␉␉␉␉␉␉␉= FWBitRange (16, 17),␊
158␉kFWSelfIDNPbPhase␉␉␉␉␉␉= FWBitRangePhase (16, 17),␊
159␉kFWSelfIDNPc␉␉␉␉␉␉␉= FWBitRange (18, 19),␊
160␉kFWSelfIDNPcPhase␉␉␉␉␉␉= FWBitRangePhase (18, 19),␊
161␉kFWSelfIDNPd␉␉␉␉␉␉␉= FWBitRange (20, 21),␊
162␉kFWSelfIDNPdPhase␉␉␉␉␉␉= FWBitRangePhase (20, 21),␊
163␉kFWSelfIDNPe␉␉␉␉␉␉␉= FWBitRange (22, 23),␊
164␉kFWSelfIDNPePhase␉␉␉␉␉␉= FWBitRangePhase (22, 23),␊
165␉kFWSelfIDNPf␉␉␉␉␉␉␉= FWBitRange (24, 25),␊
166␉kFWSelfIDNPfPhase␉␉␉␉␉␉= FWBitRangePhase (24, 25),␊
167␉kFWSelfIDNPg␉␉␉␉␉␉␉= FWBitRange (26, 27),␊
168␉kFWSelfIDNPgPhase␉␉␉␉␉␉= FWBitRangePhase (26, 27),␊
169␉kFWSelfIDNPh␉␉␉␉␉␉␉= FWBitRange (28, 29),␊
170␉kFWSelfIDNPhPhase␉␉␉␉␉␉= FWBitRangePhase (28, 29),␊
171␉kFWSelfIDMore␉␉␉␉␉␉␉= FW_BIT(31)␊
172};␊
173␊
174// Primary packet defs.␊
175enum␊
176{␊
177␉kFWPacketTCode␉␉␉␉␉␉␉= FWBitRange (24, 27),␊
178␉kFWPacketTCodePhase␉␉␉␉␉␉= FWBitRangePhase (24, 27)␊
179};␊
180␊
181␊
182enum␊
183{␊
184␉kFWAsynchSpd␉␉␉␉␉␉␉= FWBitRange (14, 15),␊
185␉kFWAsynchSpdPhase␉␉␉␉␉␉= FWBitRangePhase (14, 15),␊
186␊
187␉kFWAsynchTLabel␉␉␉␉␉␉␉= FWBitRange (16, 21),␊
188␉kFWAsynchTLabelPhase␉␉␉␉␉= FWBitRangePhase (16, 21),␊
189␉kFWAsynchTTotal ␉␉␉␉␉␉= ((0xffffffff & kFWAsynchTLabel) >> kFWAsynchTLabelPhase)+1,␊
190␉kFWAsynchRt␉␉␉␉␉␉␉␉= FWBitRange (22, 23),␊
191␉kFWAsynchRtPhase␉␉␉␉␉␉= FWBitRangePhase (22, 23),␊
192␉kFWAsynchNew␉␉␉␉␉␉␉= 0,␊
193␉kFWAsynchRetryA␉␉␉␉␉␉␉= 2,␊
194␉kTIAsycnhRetryB␉␉␉␉␉␉␉= 3,␊
195␊
196␉kFWAsynchPriority␉␉␉␉␉␉= FWBitRange (28, 31),␊
197␉kFWAsynchPriorityPhase␉␉␉␉␉= FWBitRangePhase (28, 31),␊
198␊
199␉kFWAsynchDestinationID␉␉␉␉␉= FWBitRange (0, 15),␊
200␉kFWAsynchDestinationIDPhase␉␉␉␉= FWBitRangePhase (0, 15),␊
201␊
202␉kFWAsynchSourceID␉␉␉␉␉␉= FWBitRange (0, 15),␊
203␉kFWAsynchSourceIDPhase␉␉␉␉␉= FWBitRangePhase (0, 15),␊
204␊
205␉kFWAsynchDestinationOffsetHigh␉␉␉= FWBitRange (16, 31),␊
206␉kFWAsynchDestinationOffsetHighPhase␉␉= FWBitRangePhase (16, 31),␊
207␊
208␉kFWAsynchDestinationOffsetLow␉␉␉= FWBitRange (0, 31),␊
209␉kFWAsynchDestinationOffsetLowPhase␉␉= FWBitRangePhase (0, 31),␊
210␊
211␉kFWAsynchDataLength␉␉␉␉␉␉= FWBitRange (0, 15),␊
212␉kFWAsynchDataLengthPhase␉␉␉␉= FWBitRangePhase (0, 15),␊
213␊
214␉kFWAsynchExtendedTCode␉␉␉␉␉= FWBitRange (16, 31),␊
215␉kFWAsynchExtendedTCodePhase␉␉␉␉= FWBitRangePhase (16, 31),␊
216␊
217␉kFWAsynchAckSent␉␉␉␉␉␉= FWBitRange (28, 31),␊
218␉kFWAsynchAckSentPhase␉␉␉␉␉= FWBitRangePhase (28, 31),␊
219␊
220␉kFWAsynchRCode␉␉␉␉␉␉␉= FWBitRange (16, 19),␊
221␉kFWAsynchRCodePhase␉␉␉␉␉␉= FWBitRangePhase (16, 19)␊
222};␊
223␊
224enum␊
225{␊
226␉kFWTCodeWriteQuadlet␉␉␉␉␉= 0,␊
227␉kFWTCodeWriteBlock␉␉␉␉␉␉= 1,␊
228␉kFWTCodeWriteResponse␉␉␉␉␉= 2,␊
229␉kFWTCodeReadQuadlet␉␉␉␉␉␉= 4,␊
230␉kFWTCodeReadBlock␉␉␉␉␉␉= 5,␊
231␉kFWTCodeReadQuadletResponse␉␉␉␉= 6,␊
232␉kFWTCodeReadBlockResponse␉␉␉␉= 7,␊
233␉kFWTCodeCycleStart␉␉␉␉␉␉= 8,␊
234␉kFWTCodeLock␉␉␉␉␉␉␉= 9,␊
235␉kFWTCodeIsochronousBlock␉␉␉␉= 10,␊
236␉kFWTCodeLockResponse␉␉␉␉␉= 11,␊
237␉kFWTCodePHYPacket␉␉␉␉␉␉= 14␊
238};␊
239␊
240enum␊
241{␊
242␉kFWExtendedTCodeMaskSwap␉␉␉␉= 1,␊
243␉kFWExtendedTCodeCompareSwap␉␉␉␉= 2,␊
244␉kFWExtendedTCodeFetchAdd␉␉␉␉= 3,␊
245␉kFWExtendedTCodeLittleAdd␉␉␉␉= 4,␊
246␉kFWExtendedTCodeBoundedAdd␉␉␉␉= 5,␊
247␉kFWExtendedTCodeWrapAdd␉␉␉␉␉= 6,␊
248␉kFWExtendedTCodeVendorDependent␉␉␉= 7␊
249};␊
250␊
251// debug boot-arg constants␊
252enum␊
253{␊
254␉kFWDebugIgnoreNodeNone␉␉␉␉␉= 0xFFFFFFFF␊
255};␊
256␊
257struct AsyncPendingTrans {␊
258 IOFWAsyncCommand *␉fHandler;␊
259 IOFWCommand *␉␉fAltHandler;␊
260 int␉␉␉fTCode;␊
261 bool␉␉fInUse;␊
262};␊
263␊
264struct IOFWNodeScan {␊
265 IOFireWireController ␉*␉fControl;␊
266 FWAddress␉␉␉␉␉fAddr;␊
267 UInt32␉␉␉␉␉␉fBuf[5];␉// Enough for bus info block␊
268 UInt32 ␉␉␉␉␉*␉fSelfIDs;␊
269 int␉␉␉␉␉␉␉fNumSelfIDs;␊
270 int␉␉␉␉␉␉␉fROMSize;␊
271 int␉␉␉␉␉␉␉fRead;␊
272 IOFWReadQuadCommand ␉* ␉fCmd;␊
273␉IOFWCompareAndSwapCommand * fLockCmd;␊
274␉UInt32␉␉␉␉␉␉generation;␊
275 UInt32␉␉␉␉␉␉fIRMBitBucketOld;␊
276 UInt32␉␉␉␉␉␉fIRMBitBucketNew;␊
277 bool␉␉␉␉␉␉fIRMisBad;␊
278 bool␉␉␉␉␉␉speedChecking;␊
279 bool␉␉␉␉␉␉fContenderNeedsChecking;␊
280 bool␉␉␉␉␉␉fIRMCheckingRead;␊
281 bool␉␉␉␉␉␉fIRMCheckingLock;␊
282␉int␉␉␉␉␉␉␉fRetriesBumped;␊
283␉bool␉␉␉␉␉␉fMustNotBeRoot;␊
284};␊
285␊
286␊
287typedef struct IOFWDuplicateGUIDStruct IOFWDuplicateGUIDRec;␊
288struct IOFWDuplicateGUIDStruct␊
289 {␊
290␉IOFWDuplicateGUIDRec␉␉* ␉fNextGUID;␊
291␉CSRNodeUniqueID␉␉␉␉fGUID;␊
292␉UInt32␉␉␉␉␉␉fLastGenSeen;␊
293};␊
294␉␊
295␊
296// IOFireWireDuplicateGUIDList␊
297//␊
298// A little class for keeping track of GUIDs which where we have observed 2 nodes with␊
299// the same GUID␊
300␊
301class IOFireWireDuplicateGUIDList : public OSObject␊
302{␊
303 OSDeclareDefaultStructors(IOFireWireDuplicateGUIDList);␊
304␊
305private:␊
306 IOFWDuplicateGUIDRec␉␉* ␉fFirstGUID;␊
307 ␊
308protected:␊
309 virtual void free();␊
310 ␊
311public:␊
312␊
313␉static IOFireWireDuplicateGUIDList * create( void );␊
314␊
315␉void addDuplicateGUID( CSRNodeUniqueID guid, UInt32 gen );␊
316␉void removeDuplicateGUID( CSRNodeUniqueID guid );␊
317␉␊
318␉bool findDuplicateGUID( CSRNodeUniqueID guid, UInt32 gen );␊
319␉␊
320};␊
321␊
322#define kMaxPendingTransfers kFWAsynchTTotal␊
323␊
324class IOFireWireController;␊
325␊
326#pragma mark -␊
327␊
328/*! ␊
329␉@class IOFireWireControllerAux␊
330*/␊
331␊
332class IOFireWireControllerAux : public IOFireWireBusAux␊
333{␊
334 OSDeclareDefaultStructors(IOFireWireControllerAux)␊
335␊
336␉friend class IOFireWireController;␊
337␉␊
338protected:␊
339␉␊
340␉IOFireWireController * ␉␉fPrimary;␊
341␉␊
342␉UInt8␉␉␉␉␉␉fMaxRec;␊
343␉␊
344␉UInt8␉␉␉␉␉␉fPadding;␊
345␉UInt16␉␉␉␉␉␉fPadding2;␊
346␉␊
347␉IOFWUserObjectExporter *␉fSessionRefExporter;␊
348␉␊
349␉/*! ␊
350␉␉@struct ExpansionData␊
351␉␉@discussion This structure will be used to expand the capablilties of the class in the future.␊
352 */ ␊
353␉ ␊
354 struct ExpansionData { };␊
355␊
356␉/*! ␊
357␉␉@var reserved␊
358␉␉Reserved for future use. (Internal use only) ␊
359␉*/␊
360 ␊
361␉ExpansionData * reserved;␊
362␊
363 virtual bool ␉␉␉␉␉␉␉␉␉init ( ␊
364␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉IOFireWireController * ␉primary );␊
365␉virtual␉void ␉␉␉␉␉␉␉␉␉free ();␊
366␉virtual IOFWDCLPool *␉␉␉␉␉␉␉createDCLPool ( unsigned capacity ) const ;␉␊
367␉virtual UInt8␉␉␉␉␉␉␉␉␉getMaxRec( void );␊
368␉␊
369␉virtual UInt64 getFireWirePhysicalAddressMask( void );␊
370␉virtual UInt32 getFireWirePhysicalAddressBits( void );␊
371␉virtual UInt64 getFireWirePhysicalBufferMask( void );␊
372␉virtual UInt32 getFireWirePhysicalBufferBits( void );␊
373␉␊
374␉virtual IOFWSimpleContiguousPhysicalAddressSpace * createSimpleContiguousPhysicalAddressSpace( vm_size_t size, IODirection direction );␊
375␉virtual IOFWSimplePhysicalAddressSpace * createSimplePhysicalAddressSpace( vm_size_t size, IODirection direction );␊
376␉␊
377␉virtual IOFWUserObjectExporter * getSessionRefExporter( void );␊
378␉␊
379private:␊
380 OSMetaClassDeclareReservedUnused(IOFireWireControllerAux, 0);␊
381 OSMetaClassDeclareReservedUnused(IOFireWireControllerAux, 1);␊
382 OSMetaClassDeclareReservedUnused(IOFireWireControllerAux, 2);␊
383 OSMetaClassDeclareReservedUnused(IOFireWireControllerAux, 3);␊
384 OSMetaClassDeclareReservedUnused(IOFireWireControllerAux, 4);␊
385 OSMetaClassDeclareReservedUnused(IOFireWireControllerAux, 5);␊
386 OSMetaClassDeclareReservedUnused(IOFireWireControllerAux, 6);␊
387 OSMetaClassDeclareReservedUnused(IOFireWireControllerAux, 7);␊
388␊
389};␊
390␊
391␊
392#pragma mark -␊
393␊
394/*! @class IOFireWireController␊
395*/␊
396class IOFireWireController : public IOFireWireBus␊
397{␊
398 OSDeclareAbstractStructors(IOFireWireController)␊
399␊
400protected:␊
401 enum busState {␊
402 kStarting = 0,␉␉␊
403␉␉kAsleep,␉␉␉// Link off, zzzzzz␊
404␉␉kWaitingBusReset,␊
405 kWaitingSelfIDs,␉// Bus has been reset, no selfIDs yet␊
406 kWaitingScan,␉␉// Got selfIDs, waiting a bit before hitting lame devices␊
407 kScanning,␉␉␉// Reading node ROMs␊
408 kWaitingPrune,␉␉// Read all ROMs, pausing before pruning missing devices␊
409 kRunning,␉␉␉// Normal happy state,␊
410␉␉kWaitingBusResetStart␉// bus reset is desired, but not yet sent to the fwim␊
411 };␊
412 ␊
413␉enum ResetState␊
414␉{␊
415␉␉kResetStateResetting,␊
416␉␉kResetStateDisabled,␊
417␉␉kResetStateArbitrated␊
418␉};␊
419␊
420␉enum␊
421␉{␊
422␉␉kDisablePhysicalAccess ␉= (1 << 0)␊
423␉};␊
424␉␉␊
425 struct timeoutQ: public IOFWCmdQ␊
426 {␊
427 IOTimerEventSource *fTimer;␊
428 virtual void headChanged(IOFWCommand *oldHead);␊
429 void busReset();␊
430 };␊
431␉␊
432 struct pendingQ: public IOFWCmdQ␊
433 {␊
434 IOFWQEventSource *fSource;␊
435 virtual void headChanged(IOFWCommand *oldHead);␊
436 };␊
437␊
438 friend class IOFireWireLink;␊
439␉friend class IOFireWireDevice;␊
440␉friend class IOFireWireDeviceAux;␊
441␉friend class IOFWAddressSpace;␊
442␉friend class IOFWAddressSpaceAux;␊
443 friend class IOFWPseudoAddressSpace;␊
444 friend class IOFireWireSBP2ORB;␊
445␉friend class IOFireWireSBP2Login;␊
446␉friend class IOFWLocalIsochPort;␊
447␉friend class IOFWCommand;␊
448 friend class IOFireWireUnit;␊
449␉friend class IOFireWirePCRSpace;␊
450 friend class IOFireWireROMCache;␊
451 friend class IOFWAsyncStreamCommand;␊
452␉friend class IOFireWireAVCLocalUnit;␊
453␉friend class IOFireWireAVCUnit;␊
454 friend class IOFireWireAVCCommand;␊
455␉friend class IOFireWirePowerManager;␊
456␉friend class IOFWWriteQuadCommand;␊
457␉friend class IOFWWriteCommand;␊
458␉friend class IOFWCompareAndSwapCommand;␊
459␉friend class IOFWAsyncCommand;␊
460␉friend class IOFireWireAVCTargetSpace;␊
461␉friend class AppleFWOHCI;␊
462␉friend class IOFireWireNub;␊
463␉friend class IOFWAsyncStreamListener;␊
464␉friend class IOFireWireLocalNode;␊
465␉friend class IOFireWireIRMAllocation;␊
466␉friend class IOFWUserVectorCommand;␊
467␉friend class IOFWAsyncPHYCommand;␊
468␉friend class IOFWUserPHYPacketListener;␊
469␉friend class IOFWAsyncStreamReceiver;␉␊
470␉␊
471#if FIRELOGCORE␊
472␉friend class IOFireLog;␊
473#endif␊
474␊
475 IOFireWireLink *␉␉␉fFWIM;␊
476 IOFWWorkLoop *␉␉␉␉fWorkLoop;␊
477 IOTimerEventSource *␉␉fTimer;␊
478 OSSet *␉␉␉␉␉␉fLocalAddresses;␉// Collection of local adress spaces␊
479 OSIterator *␉␉␉␉fSpaceIterator;␉␉// Iterator over local addr spaces␊
480␊
481 OSSet *␉␉␉␉␉␉fAllocatedChannels;␉// Need to be informed of bus resets␊
482 OSIterator *␉␉␉␉fAllocChannelIterator;␉// Iterator over channels␊
483␊
484␉OSSet *␉␉␉␉␉␉fIRMAllocations;␉// Need to be informed of bus resets␊
485 OSIterator *␉␉␉␉fIRMAllocationsIterator;␉// Iterator over channels␊
486␉OSSet *␉␉␉␉␉␉fIRMAllocationsAllocated;␉// Need to be informed of bus resets␊
487␊
488 // Bus management variables (although we aren't a FireWire Bus Manager...)␊
489 AbsoluteTime␉␉␉␉fResetTime;␉␉// Time of last reset␊
490 UInt32␉␉␉␉␉␉fBusGeneration;␉␉// ID of current bus topology.␊
491 UInt16␉␉␉␉␉␉fLocalNodeID;␉␉// ID of local node, ie. this computer␊
492 UInt16␉␉␉␉␉␉fRootNodeID;␉␉// ID of root, ie. highest node id in use.␊
493 UInt16␉␉␉␉␉␉fIRMNodeID;␉␉// ID of Isochronous resource manager, or kFWBadNodeID␊
494 bool␉␉␉␉␉␉fBusMgr;␉␉// true if at least one node is bus manager capable␊
495 IORegistryEntry *␉␉␉fNodes[kFWMaxNodesPerBus];␉// FireWire nodes on this bus␊
496 UInt32 *␉␉␉␉␉fNodeIDs[kFWMaxNodesPerBus+1];␉// Pointer to SelfID list for each node␊
497␉␉␉␉␉␉␉// +1 so we know how many selfIDs the last node has␊
498␉␉␉␉␉␉␉␊
499 UInt32␉␉␉␉␉␉fGapCount;␉␉// What we think the gap count should be␊
500 //UInt8␉␉␉␉␉␉fSpeedCodes[(kFWMaxNodesPerBus+1)*kFWMaxNodesPerBus];␊
501 UInt8␉␉␉␉␉␉fSpeedVector[((kFWMaxNodesPerBus+1)*kFWMaxNodesPerBus)/2];␊
502␉␉␉␉␉␉// Max speed between two nodes␊
503 busState␉␉␉␉␉fBusState;␉␉// Which state are we in?␊
504 int␉␉␉␉␉␉␉fNumROMReads;␉␉// Number of device ROMs we are still reading␊
505 // SelfIDs␊
506 int␉␉␉␉␉␉␉fNumSelfIDs;␉␉// Total number of SelfID packets␊
507 UInt32␉␉␉␉␉␉fSelfIDs[kMaxSelfIDs*kFWMaxNodesPerBus];␊
508␊
509 // The local device's Config ROM␊
510 UInt32␉␉␉␉␉␉fROMHeader[5];␉␉// More or less fixed header and bus info block␊
511 IOLocalConfigDirectory *␉fRootDir;␉␉// Local Config ROM root directory.␊
512␊
513 // log base 2 of maximum packet size the FWIM can send/receive␊
514 // Normally calculated from bus info block.␊
515 int␉fMaxSendLog;␊
516 int fMaxRecvLog;␊
517 ␊
518 IOFWAddressSpace *␉␉␉fROMAddrSpace;␊
519 IOMemoryDescriptor *␉␉fBadReadResponse;␉// Send back easily identified bad data to out of range addrs. ␊
520␊
521 // Array for outstanding requests (up to 64)␊
522 AsyncPendingTrans␉␉␉fTrans[kMaxPendingTransfers];␊
523 int␉␉␉␉␉␉␉fLastTrans;␊
524␊
525 // queue for executing commands that may timeout␊
526 timeoutQ␉␉␉␉␉fTimeoutQ;␊
527␊
528 // queue for commands that can't execute yet␊
529 pendingQ␉␉␉␉␉fPendingQ;␊
530␊
531 // queue for async commands interrupted by bus reset␊
532 IOFWCmdQ␉␉␉␉␉fAfterResetHandledQ;␊
533 ␊
534 // Command to change bus state after a delay.␊
535 IOFWDelayCommand *␉␉␉fDelayedStateChangeCmd;␊
536 bool␉␉␉␉␉␉fDelayedStateChangeCmdNeedAbort;␊
537 ␊
538␉UInt32␉␉␉␉␉␉fDelayedPhyPacket;␊
539␉bool␉␉␉␉␉␉fBusResetScheduled;␊
540␉ResetState␉␉␉␉␉fBusResetState;␊
541␉IOFWDelayCommand *␉␉␉fBusResetStateChangeCmd;␊
542␉UInt32␉␉␉␉␉␉fBusResetDisabledCount;␊
543␊
544#if FIRELOGCORE␊
545 IOFireLogPublisher *␉␉fFireLogPublisher;␊
546#else␊
547 void *␉␉␉␉␉␉fFireLogPublisher;␊
548#endif␊
549␊
550 OSData *␉␉␉␉␉fAllocatedAddresses;␊
551␊
552␉UInt32␉␉␉␉␉␉fDevicePruneDelay;␊
553␉␊
554␉IOFWPhysicalAccessMode␉␉fPhysicalAccessMode;␊
555␉IOFWSecurityMode␉␉␉fSecurityMode;␊
556␉IONotifier *␉␉␉␉fKeyswitchNotifier;␊
557␉␊
558␉IOFireWireIRM *␉␉␉␉fIRM;␊
559␉IOFireWirePowerManager *␉fBusPowerManager;␊
560␉␊
561␉bool␉␉␉␉␉␉fGapCountMismatch;␊
562␊
563␉bool␉␉␉␉␉␉fUseHalfSizePackets;␊
564␉bool␉␉␉␉␉␉fRequestedHalfSizePackets;␊
565␊
566␉IOFWNodeScan *␉␉␉␉␉fScans[kFWMaxNodesPerBus];␊
567␉IOFireWireDuplicateGUIDList␉*␉fGUIDDups;␊
568␉␊
569␉bool␉␉␉␉␉␉fDelegateCycleMaster;␊
570␉bool␉␉␉␉␉␉fBadIRMsKnown;␊
571␉␊
572␉UInt32␉␉␉␉␉␉fPreviousGap;␊
573␉␊
574␉UInt32␉␉␉␉␉␉fOutOfTLabels;␊
575␉UInt32␉␉␉␉␉␉fOutOfTLabels10S;␊
576␉UInt32␉␉␉␉␉␉fOutOfTLabelsThreshold;␊
577␊
578#ifdef LEGACY_SHUTDOWN␊
579␉IONotifier *␉␉␉␉fPowerEventNotifier;␊
580#endif␊
581␊
582␉bool␉␉␉␉␉␉fStarted;␊
583␊
584␉UInt32␉␉␉␉␉␉fIOCriticalSectionCount;␊
585␉UInt32␉␉␉␉␉␉fHubPort;␊
586␉UInt32␉␉␉␉␉␉fDebugIgnoreNode;␊
587␊
588␉OSSet *␉␉␉␉␉␉fLocalAsyncStreamReceivers; ␊
589 OSIterator *␉␉␉␉fAsyncStreamReceiverIterator;␊
590␊
591␉bool␉␉␉␉␉␉fInstantiated;␊
592␊
593␉IOReturn␉␉␉␉␉fStartStatus;␊
594␉UInt32␉␉␉␉␉␉fWaitingForSelfID;␊
595␊
596␉UInt32␉␉␉␉␉␉fForcedRootNodeID;␊
597␉bool␉␉␉␉␉␉fNodeMustBeRootFlag;␊
598␉bool␉␉␉␉␉␉fNodeMustNotBeRootFlag;␊
599␉␊
600␉UInt32␉␉␉␉␉␉fForcedGapCount;␊
601␉bool␉␉␉␉␉␉fForcedGapFlag;␊
602␊
603␉OSSet *␉␉␉␉␉␉fPHYPacketListeners;␊
604 ␉OSIterator *␉␉␉␉fPHYPacketListenersIterator;␊
605␊
606␉bool␉␉␉␉␉␉fDSLimited;␊
607␉␊
608/*! @struct ExpansionData␊
609 @discussion This structure will be used to expand the capablilties of the class in the future.␊
610 */ ␊
611 struct ExpansionData { };␊
612␊
613/*! @var reserved␊
614 Reserved for future use. (Internal use only) */␊
615 ExpansionData *reserved;␊
616␉␊
617 static void clockTick(OSObject *, IOTimerEventSource *);␊
618 static void readROMGlue(void *refcon, IOReturn status,␊
619␉␉␉IOFireWireNub *device, IOFWCommand *fwCmd);␊
620 static void delayedStateChange(void *refcon, IOReturn status,␊
621 IOFireWireBus *bus, IOFWBusCommand *fwCmd);␊
622␊
623 virtual void processBusReset();␊
624 virtual void processSelfIDs(UInt32 *IDs, int numIDs, UInt32 *ownIDs, int numOwnIDs);␊
625 virtual void processTimeout(IOTimerEventSource *src);␊
626 virtual void processRcvPacket( UInt32 *data, int numQuads, IOFWSpeed speed );␊
627 virtual void processWriteRequest(UInt16 sourceID, UInt32 tlabel,␊
628␉␉␉␉UInt32 *hdr, void *buf, int len, IOFWSpeed speed);␊
629 virtual void processLockRequest(UInt16 sourceID, UInt32 tlabel,␊
630␉␉␉␉UInt32 *hdr, void *buf, int len, IOFWSpeed speed);␊
631␊
632 // Process read from a local address, return rcode␊
633 virtual UInt32 doReadSpace(UInt16 nodeID, IOFWSpeed &speed, FWAddress addr, UInt32 len,␊
634 IOMemoryDescriptor **buf, IOByteCount * offset, IODMACommand **dma_command,␊
635 IOFWRequestRefCon refcon);␊
636␊
637 // Process write to a local address, return rcode␊
638 virtual UInt32 doWriteSpace(UInt16 nodeID, IOFWSpeed &speed, FWAddress addr, UInt32 len,␊
639 const void *buf, IOFWRequestRefCon refcon);␊
640␊
641 // Process lock to a local address, return rcode␊
642 UInt32 doLockSpace(UInt16 nodeID, IOFWSpeed &speed, FWAddress addr, UInt32 inlen,␊
643 const UInt32 *newVal, UInt32 &outLen, UInt32 *oldVal,␊
644 UInt32 extType, IOFWRequestRefCon refcon);␊
645 ␊
646 virtual void updatePlane();␊
647 virtual void startBusScan();␊
648␊
649 // Called when all devices on bus have been examined␊
650 virtual void finishedBusScan();␊
651 ␊
652 virtual void buildTopology(bool doFWPlane);␊
653␊
654 virtual void readDeviceROM(IOFWNodeScan *refCon, IOReturn status);␊
655 ␊
656 virtual IOReturn UpdateROM();␊
657 virtual IOReturn allocAddress(IOFWAddressSpace *space);␊
658 virtual void freeAddress(IOFWAddressSpace *space);␊
659␊
660␉IOFireWireBusAux * createAuxiliary( void );␊
661␉␊
662public:␊
663␊
664 // Initialization␊
665 virtual bool init(IOFireWireLink *fwim);␊
666 virtual void free();␊
667 virtual bool start(IOService *provider);␊
668 virtual void stop( IOService * provider );␊
669 virtual bool finalize( IOOptionBits options );␊
670 virtual bool requestTerminate( IOService * provider, IOOptionBits options );␊
671␊
672␉// Power management␊
673 virtual IOReturn setPowerState ( unsigned long powerStateOrdinal, IOService* whatDevice );␊
674␊
675 // Implement IOService::getWorkLoop␊
676 virtual IOWorkLoop *getWorkLoop() const;␊
677␊
678 // Allocate struct for tracking a transaction␊
679 virtual AsyncPendingTrans *allocTrans(IOFWAsyncCommand *cmd=NULL);␊
680 virtual void freeTrans(AsyncPendingTrans *trans);␊
681␊
682 // Really public methods␊
683␊
684 virtual IOReturn getCycleTime(UInt32 &cycleTime);␊
685 virtual IOReturn getBusCycleTime(UInt32 &busTime, UInt32 &cycleTime);␊
686 ␊
687 // Methods to manipulate the local Config ROM␊
688 virtual IOReturn AddUnitDirectory(IOLocalConfigDirectory *unitDir);␊
689 virtual IOReturn RemoveUnitDirectory(IOLocalConfigDirectory *unitDir);␊
690␊
691 // Cause a bus reset␊
692 virtual IOReturn resetBus();␊
693␊
694 // Send async request packets␊
695 virtual IOReturn asyncRead(␉UInt32 ␉␉␉␉generation, ␊
696␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉nodeID, ␊
697␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉addrHi, ␊
698␉␉␉␉␉␉␉␉UInt32 ␉␉␉␉addrLo,␊
699 int ␉␉␉␉speed, ␊
700␉␉␉␉␉␉␉␉int ␉␉␉␉label, ␊
701␉␉␉␉␉␉␉␉int ␉␉␉␉size, ␊
702␉␉␉␉␉␉␉␉IOFWAsyncCommand *␉cmd );␊
703␊
704 virtual IOReturn asyncWrite(␉UInt32 ␉␉␉␉␉generation, ␊
705␉␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉␉nodeID, ␊
706␉␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉␉addrHi, ␊
707␉␉␉␉␉␉␉␉␉UInt32 ␉␉␉␉␉addrLo,␊
708␉␉␉␉␉␉␉␉␉int ␉␉␉␉␉speed, ␊
709␉␉␉␉␉␉␉␉␉int ␉␉␉␉␉label, ␊
710␉␉␉␉␉␉␉␉␉IOMemoryDescriptor *␉buf, ␊
711␉␉␉␉␉␉␉␉␉IOByteCount ␉␉␉offset,␊
712␉␉␉␉␉␉␉␉␉int ␉␉␉␉␉size, ␊
713␉␉␉␉␉␉␉␉␉IOFWAsyncCommand *␉␉cmd );␊
714␉␉␉␉␊
715 /* DEPRECATED */ virtual IOReturn asyncWrite(␉UInt32 ␉␉␉␉generation, ␊
716␉/* DEPRECATED */␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉nodeID, ␊
717␉/* DEPRECATED */␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉addrHi, ␊
718␉/* DEPRECATED */␉␉␉␉␉␉␉␉UInt32 ␉␉␉␉addrLo,␊
719␉/* DEPRECATED */␉␉␉␉␉␉␉␉int ␉␉␉␉speed, ␊
720␉/* DEPRECATED */␉␉␉␉␉␉␉␉int ␉␉␉␉label, ␊
721␉/* DEPRECATED */␉␉␉␉␉␉␉␉void *␉␉␉␉data, ␊
722␉/* DEPRECATED */␉␉␉␉␉␉␉␉int ␉␉␉␉size, ␊
723␉/* DEPRECATED */␉␉␉␉␉␉␉␉IOFWAsyncCommand *␉cmd );␊
724␊
725 /* DEPRECATED */ virtual IOReturn asyncLock(␉UInt32 ␉␉␉␉generation, ␊
726␉/* DEPRECATED */␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉nodeID, ␊
727␉/* DEPRECATED */␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉addrHi, ␊
728␉/* DEPRECATED */␉␉␉␉␉␉␉␉UInt32 ␉␉␉␉addrLo,␊
729␉/* DEPRECATED */␉␉␉␉␉␉␉␉int ␉␉␉␉speed, ␊
730␉/* DEPRECATED */␉␉␉␉␉␉␉␉int ␉␉␉␉label, ␊
731␉/* DEPRECATED */␉␉␉␉␉␉␉␉int ␉␉␉␉type, ␊
732␉/* DEPRECATED */␉␉␉␉␉␉␉␉void *␉␉␉␉data, ␊
733␉/* DEPRECATED */␉␉␉␉␉␉␉␉int ␉␉␉␉size, ␊
734␉/* DEPRECATED */␉␉␉␉␉␉␉␉IOFWAsyncCommand *␉cmd);␊
735␊
736␊
737 // Send async read response packets␊
738 // useful for pseudo address spaces that require servicing outside the FireWire work loop.␊
739 virtual IOReturn asyncReadResponse(␉UInt32 ␉␉␉␉␉generation, ␊
740␉␉␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉␉nodeID, ␊
741␉␉␉␉␉␉␉␉␉␉int ␉␉␉␉␉speed,␊
742␉␉␉␉␉␉␉␉␉␉IOMemoryDescriptor *␉buf, ␊
743␉␉␉␉␉␉␉␉␉␉IOByteCount ␉␉␉offset, ␊
744␉␉␉␉␉␉␉␉␉␉int ␉␉␉␉␉len,␊
745␉␉␉␉␉␉␉␉␉␉IOFWRequestRefCon ␉␉refcon );␊
746␊
747 virtual IOReturn asyncLockResponse( UInt32 ␉␉␉␉␉generation, ␊
748␉␉␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉␉nodeID, ␊
749␉␉␉␉␉␉␉␉␉␉int ␉␉␉␉␉speed,␊
750 IOMemoryDescriptor *␉buf, ␊
751␉␉␉␉␉␉␉␉␉␉IOByteCount ␉␉␉offset, ␊
752␉␉␉␉␉␉␉␉␉␉int ␉␉␉␉␉len,␊
753 IOFWRequestRefCon ␉␉refcon );␊
754 ␊
755 // Try to fix whatever might have caused the other device to not respond␊
756 virtual IOReturn handleAsyncTimeout(IOFWAsyncCommand *cmd);␊
757␊
758 // Convert a firewire nodeID into the IOFireWireDevice for it␊
759 virtual IOFireWireDevice * nodeIDtoDevice(UInt32 generation, UInt16 nodeID);␊
760␊
761 // Add/remove a channel from the list informed of bus resets␊
762 virtual void addAllocatedChannel(IOFWIsochChannel *channel);␊
763 virtual void removeAllocatedChannel(IOFWIsochChannel *channel);␊
764␊
765␉// Add/remove a IRM allocation from the list informed of bus resets␊
766 virtual void addIRMAllocation(IOFireWireIRMAllocation *irmAllocation);␊
767 virtual void removeIRMAllocation(IOFireWireIRMAllocation *irmAllocation);␊
768␉␊
769 // Create an Isochronous Channel object␊
770 // doIRM = true => allocate channel and bandwith in Isochronous Resource Manager␊
771 // packetSize packet size (in bytes), used to calculate bandwidth needed.␊
772 virtual IOFWIsochChannel *createIsochChannel(␊
773␉bool doIRM, UInt32 packetSize, IOFWSpeed prefSpeed,␊
774␉FWIsochChannelForceStopNotificationProc stopProc=NULL,␊
775␉void *stopRefCon=NULL);␊
776␊
777 // Create a local isochronous port to run the given DCL program␊
778 // if task is 0, the DCL program is for the kernel task,␊
779 // otherwise all DCL pointers are valid in the specified task.␊
780 // opcodes is also pointer valid in the specified task.␊
781 virtual IOFWLocalIsochPort *createLocalIsochPort(bool talking,␊
782 DCLCommand* opcodes, DCLTaskInfo *info = 0,␊
783␉UInt32 startEvent = 0, UInt32 startState = 0, UInt32 startMask = 0);␊
784␊
785 // Execute specified function on workloop after specified delay␊
786 // Returned command is for delay, call it's cancel() function to cancel timeout.␊
787 virtual IOFWDelayCommand * createDelayedCmd(UInt32 uSecDelay, FWBusCallback func, void *refcon);␊
788␊
789 virtual IOFWPhysicalAddressSpace *createPhysicalAddressSpace(IOMemoryDescriptor *mem);␊
790 virtual IOFWPseudoAddressSpace *createPseudoAddressSpace(FWAddress *addr, UInt32 len,␊
791 FWReadCallback reader, FWWriteCallback writer, void *refcon);␊
792␊
793 // Extract info about the async request ␊
794 virtual bool isLockRequest(IOFWRequestRefCon refcon);␊
795 virtual bool isQuadRequest(IOFWRequestRefCon refcon);␊
796 virtual UInt32 getExtendedTCode(IOFWRequestRefCon refcon);␊
797 ␊
798 // Inline accessors for protected member variables␊
799 IOFWCmdQ &getTimeoutQ();␊
800␉IOFWCmdQ &getPendingQ();␊
801 IOFWCmdQ &getAfterResetHandledQ();␊
802 IOFireWireLink * getLink() const;␊
803␊
804 IOLocalConfigDirectory *getRootDir() const;␊
805 bool checkGeneration(UInt32 gen) const;␊
806 UInt32 getGeneration() const;␊
807 UInt16 getLocalNodeID() const;␊
808 IOReturn getIRMNodeID(UInt32 &generation, UInt16 &id);␊
809 ␊
810 const AbsoluteTime * getResetTime() const;␊
811␊
812 IOFWSpeed FWSpeed(UInt16 nodeAddress) const;␊
813 IOFWSpeed FWSpeed(UInt16 nodeA, UInt16 nodeB) const;␊
814␊
815 // How big (as a power of two) can packets sent to/received from the node be?␊
816 virtual int maxPackLog(bool forSend, UInt16 nodeAddress) const;␊
817␊
818 // How big (as a power of two) can packets sent from A to B be?␊
819 virtual int maxPackLog(UInt16 nodeA, UInt16 nodeB) const;␊
820␊
821 // Force given node to be root (via root holdoff Phy packet)␊
822 virtual IOReturn makeRoot(UInt32 generation, UInt16 nodeID) ;␊
823␊
824 virtual IOFWPseudoAddressSpace *createInitialAddressSpace(UInt32 addressLo, UInt32 len,␊
825 FWReadCallback reader, FWWriteCallback writer, void *refcon);␊
826 ␊
827 virtual IOFWAddressSpace *getAddressSpace(FWAddress address);␊
828 ␊
829 // Extract info about the async request - was the request ack'ed complete already?␊
830 virtual bool isCompleteRequest(IOFWRequestRefCon refcon);␊
831␊
832 // Are we currently scanning the bus?␊
833 bool scanningBus() const;␊
834␊
835protected:␊
836␊
837 void openGate();␊
838 void closeGate();␊
839␉␉␊
840protected: ␊
841␉virtual void doBusReset( void );␊
842␉static void resetStateChange( void *refcon, IOReturn status,␊
843␉␉␉␉␉␉␉␉ IOFireWireBus *bus, IOFWBusCommand *fwCmd);␊
844␊
845public:␊
846␉virtual IOReturn disableSoftwareBusResets( void );␊
847␉virtual void enableSoftwareBusResets( void );␊
848␊
849 virtual IOFWAsyncStreamCommand * createAsyncStreamCommand( UInt32 generation,␊
850 ␉␉␉UInt32 channel, UInt32 sync, UInt32 tag, IOMemoryDescriptor *hostMem,␊
851␉␉␉␉UInt32 size, int speed,FWAsyncStreamCallback completion, void *refcon);␊
852 ␊
853␉virtual␉IOReturn asyncStreamWrite(UInt32 generation,␊
854 int speed, int tag, int sync, int channel,␊
855 IOMemoryDescriptor *buf, IOByteCount offset,␊
856 ␉int size, IOFWAsyncStreamCommand *cmd);␊
857␉␉␉␉␉␊
858protected:␊
859␉bool inGate();␊
860␊
861 virtual IOReturn allocatePseudoAddress(FWAddress *addr, UInt32 lenDummy);␊
862 virtual void freePseudoAddress(FWAddress addr, UInt32 lenDummy);␊
863␉␊
864␉virtual IORegistryEntry * createDummyRegistryEntry( IOFWNodeScan *scan );␊
865␊
866␉static IOFireWireLocalNode * getLocalNode(IOFireWireController *control);␊
867␉␊
868␉virtual void setPhysicalAccessMode( IOFWPhysicalAccessMode mode );␊
869␉virtual IOFWPhysicalAccessMode getPhysicalAccessMode( void );␊
870␉virtual void physicalAccessProcessBusReset( void );␊
871␉virtual void setNodeIDPhysicalFilter( UInt16 nodeID, bool state );␊
872␉␊
873␉virtual void initSecurity( void );␊
874␉virtual void freeSecurity( void );␊
875␉static bool serverKeyswitchCallback( void * target, void * refCon, IOService * service, IONotifier * notifier );␊
876␉virtual void setSecurityMode( IOFWSecurityMode mode );␊
877␉virtual IOFWSecurityMode getSecurityMode( void );␊
878␊
879␉virtual IOReturn createTimeoutQ( void );␊
880␉virtual void destroyTimeoutQ( void );␊
881␉virtual IOReturn createPendingQ( void );␊
882␉virtual void destroyPendingQ( void );␊
883␊
884␉virtual UInt32 countNodeIDChildren( UInt16 nodeID, int hub_port = 0, int * hubChildRemainder = NULL, bool * hubParentFlag = NULL );␊
885␊
886public:␊
887␉virtual UInt32 hopCount(UInt16 nodeAAddress, UInt16 nodeBAddress );␊
888␉virtual UInt32 hopCount(UInt16 nodeAAddress );␊
889␉␊
890␉virtual IOFireWirePowerManager * getBusPowerManager( void );␊
891␊
892protected:␊
893␉virtual void handleARxReqIntComplete();␊
894␊
895 virtual IOReturn asyncLock(␉UInt32 ␉␉␉␉␉generation, ␊
896␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉␉nodeID, ␊
897␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉␉addrHi, ␊
898␉␉␉␉␉␉␉␉UInt32 ␉␉␉␉␉addrLo,␊
899␉␉␉␉␉␉␉␉int ␉␉␉␉␉speed, ␊
900␉␉␉␉␉␉␉␉int ␉␉␉␉␉label, ␊
901␉␉␉␉␉␉␉␉int ␉␉␉␉␉type, ␊
902␉␉␉␉␉␉␉␉IOMemoryDescriptor *␉buf, ␊
903␉␉␉␉␉␉␉␉IOByteCount ␉␉␉offset,␊
904␉␉␉␉␉␉␉␉int ␉␉␉␉␉size, ␊
905␉␉␉␉␉␉␉␉IOFWAsyncCommand *␉␉cmd );␊
906␊
907 virtual IOReturn asyncWrite(␉UInt32 ␉␉␉␉␉generation, ␊
908␉␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉␉nodeID, ␊
909␉␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉␉addrHi, ␊
910␉␉␉␉␉␉␉␉␉UInt32 ␉␉␉␉␉addrLo,␊
911␉␉␉␉␉␉␉␉␉int ␉␉␉␉␉speed, ␊
912␉␉␉␉␉␉␉␉␉int ␉␉␉␉␉label, ␊
913␉␉␉␉␉␉␉␉␉IOMemoryDescriptor *␉buf, ␊
914␉␉␉␉␉␉␉␉␉IOByteCount ␉␉␉offset,␊
915␉␉␉␉␉␉␉␉␉int ␉␉␉␉␉size, ␊
916␉␉␉␉␉␉␉␉␉IOFWAsyncCommand *␉␉cmd,␊
917␉␉␉␉␉␉␉␉␉IOFWWriteFlags ␉␉␉flags );␊
918␊
919protected:␊
920␉bool delayedStateCommandInUse() const;␊
921␉void enterBusResetDisabledState( );␊
922␉␊
923␉virtual UInt32 getPortNumberFromIndex( UInt16 index );␊
924␉␉␉␉␉␉␉␉␉␉␉␉␊
925 virtual bool checkForDuplicateGUID(IOFWNodeScan *scan, CSRNodeUniqueID *currentGUIDs );␊
926 virtual void updateDevice(IOFWNodeScan *scan );␊
927 virtual bool AssignCycleMaster();␊
928␊
929public:␊
930␊
931 ␉IOReturn clipMaxRec2K(Boolean clipMaxRec );␊
932␉void setNodeSpeed( UInt16 nodeAddress, IOFWSpeed speed );␊
933␉void useHalfSizePackets( void );␊
934␉void disablePhyPortOnSleepForNodeID( UInt32 nodeID );␊
935␊
936␉IOReturn handleAsyncCompletion( IOFWCommand *cmd, IOReturn status );␊
937␉void processCycle64Int();␊
938␊
939#ifdef LEGACY_SHUTDOWN␊
940␉static IOReturn systemShutDownHandler( void * target, void * refCon,␊
941 UInt32 messageType, IOService * service,␊
942 void * messageArgument, vm_size_t argSize );␊
943#else␊
944 virtual void systemWillShutdown( IOOptionBits specifier );␊
945#endif␊
946␊
947␉IOReturn beginIOCriticalSection( void );␊
948␉void endIOCriticalSection( void );␊
949␊
950protected:␉␊
951␉IOReturn poweredStart( void );␊
952␉void setNodeSpeed( UInt16 nodeA, UInt16 nodeB, UInt8 speed );␊
953␉void setNodeSpeed( UInt16 nodeAddress, UInt8 speed );␊
954␊
955public:␊
956␉bool isPhysicalAccessEnabledForNodeID( UInt16 nodeID );␊
957␉␊
958␉// Allocate IRM bandwidth if the specified generation is the current FireWire generation.␊
959␉IOReturn allocateIRMBandwidthInGeneration(UInt32 bandwidthUnits, UInt32 generation) ;␊
960␉␊
961␉// Release IRM bandwidth if the specified generation is the current FireWire generation.␊
962␉IOReturn releaseIRMBandwidthInGeneration(UInt32 bandwidthUnits, UInt32 generation) ;␊
963␉␊
964␉// Allocate IRM channel if the specified generation is the current FireWire generation.␊
965␉IOReturn allocateIRMChannelInGeneration(UInt8 isochChannel, UInt32 generation) ;␊
966␉␊
967␉// Release IRM channel if the specified generation is the current FireWire generation.␊
968␉IOReturn releaseIRMChannelInGeneration(UInt8 isochChannel, UInt32 generation) ;␊
969␉␊
970␉// Create an IOFireWireIRMAllocation object which can be used to allocate isoch resources that are automatically reallocated after bus-resets!␊
971␉IOFireWireIRMAllocation *createIRMAllocation(Boolean releaseIRMResourcesOnFree = true, ␊
972␉␉␉␉␉␉␉␉␉␉␉␉IOFireWireIRMAllocation::AllocationLostNotificationProc allocationLostProc = NULL,␊
973␉␉␉␉␉␉␉␉␉␉␉␉void *pLostNotificationProcRefCon = NULL);␊
974␊
975␉IOFWAsyncStreamListener *createAsyncStreamListener( UInt32␉channel, FWAsyncStreamReceiveCallback proc, void *refcon );␊
976␊
977␉void removeAsyncStreamListener( IOFWAsyncStreamListener *listener );␊
978␊
979␉IOFWSpeed getBroadcastSpeed(){ return FWSpeed( fLocalNodeID ); };␊
980␊
981private:␊
982␊
983␉IOFWAsyncStreamReceiver *allocAsyncStreamReceiver( UInt32 channel, FWAsyncStreamReceiveCallback proc, void *refcon );␊
984␊
985␉IOFWAsyncStreamReceiver *getAsyncStreamReceiver( UInt32 channel );␊
986␊
987␉void freeAllAsyncStreamReceiver();␊
988␊
989␉void activateAsyncStreamReceivers();␊
990␊
991␉void deactivateAsyncStreamReceivers();␊
992␊
993protected:␊
994␉IOService *findKeyswitchDevice( void );␊
995␉void suspendBus( void );␊
996␊
997public:␊
998␉virtual IOReturn␉␉␉asyncRead(␉UInt32 ␉␉␉␉generation, ␊
999␉␉␉␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉nodeID, ␊
1000␉␉␉␉␉␉␉␉␉␉␉UInt16 ␉␉␉␉addrHi, ␊
1001␉␉␉␉␉␉␉␉␉␉␉UInt32 ␉␉␉␉addrLo,␊
1002␉␉␉␉␉␉␉␉␉␉␉int ␉␉␉␉speed, ␊
1003␉␉␉␉␉␉␉␉␉␉␉int ␉␉␉␉label, ␊
1004␉␉␉␉␉␉␉␉␉␉␉int ␉␉␉␉size, ␊
1005␉␉␉␉␉␉␉␉␉␉␉IOFWAsyncCommand *␉cmd,␊
1006␉␉␉␉␉␉␉␉␉␉␉IOFWReadFlags␉␉flags );␊
1007␊
1008␉void checkProgress( void );␊
1009␊
1010␉void terminateDevice( IOFireWireDevice * device );␊
1011␊
1012␉void nodeMustBeRoot( UInt32 nodeID );␊
1013␊
1014␉void nodeMustNotBeRoot( UInt32 nodeID );␉␊
1015␊
1016␉void setGapCount( UInt32␉gapCount );␉␊
1017␉␊
1018␉IOReturn asyncPHYPacket(␉UInt32␉␉␉␉␉generation, ␊
1019␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉data, ␊
1020␉␉␉␉␉␉␉␉UInt32␉␉␉␉␉data2, ␊
1021␉␉␉␉␉␉␉␉IOFWAsyncPHYCommand *␉cmd );␊
1022␊
1023 IOFWAsyncPHYCommand * createAsyncPHYCommand(␉UInt32␉␉␉␉generation,␊
1024␉␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉data1, ␊
1025␉␉␉␉␉␉␉␉␉␉␉␉␉UInt32␉␉␉␉data2,␉␉␉␊
1026␉␉␉␉␉␉␉␉␉␉␉␉␉FWAsyncPHYCallback␉completion, ␊
1027␉␉␉␉␉␉␉␉␉␉␉␉␉void *␉␉␉␉refcon, ␊
1028␉␉␉␉␉␉␉␉␉␉␉␉␉bool␉␉␉␉failOnReset );␊
1029␉␊
1030private:␊
1031␉AsyncPendingTrans * allocTrans( IOFWAsyncCommand * cmd, IOFWCommand * altcmd );␊
1032␊
1033public:␊
1034␊
1035␉IOReturn activatePHYPacketListener( IOFWPHYPacketListener * listener );␊
1036␉void deactivatePHYPacketListener( IOFWPHYPacketListener * listener );␊
1037␊
1038␉IOFWPHYPacketListener * createPHYPacketListener( FWPHYPacketCallback proc, void * refcon );␊
1039␊
1040private:␊
1041␉void processPHYPacket( UInt32 data1, UInt32 data2 );␊
1042␉void enterLoggingMode( void );␊
1043␊
1044public:␊
1045␉IOReturn getCycleTimeAndUpTime( UInt32 &cycleTime, UInt64 &uptime );␊
1046␊
1047protected:␊
1048␉void removeAsyncStreamReceiver( IOFWAsyncStreamReceiver *receiver );␊
1049␉␊
1050public:␊
1051␊
1052␉// Create a multi-isoch-receive listener␊
1053␉IOFireWireMultiIsochReceiveListener * createMultiIsochReceiveListener(UInt32 channel,␊
1054␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉ FWMultiIsochReceiveListenerCallback callback,␊
1055␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉ void *pCallbackRefCon,␊
1056␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉ FWMultiIsochReceiveListenerParams *pListenerParams = NULL);␊
1057␉␊
1058␉// Activate a multi-isoch-receive listener␊
1059␉IOReturn activateMultiIsochReceiveListener(IOFireWireMultiIsochReceiveListener *pListener);␊
1060␉␊
1061␉// Deactivate a multi-isoch-receive listener␊
1062␉IOReturn deactivateMultiIsochReceiveListener(IOFireWireMultiIsochReceiveListener *pListener);␊
1063␊
1064␉// Call for client to specify he is done with a multi-isoch receiver isoch packet␊
1065␉void clientDoneWithMultiIsochReceivePacket(IOFireWireMultiIsochReceivePacket *pPacket);␊
1066␊
1067public:␊
1068 virtual IOFWAsyncStreamCommand * createAsyncStreamCommand( UInt32 generation,␊
1069 ␉␉␉UInt32 channel, UInt32 sync, UInt32 tag, IOMemoryDescriptor *hostMem,␊
1070␉␉␉␉UInt32 size, int speed,FWAsyncStreamCallback completion, void *refcon, bool␉failOnReset);␊
1071␊
1072private:␊
1073␉void addToIRMAllocationSet(IOFireWireIRMAllocation *anObject);␊
1074␉void removeFromIRMAllocationSet(IOFireWireIRMAllocation *anObject);␊
1075␉␊
1076protected:␉␊
1077␉OSMetaClassDeclareReservedUnused(IOFireWireController, 0);␊
1078 OSMetaClassDeclareReservedUnused(IOFireWireController, 1);␊
1079 OSMetaClassDeclareReservedUnused(IOFireWireController, 2);␊
1080 OSMetaClassDeclareReservedUnused(IOFireWireController, 3);␊
1081 OSMetaClassDeclareReservedUnused(IOFireWireController, 4);␊
1082 OSMetaClassDeclareReservedUnused(IOFireWireController, 5);␊
1083 OSMetaClassDeclareReservedUnused(IOFireWireController, 6);␊
1084 OSMetaClassDeclareReservedUnused(IOFireWireController, 7);␊
1085 OSMetaClassDeclareReservedUnused(IOFireWireController, 8);␊
1086␊
1087};␊
1088␊
1089#endif /* ! _IOKIT_IOFIREWIRECONTROLLER_H */␊
1090

Archive Download this file

Revision: 1146