![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IODirectDevice.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / libDriver|
Return to IODirectDevice.m CVS log | Up to [Apple Darwin 0.x] / driverkit / libDriver |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: /* Copyright (c) 1993 NeXT Computer, Inc. All rights reserved.
25: *
26: * IODirectDevice class implementation.
27: *
28: * HISTORY
29: * 08-Jan-93 Doug Mitchell at NeXT
30: * Created.
31: */
32:
33: #ifdef KERNEL
34: #define MACH_USER_API 1
35: #endif KERNEL
36:
37: #import <objc/List.h>
38: #import <driverkit/IODirectDevice.h>
39: #import <driverkit/IODirectDevicePrivate.h>
40: #import <driverkit/IODeviceDescriptionPrivate.h>
41: #import <driverkit/generalFuncs.h>
42: #import <driverkit/KernDeviceDescription.h>
43: #import <driverkit/KernDevice.h>
44: #import <driverkit/KernBusMemory.h>
45: #import <driverkit/interruptMsg.h>
46: #import <mach/mach_types.h>
47: #import <mach/mach_interface.h>
48:
49: @interface IODirectDevice(EISAPrivate)
50: - initEISA;
51: - freeEISA;
52: @end
53: @interface IODirectDevice(HPPAPrivate)
54: - initHPPA;
55: - freeHPPA;
56: @end
57: @interface IODirectDevice(SPARCPrivate)
58: - initSPARC;
59: - freeSPARC;
60: @end
61: @interface IODirectDevice(PPCPrivate)
62: - initPPC;
63: - freePPC;
64: @end
65:
66: @interface IODirectDevice(InterruptPrivate)
67: - (IOReturn) _changeInterrupt:(unsigned int) localInterrupt to:(BOOL) enable;
68: @end
69:
70: #define NUM_LOCAL_INTS 4
71:
72: typedef struct _IODirectDevicePrivate {
73: id memory_mappings;
74: id device_interrupts;
75: id local_device_interrupts[ NUM_LOCAL_INTS ];
76: } IODirectDevicePrivate;
77:
78: #define IO_EXIT_THREAD_MSG IO_FIRST_UNRESERVED_INTERRUPT_MSG
79:
80: @implementation IODirectDevice
81:
82: /*
83: * By defintion, all subclasses of this class are of style IO_DirectDevice.
84: * Subclasses need not implement this method.
85: */
86: + (IODeviceStyle)deviceStyle
87: {
88: return IO_DirectDevice;
89: }
90:
91: - initFromDeviceDescription: deviceDescription
92: {
93: IODirectDevicePrivate *private;
94: [super init];
95:
96: [self setDeviceDescription:deviceDescription];
97:
98: #if i386
99: [self initEISA];
100: #elif ppc
101: [self initPPC];
102: #elif hppa
103: [self initHPPA];
104: #elif sparc
105: [self initSPARC];
106: #endif
107: private = _private = (void *)IOMalloc(sizeof (*private));
108: bzero( private, sizeof (*private));
109:
110: return self;
111: }
112:
113: - init
114: {
115: return [self free];
116: }
117:
118: - free
119: {
120: IODirectDevicePrivate *private = _private;
121: struct _private *busPrivate = _busPrivate;
122: msg_header_t msg = { 0 };
123:
124: if (_interruptPort) {
125: if (_ioThread) {
126: msg.msg_size = sizeof (msg);
127: msg.msg_id = IO_EXIT_THREAD_MSG;
128: #ifdef KERNEL
129: msg.msg_remote_port = IOGetKernPort(_interruptPort);
130: msg_send_from_kernel(&msg, MSG_OPTION_NONE, 0);
131: #else
132: msg.msg_remote_port = _interruptPort;
133: msg_send(&msg, MSG_OPTION_NONE, 0);
134: #endif KERNEL
135: }
136:
137: [[_deviceDescriptionDelegate device] detachInterruptPort];
138: (void) port_deallocate(task_self(), _interruptPort);
139: _interruptPort = PORT_NULL;
140: }
141:
142: if (busPrivate) {
143: if (busPrivate->type == EISA)
144: [self freeEISA];
145: else if (busPrivate->type == ArchPPC)
146: [self freePPC];
147: else if (busPrivate->type == HPPA)
148: [self freeHPPA];
149: else if (busPrivate->type == SPARC)
150: [self freeSPARC];
151: }
152:
153: if (private) {
154: if (private->memory_mappings)
155: [private->memory_mappings free];
156: if (private->device_interrupts)
157: [private->device_interrupts free];
158: IOFree((void *)private, sizeof (*private));
159: }
160:
161: return [super free];
162: }
163:
164: - (void)setDeviceDescription : deviceDescription
165: {
166: [super setDeviceDescription:deviceDescription];
167: _deviceDescription = deviceDescription;
168: _deviceDescriptionDelegate = [deviceDescription _delegate];
169: }
170:
171: - (port_t)interruptPort
172: {
173: return _interruptPort;
174: }
175:
176: - (IOReturn) attachInterruptPort
177: {
178: if (_interruptPort == PORT_NULL) {
179: if (port_allocate(task_self(), &_interruptPort))
180: return IO_R_NOT_ATTACHED;
181:
182: /*
183: * Don't attach unless interrupts have been configured.
184: */
185: if ([[_deviceDescriptionDelegate device]
186: attachInterruptPort:_interruptPort] == nil) {
187: (void) port_deallocate(task_self(), _interruptPort);
188: _interruptPort = PORT_NULL;
189:
190: return IO_R_NOT_ATTACHED;
191: }
192: }
193:
194: return IO_R_SUCCESS;
195: }
196:
197: static void
198: IODirectDeviceThread(id device);
199:
200: - (IOReturn)startIOThreadWithPriority:(int)priority
201: {
202: IOReturn result = IO_R_SUCCESS;
203:
204: if (_ioThread == NULL) {
205: result = [self attachInterruptPort];
206:
207: if (result == IO_R_SUCCESS) {
208: _ioThread = IOForkThread((IOThreadFunc)IODirectDeviceThread, self);
209: if (priority >= 0)
210: (void) IOSetThreadPriority(_ioThread, priority);
211: }
212: }
213:
214: return (result);
215: }
216:
217: - (IOReturn)startIOThreadWithFixedPriority:(int)priority
218: {
219: IOReturn result = IO_R_SUCCESS;
220:
221: if (_ioThread == NULL) {
222: result = [self startIOThreadWithPriority:priority];
223: if (result == IO_R_SUCCESS)
224: (void) IOSetThreadPolicy(_ioThread, POLICY_FIXEDPRI);
225: }
226:
227: return (result);
228: }
229:
230: - (IOReturn)startIOThread
231: {
232: return [self startIOThreadWithPriority:-1];
233: }
234:
235: - (IOReturn)waitForInterrupt:(int *)id
236: {
237: IOInterruptMsg interruptMsg;
238: kern_return_t result;
239: msg_option_t option = RCV_TIMEOUT | RCV_LARGE;
240:
241: if (_interruptPort == PORT_NULL)
242: return (IO_R_NO_INTERRUPT);
243:
244: do {
245: interruptMsg.header.msg_size = sizeof (interruptMsg);
246: interruptMsg.header.msg_local_port = _interruptPort;
247:
248: result = msg_receive(&interruptMsg.header, option, 0);
249: if (result == RCV_TOO_LARGE)
250: return (IO_R_MSG_TOO_LARGE);
251:
252: if (result != RCV_SUCCESS && result != RCV_TIMED_OUT) {
253: IOLog("%s: %s waitForInterrupt: msg_receive returns %d\n",
254: [self name], [self deviceKind], result);
255: return (IO_R_IPC_FAILURE);
256: }
257:
258: if (option & RCV_TIMEOUT) {
259: if (result == RCV_TIMED_OUT)
260: option = RCV_LARGE;
261: else /* if (result == RCV_SUCCESS) */
262: (void) thread_block();
263: }
264: } while (result != RCV_SUCCESS);
265:
266: *id = interruptMsg.header.msg_id;
267:
268: return (IO_R_SUCCESS);
269: }
270:
271: - (void)receiveMsg
272: {
273: IOInterruptMsg interruptMsg;
274:
275: if (_interruptPort == PORT_NULL)
276: return;
277:
278: interruptMsg.header.msg_size = sizeof (interruptMsg);
279: interruptMsg.header.msg_local_port = _interruptPort;
280:
281: (void) msg_receive(&interruptMsg.header, MSG_OPTION_NONE, 0);
282: }
283:
284: - (void)timeoutOccurred
285: {
286: }
287:
288: - (void)interruptOccurred
289: {
290: [self interruptOccurredAt:0];
291: }
292:
293: - (void)interruptOccurredAt:(int)localNum
294: {
295: }
296:
297: - (void)commandRequestOccurred
298: {
299: }
300:
301: - (void)otherOccurred:(int)id
302: {
303: }
304:
305: @end /* IODirectDevice */
306:
307: @implementation IODirectDevice(IOInterrupts)
308:
309: - (IOReturn) enableAllInterrupts
310: {
311: unsigned int i, max = [_deviceDescription numInterrupts];
312:
313: for (i=0; i < max; i++) {
314: if ([self enableInterrupt:i] != IO_R_SUCCESS) {
315: [self disableAllInterrupts];
316: return IO_R_NOT_ATTACHED;
317: }
318: }
319: return IO_R_SUCCESS;
320: }
321:
322:
323: - (void) disableAllInterrupts
324: {
325: unsigned int i, max = [_deviceDescription numInterrupts];
326:
327: for (i=0; i < max; i++)
328: [self disableInterrupt:i];
329: }
330:
331: - (IOReturn) enableInterrupt:(unsigned int) localInterrupt
332: {
333: IODirectDevicePrivate *private = _private;
334:
335: if( (localInterrupt < NUM_LOCAL_INTS) && private->local_device_interrupts[ localInterrupt ]) {
336: [private->local_device_interrupts[ localInterrupt ] resume];
337: return IO_R_SUCCESS;
338: }
339:
340: if ([self attachInterruptPort] != IO_R_SUCCESS)
341: return IO_R_NOT_ATTACHED;
342: return [self _changeInterrupt:localInterrupt to:YES];
343: }
344:
345:
346: - (void) disableInterrupt:(unsigned int) localInterrupt
347: {
348: IODirectDevicePrivate *private = _private;
349:
350: if( (localInterrupt < NUM_LOCAL_INTS) && private->local_device_interrupts[ localInterrupt ]) {
351: [private->local_device_interrupts[ localInterrupt ] suspend];
352: return;
353: }
354: [self _changeInterrupt:localInterrupt to:NO];
355: }
356:
357: /*
358: * The subclass overrides this method. In the superclass, we just
359: * return NO.
360: */
361: - (BOOL) getHandler:(IOInterruptHandler *)handler
362: level:(unsigned int *)ipl
363: argument:(unsigned int *) arg
364: forInterrupt:(unsigned int) localInterrupt
365: {
366: return NO;
367: }
368:
369: @end
370:
371: @implementation IODirectDevice(InterruptPrivate)
372:
373: - (IOReturn) _changeInterrupt:(unsigned int) localInterrupt to:(BOOL) enable
374: {
375: IODirectDevicePrivate *private = _private;
376: id interrupt;
377:
378: if (localInterrupt >= [_deviceDescription numInterrupts])
379: return IO_R_INVALID_ARG;
380:
381: if (private->device_interrupts == nil)
382: private->device_interrupts =
383: [[HashTable alloc] initKeyDesc:"i"];
384: interrupt = [private->device_interrupts
385: valueForKey:(void *)localInterrupt];
386: if (interrupt == nil) {
387: IOInterruptHandler handler;
388: unsigned int ipl = 3; /* XXX */
389: unsigned int arg = 0;
390: id busInterrupt;
391:
392: interrupt = [[_deviceDescriptionDelegate device]
393: interrupt:localInterrupt];
394: [private->device_interrupts
395: insertKey:(void *)localInterrupt
396: value:interrupt];
397: if( localInterrupt < NUM_LOCAL_INTS)
398: private->local_device_interrupts[ localInterrupt ] = interrupt;
399: busInterrupt = [[_deviceDescriptionDelegate
400: resourcesForKey:IRQ_LEVELS_KEY]
401: objectAt:localInterrupt];
402: if ([self getHandler:&handler
403: level:&ipl
404: argument:&arg
405: forInterrupt:localInterrupt])
406: [interrupt attachToBusInterrupt:busInterrupt
407: withSpecialHandler:handler
408: argument:(void *)arg
409: atLevel:ipl];
410: else
411: [interrupt attachToBusInterrupt:busInterrupt
412: withArgument:(void *)
413: (IO_DEVICE_INTERRUPT_MSG +
414: localInterrupt)];
415: }
416:
417: if (enable)
418: [interrupt resume];
419: else
420: [interrupt suspend];
421:
422: return IO_R_SUCCESS;
423: }
424:
425:
426: @end
427:
428: @implementation IODirectDevice(IOMemory)
429: /*
430: * Methods to map device memory into the calling task's address space.
431: */
432: - (IOReturn) mapMemoryRange:(unsigned int) localRange
433: to:(vm_address_t *) destAddr
434: findSpace:(BOOL) findSpace
435: cache:(IOCache) cache
436: {
437: IODirectDevicePrivate *private = _private;
438: id mapping;
439: id resource;
440:
441: if (localRange >= [_deviceDescription numMemoryRanges])
442: return IO_R_INVALID_ARG;
443:
444: resource = [[_deviceDescriptionDelegate resourcesForKey:MEM_MAPS_KEY]
445: objectAt:localRange];
446: if (findSpace)
447: mapping =
448: [resource mapInTarget:current_task_EXTERNAL()
449: cache:cache];
450: else
451: mapping =
452: [resource mapToAddress:*destAddr
453: inTarget:current_task_EXTERNAL()
454: cache:cache];
455:
456: if (mapping == nil)
457: return IO_R_NO_MEMORY;
458:
459: *destAddr = [mapping address];
460:
461: if (private->memory_mappings == nil)
462: private->memory_mappings = [[HashTable alloc] initKeyDesc:"i"];
463:
464: [private->memory_mappings insertKey:(void *)*destAddr value:mapping];
465:
466: return IO_R_SUCCESS;
467: }
468:
469: - (void) unmapMemoryRange:(unsigned int) localRange
470: from:(vm_address_t) virtAddr;
471: {
472: IODirectDevicePrivate *private = _private;
473: id mapping;
474:
475: if (localRange >= [_deviceDescription numMemoryRanges])
476: return;
477:
478: mapping = [private->memory_mappings valueForKey:(void *)virtAddr];
479: if (mapping == nil)
480: return;
481:
482: [private->memory_mappings removeKey:(void *)virtAddr];
483:
484: [mapping free];
485: }
486:
487:
488: @end
489:
490: static void
491: IODirectDeviceThread(
492: id device
493: )
494: {
495: IOReturn result;
496: int id;
497:
498: while (TRUE) {
499: result = [device waitForInterrupt:&id];
500: if (result == IO_R_MSG_TOO_LARGE)
501: [device receiveMsg];
502: else if (result != IO_R_SUCCESS)
503: IOLog("%s: %s thread: waitForInterrupt: returns %d\n",
504: [device name], [device deviceKind], result);
505: else {
506: switch (id) {
507:
508: case IO_TIMEOUT_MSG:
509: [device timeoutOccurred];
510: break;
511:
512: case IO_COMMAND_MSG:
513: [device commandRequestOccurred];
514: break;
515:
516: case IO_DEVICE_INTERRUPT_MSG:
517: [device interruptOccurred];
518: break;
519:
520: case IO_EXIT_THREAD_MSG:
521: IOExitThread();
522: break;
523:
524: default:
525: if ( id >= IO_DEVICE_INTERRUPT_MSG_FIRST
526: && id <= IO_DEVICE_INTERRUPT_MSG_LAST) {
527: int localNum = id - IO_DEVICE_INTERRUPT_MSG_FIRST;
528:
529: [device interruptOccurredAt:localNum];
530: }
531: else
532: [device otherOccurred:id];
533: }
534: }
535: }
536: }
537:
538: @implementation IODirectDevice(Private)
539:
540: - _deviceDescriptionDelegate
541: {
542: return _deviceDescriptionDelegate;
543: }
544:
545: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.