![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOFWIsochPort.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOFireWire|
Return to IOFWIsochPort.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOFireWire |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
24: *
25: * IOFWIsochPort is an abstract object that represents hardware on the bus
26: * (locally or remotely) that sends or receives isochronous packets.
27: * Local ports are implemented by the local device driver,
28: * Remote ports are implemented by the driver for the remote device.
29: *
30: * HISTORY
31: *
32: */
33: #include <IOKit/firewire/IOFWIsochPort.h>
34: #include <IOKit/firewire/IOFWLocalIsochPort.h>
35: #include <IOKit/firewire/IOFWDCLProgram.h>
36: #include <IOKit/firewire/IOFWCommand.h>
37:
38: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
39: // Commands to control isoch bus hardware
40:
41: class IOFWAllocIsoHWCommand : public IOFWBusCommand
42: {
43: OSDeclareDefaultStructors(IOFWAllocIsoHWCommand)
44:
45: protected:
46: IODCLProgram * fProgram;
47: IOFWSpeed fSpeed;
48: UInt32 fChan;
49:
50: public:
51: virtual IOReturn execute();
52: virtual bool init(IODCLProgram *program, IOFireWireController *control,
53: IOFWSpeed speed, UInt32 chan,
54: FWBusCallback completion=NULL, void *refcon=NULL);
55: };
56:
57: OSDefineMetaClassAndStructors(IOFWAllocIsoHWCommand, IOFWBusCommand)
58:
59: bool IOFWAllocIsoHWCommand::init(IODCLProgram *program,
60: IOFireWireController *control,
61: IOFWSpeed speed, UInt32 chan,
62: FWBusCallback completion, void *refcon)
63: {
64: if(!IOFWBusCommand::initWithController(control, completion, refcon))
65: return false;
66: fProgram = program;
67: fSpeed = speed;
68: fChan = chan;
69: return true;
70: }
71:
72: IOReturn IOFWAllocIsoHWCommand::execute()
73: {
74: return complete(fProgram->allocateHW(fSpeed, fChan));
75: }
76:
77: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
78:
79: class IOFWReleaseIsoHWCommand : public IOFWBusCommand
80: {
81: OSDeclareDefaultStructors(IOFWReleaseIsoHWCommand)
82:
83: protected:
84: IODCLProgram * fProgram;
85:
86: public:
87: virtual IOReturn execute();
88: virtual bool init(IODCLProgram *program, IOFireWireController *control,
89: FWBusCallback completion=NULL, void *refcon=NULL);
90: };
91:
92: OSDefineMetaClassAndStructors(IOFWReleaseIsoHWCommand, IOFWBusCommand)
93:
94: bool IOFWReleaseIsoHWCommand::init(IODCLProgram *program,
95: IOFireWireController *control,
96: FWBusCallback completion, void *refcon)
97: {
98: if(!IOFWBusCommand::initWithController(control, completion, refcon))
99: return false;
100: fProgram = program;
101: return true;
102: }
103:
104: IOReturn IOFWReleaseIsoHWCommand::execute()
105: {
106: return complete(fProgram->releaseHW());
107: }
108:
109:
110: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
111:
112: class IOFWStartIsoHWCommand : public IOFWBusCommand
113: {
114: OSDeclareDefaultStructors(IOFWStartIsoHWCommand)
115:
116: protected:
117: IODCLProgram * fProgram;
118:
119: public:
120: virtual IOReturn execute();
121: virtual bool init(IODCLProgram *program, IOFireWireController *control,
122: FWBusCallback completion=NULL, void *refcon=NULL);
123: };
124:
125: OSDefineMetaClassAndStructors(IOFWStartIsoHWCommand, IOFWBusCommand)
126:
127: bool IOFWStartIsoHWCommand::init(IODCLProgram *program,
128: IOFireWireController *control,
129: FWBusCallback completion, void *refcon)
130: {
131: if(!IOFWBusCommand::initWithController(control, completion, refcon))
132: return false;
133: fProgram = program;
134: return true;
135: }
136:
137: IOReturn IOFWStartIsoHWCommand::execute()
138: {
139: return complete(fProgram->start());
140: }
141:
142:
143: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
144: class IOFWStopIsoHWCommand : public IOFWBusCommand
145: {
146: OSDeclareDefaultStructors(IOFWStopIsoHWCommand)
147:
148: protected:
149: IODCLProgram * fProgram;
150:
151: public:
152: virtual IOReturn execute();
153: virtual bool init(IODCLProgram *program, IOFireWireController *control,
154: FWBusCallback completion=NULL, void *refcon=NULL);
155: };
156:
157: OSDefineMetaClassAndStructors(IOFWStopIsoHWCommand, IOFWBusCommand)
158:
159: bool IOFWStopIsoHWCommand::init(IODCLProgram *program,
160: IOFireWireController *control,
161: FWBusCallback completion, void *refcon)
162: {
163: if(!IOFWBusCommand::initWithController(control, completion, refcon))
164: return false;
165: fProgram = program;
166: return true;
167: }
168:
169: IOReturn IOFWStopIsoHWCommand::execute()
170: {
171: fProgram->stop();
172: return complete(kIOReturnSuccess);
173: }
174:
175:
176: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
177: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
178: OSDefineMetaClass( IOFWIsochPort, OSObject )
179: OSDefineAbstractStructors(IOFWIsochPort, OSObject)
180:
181: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
182: OSDefineMetaClassAndStructors(IOFWLocalIsochPort, IOFWIsochPort)
183:
184: bool IOFWLocalIsochPort::init(IODCLProgram *program, IOFireWireController *control)
185: {
186: if(!IOFWIsochPort::init())
187: return false;
188: fProgram = program; // belongs to us.
189: fControl = control;
190: return true;
191: }
192:
193: void IOFWLocalIsochPort::free()
194: {
195: if(fProgram)
196: fProgram->release();
197: IOFWIsochPort::free();
198: }
199:
200: // Return maximum speed and channels supported
201: // (bit n set = chan n supported)
202: IOReturn IOFWLocalIsochPort::getSupported(IOFWSpeed &maxSpeed, UInt64 &chanSupported)
203: {
204: maxSpeed = kFWSpeedMaximum;
205: chanSupported = ~(UInt64)0;
206: return kIOReturnSuccess;
207: }
208:
209: /*
210: * Allocate hardware resources for port, via workloop
211: * Then compile program, not on workloop.
212: */
213: IOReturn IOFWLocalIsochPort::allocatePort(IOFWSpeed speed, UInt32 chan)
214: {
215: IOReturn res;
216: IOFWAllocIsoHWCommand *allocHW;
217:
218: allocHW = new IOFWAllocIsoHWCommand();
219: if(NULL == allocHW)
220: return kIOReturnNoMemory;
221: if(!allocHW->init(fProgram, fControl, speed, chan)) {
222: allocHW->release();
223: return kIOReturnNoMemory;
224: }
225: allocHW->submit();
226:
227: res = allocHW->fStatus;
228: allocHW->release();
229:
230: if(kIOReturnSuccess != res)
231: return res;
232: return fProgram->compile(speed, chan); // Not on workloop
233: }
234:
235: IOReturn IOFWLocalIsochPort::releasePort()
236: {
237: IOFWReleaseIsoHWCommand *releaseHW;
238: IOReturn res;
239:
240: releaseHW = new IOFWReleaseIsoHWCommand();
241: if(NULL == releaseHW)
242: return kIOReturnNoMemory;
243: if(!releaseHW->init(fProgram, fControl)) {
244: releaseHW->release();
245: return kIOReturnNoMemory;
246: }
247: releaseHW->submit();
248:
249: res = releaseHW->fStatus;
250: releaseHW->release();
251: return res;
252: }
253:
254: IOReturn IOFWLocalIsochPort::start()
255: {
256: IOFWStartIsoHWCommand *startHW;
257: IOReturn res;
258:
259: startHW = new IOFWStartIsoHWCommand();
260: if(NULL == startHW)
261: return kIOReturnNoMemory;
262: if(!startHW->init(fProgram, fControl)) {
263: startHW->release();
264: return kIOReturnNoMemory;
265: }
266: startHW->submit();
267:
268: res = startHW->fStatus;
269: startHW->release();
270: return res;
271: }
272:
273: IOReturn IOFWLocalIsochPort::stop()
274: {
275: IOFWStopIsoHWCommand *stopHW;
276: IOReturn res;
277:
278: stopHW = new IOFWStopIsoHWCommand();
279: if(NULL == stopHW)
280: return kIOReturnNoMemory;
281: if(!stopHW->init(fProgram, fControl)) {
282: stopHW->release();
283: return kIOReturnNoMemory;
284: }
285: stopHW->submit();
286:
287: res = stopHW->fStatus;
288: stopHW->release();
289: return res;
290: }
291:
292:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.