![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOCDAudioNubClient.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOCDDrive|
Return to IOCDAudioNubClient.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOCDDrive |
1.1 root 1: #include <IOKit/IOUserClient.h>
2: #include <IOKit/assert.h>
3: #include "IOCDAudioNub.h"
4: #include "IOCDAudioNubClient.h"
5:
6: #define super IOUserClient
7:
8: OSDefineMetaClassAndStructors(IOCDAudioNubClient, IOUserClient)
9:
10: IOCDAudioNubClient *IOCDAudioNubClient::withTask(task_t owningTask)
11: {
12: IOCDAudioNubClient *me;
13:
14: me = new IOCDAudioNubClient;
15: if(me) {
16: if(!me->init()) {
17: me->release();
18: return NULL;
19: }
20: me->fTask = owningTask;
21: }
22: return me;
23: }
24:
25: bool IOCDAudioNubClient::start( IOService * provider )
26: {
27: kprintf("IOCDAudioNubClient::start\n");
28:
29: assert(OSDynamicCast(IOCDAudioNub, provider));
30: if(!super::start(provider))
31: return false;
32: fOwner = (IOCDAudioNub *)provider;
33:
34: fMethods[kTest].object = this;
35: fMethods[kTest].func =
36: (IOMethod)&IOCDAudioNubClient::CDAudioNubTest;
37: fMethods[kTest].count0 = 3;
38: fMethods[kTest].count1 = 1;
39: fMethods[kTest].flags = kIOUCScalarIScalarO;
40:
41: fMethods[kGetNumAudioTracks].object = this;
42: fMethods[kGetNumAudioTracks].func =
43: (IOMethod)&IOCDAudioNubClient::getNumAudioTracks;
44: fMethods[kGetNumAudioTracks].count0 = 0;
45: fMethods[kGetNumAudioTracks].count1 = 1;
46: fMethods[kGetNumAudioTracks].flags = kIOUCScalarIScalarO;
47:
48: fMethods[kGetMSF].object = this;
49: fMethods[kGetMSF].func =
50: (IOMethod)&IOCDAudioNubClient::getMSF;
51: fMethods[kGetMSF].count0 = 1;
52: fMethods[kGetMSF].count1 = 1;
53: fMethods[kGetMSF].flags = kIOUCScalarIScalarO;
54:
55: fMethods[kPlayTrack].object = this;
56: fMethods[kPlayTrack].func =
57: (IOMethod)&IOCDAudioNubClient::playTrack;
58: fMethods[kPlayTrack].count0 = 1;
59: fMethods[kPlayTrack].count1 = 1;
60: fMethods[kPlayTrack].flags = kIOUCScalarIScalarO;
61:
62: fMethods[kPause].object = this;
63: fMethods[kPause].func =
64: (IOMethod)&IOCDAudioNubClient::pause;
65: fMethods[kPause].count0 = 0;
66: fMethods[kPause].count1 = 1;
67: fMethods[kPause].flags = kIOUCScalarIScalarO;
68:
69: fMethods[kResume].object = this;
70: fMethods[kResume].func =
71: (IOMethod)&IOCDAudioNubClient::resume;
72: fMethods[kResume].count0 = 0;
73: fMethods[kResume].count1 = 1;
74: fMethods[kResume].flags = kIOUCScalarIScalarO;
75:
76: fMethods[kGetVolume].object = this;
77: fMethods[kGetVolume].func =
78: (IOMethod)&IOCDAudioNubClient::getVolume;
79: fMethods[kGetVolume].count0 = 0;
80: fMethods[kGetVolume].count1 = 1;
81: fMethods[kGetVolume].flags = kIOUCScalarIScalarO;
82:
83: fMethods[kSetVolume].object = this;
84: fMethods[kSetVolume].func =
85: (IOMethod)&IOCDAudioNubClient::setVolume;
86: fMethods[kSetVolume].count0 = 2;
87: fMethods[kSetVolume].count1 = 1;
88: fMethods[kSetVolume].flags = kIOUCScalarIScalarO;
89:
90: fMethods[kGetAudioStatus].object = this;
91: fMethods[kGetAudioStatus].func =
92: (IOMethod)&IOCDAudioNubClient::getAudioStatus;
93: fMethods[kGetAudioStatus].count0 = 0;
94: fMethods[kGetAudioStatus].count1 = 4;
95: fMethods[kGetAudioStatus].flags = kIOUCScalarIScalarO;
96:
97: fMethods[kPlayMSF].object = this;
98: fMethods[kPlayMSF].func =
99: (IOMethod)&IOCDAudioNubClient::playMSF;
100: fMethods[kPlayMSF].count0 = 2;
101: fMethods[kPlayMSF].count1 = 1;
102: fMethods[kPlayMSF].flags = kIOUCScalarIScalarO;
103:
104: return true;
105: }
106:
107: IOReturn IOCDAudioNubClient::clientClose( void )
108: {
109: kprintf("IOCDAudioNubClient::clientClose\n");
110: if (fOwner) {
111: fOwner->close(this);
112: detach( fOwner);
113: }
114: return kIOReturnSuccess;
115: }
116:
117: IOReturn IOCDAudioNubClient::clientDied( void )
118: {
119: return( clientClose());
120: }
121:
122: IOReturn IOCDAudioNubClient::connectClient( IOUserClient * client )
123: {
124: return kIOReturnSuccess;
125: }
126:
127: IOExternalMethod * IOCDAudioNubClient::getExternalMethodForIndex( UInt32 index )
128: {
129: kprintf("IOCDAudioNubClient::getExternalMethodForIndex: %d\n",index);
130: if(index >= kMethods) {
131: kprintf("IOCDAudioNubClient::getExternalMethodForIndex: bad index\n");
132: return NULL;
133: } else {
134: return &fMethods[index];
135: }
136: }
137:
138: IOReturn IOCDAudioNubClient::registerNotificationPort(
139: mach_port_t port, UInt32 type )
140: {
141: return kIOReturnUnsupported;
142: }
143:
144: IOReturn IOCDAudioNubClient::clientMemoryForType( UInt32 type,
145: UInt32 * flags, IOMemoryDescriptor ** memory )
146: {
147: return 1;
148: }
149:
150: IOReturn IOCDAudioNubClient::CDAudioNubTest(UInt32 opcode, UInt32 operand1, UInt32 operand2, UInt32 *status)
151: {
152: // IOLog("IOCDAudioNubClient::CDAudioNubTest %d %d %d\n", opcode,operand1,operand2);
153:
154: if (!fOwner) return -2;
155:
156: switch(opcode) {
157: case 0:
158: return getNumAudioTracks(status);
159: case 1:
160: return getMSF(operand1-1,status);
161: case 2:
162: return playTrack(operand1-1,status);
163: case 3:
164: return pause(status);
165: case 4:
166: return resume(status);
167: case 5:
168: return getVolume(status);
169: case 6:
170: return setVolume((UInt8)operand1,(UInt8)operand2,status);
171: case 7:
172: return getAudioStatus(status,status,status,status);
173: case 8:
174: return playMSF(operand1,operand2,status);
175: case 9:
176: return readHeader(operand1,status);
177: }
178:
179: return -1;
180: }
181:
182: int subMSF(int m1, int m2)
183: {
184: int f1,f2;
185: int min,sec,frm;
186:
187: // convert to total frames
188: f1 = (m1 >> 16 & 0xff) * 75 * 60 +
189: (m1 >> 8 & 0xff) * 75 +
190: (m1 & 0xff);
191: f2 = (m2 >> 16 & 0xff) * 75 * 60 +
192: (m2 >> 8 & 0xff) * 75 +
193: (m2 & 0xff);
194:
195: // get the total difference in frames
196: m1 = f1 - f2;
197:
198: // convert make to MSF
199: min = (int)(m1 / (75 * 60));
200: m1 = m1 - min * 75 * 60;
201: sec = (int)(m1 / 75);
202: frm = m1 - sec * 75;
203: return (min << 16) | (sec << 8) | frm;
204: }
205:
206: IOReturn IOCDAudioNubClient::playTrack(UInt32 track,UInt32 *status)
207: {
208: struct macEntireToc toc;
209: UInt32 starting_msf, ending_msf;
210: UInt32 starting_track, ending_track;
211:
212: if (!fOwner) return -2;
213: if (track > 101) return -1;
214:
215: // read the TOC
216: fOwner->readEntireTOC(&toc);
217:
218: // get the starting and ending MSF
219: starting_msf = (toc.entries[track].pMin << 16) |
220: (toc.entries[track].pSec << 8) |
221: (toc.entries[track].pFrame);
222:
223: ending_msf = (toc.entries[track+1].pMin << 16) |
224: (toc.entries[track+1].pSec << 8) |
225: (toc.entries[track+1].pFrame);
226:
227: if (ending_msf == 0) return -3;
228:
229: // subtrace one frame from the ending MSF
230: ending_msf = subMSF(ending_msf,1);
231:
232: // status returns the time
233: *status = subMSF(ending_msf,starting_msf);
234:
235: // IOLog("IOCDAudioNubClient::playTrack %d %x %x\n", track,starting_msf,ending_msf);
236:
237: // set the audio stop address
238: fOwner->setAudioStopAddress(kAbsoluteTime,(cdAddress)ending_msf);
239:
240: // send the play command and return immediately
241: return fOwner->audioPlay(kAbsoluteTime,(cdAddress)starting_msf,kNormalMode);
242: }
243:
244: IOReturn IOCDAudioNubClient::playMSF(
245: UInt32 starting_msf, UInt32 ending_msf, UInt32 *status)
246: {
247: // status returns the time
248: *status = subMSF(ending_msf,starting_msf);
249:
250: // set the audio stop address
251: fOwner->setAudioStopAddress(kAbsoluteTime,(cdAddress)ending_msf);
252:
253: // send the play command and return immediately
254: return fOwner->audioPlay(kAbsoluteTime,(cdAddress)starting_msf,kNormalMode);
255: }
256:
257: IOReturn IOCDAudioNubClient::readHeader(UInt32 address, UInt32 *status)
258: {
259: struct headerInfo buffer;
260: IOReturn ret;
261:
262: ret = fOwner->readHeader(address,&buffer);
263: *status = buffer.address;
264: return ret;
265: }
266: IOReturn IOCDAudioNubClient::getMSF(UInt32 track, UInt32 *status)
267: {
268: struct macEntireToc toc;
269: UInt32 msf;
270:
271: if (!fOwner) return -2;
272:
273: // get the TOC
274: fOwner->readEntireTOC(&toc);
275:
276: // get the MSF
277: msf = (toc.entries[track].pMin << 16) |
278: (toc.entries[track].pSec << 8) |
279: (toc.entries[track].pFrame);
280:
281: // status is the MSF
282: *status = msf;
283:
284: // IOLog("IOCDAudioNubClient::getMSF %d %x\n",track,msf);
285: return 0;
286: }
287:
288: IOReturn IOCDAudioNubClient::getNumAudioTracks(UInt32 *status)
289: {
290: struct macEntireToc toc;
291: UInt32 track = 0;
292:
293: if (!fOwner) return -2;
294:
295: // get the TOC
296: fOwner->readEntireTOC(&toc);
297:
298: // count the number of tracks
299: for(;;) {
300: if (!toc.entries[track].trackPoint) break;
301: track++;
302: }
303: if (track) track--;
304:
305: // status returns the number of tracks
306: *status = track;
307:
308: // IOLog("IOCDAudioNubClient::getNumAudioTracks %d\n",track);
309: return 0;
310: }
311:
312: IOReturn IOCDAudioNubClient::pause(UInt32 *status)
313: {
314: if (!fOwner) return -2;
315: *status = 0;
316: return fOwner->audioPause(true);
317: }
318:
319: IOReturn IOCDAudioNubClient::resume(UInt32 *status)
320: {
321: if (!fOwner) return -2;
322: *status = 0;
323: return fOwner->audioPause(false);
324: }
325:
326: IOReturn IOCDAudioNubClient::getVolume(UInt32 *status)
327: {
328: UInt8 right, left;
329: IOReturn ret;
330:
331: if (!fOwner) return -2;
332: ret = fOwner->readAudioVolume(&left,&right);
333: *status = (left << 8 & 0xff00) | (right & 0xff);
334: return ret;
335: }
336:
337: IOReturn IOCDAudioNubClient::setVolume(UInt8 left, UInt8 right, UInt32 *status)
338: {
339: IOReturn ret;
340:
341: // IOLog("IOCDAudioNubClient::setVolume %d %d\n",left,right);
342:
343: if (!fOwner) return -2;
344: ret = fOwner->setVolume(left,right);
345: *status = (left << 8 & 0xff00) | (right & 0xff);
346: return ret;
347: }
348:
349: IOReturn IOCDAudioNubClient::getAudioStatus(UInt32 *status,
350: UInt32 *absAddress, UInt32 *relAddress, UInt32 *trackType)
351: {
352: IOReturn ret;
353: struct audioStatus stat;
354: struct qSubcode buffer;
355: bool found;
356: UInt8 buf[15];
357:
358: ret = fOwner->getAudioStatus(&stat);
359: *status = stat.status;
360: *trackType = stat.type;
361:
362: ret = fOwner->readTheQSubcode(&buffer);
363: *relAddress = buffer.relAddress;
364: *absAddress = buffer.absAddress;
365:
366: // IOLog("IOCDAudioNubClient::getAudioStatus abs=0x%x rel=0x%x status=%d type=%x\n", *absAddress, *relAddress, *status, *trackType);
367:
368: return ret;
369: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.