![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to EventDriver.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 / Kernel|
Return to EventDriver.m CVS log | Up to [Apple Darwin 0.x] / driverkit / libDriver / Kernel |
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) 1992 NeXT Computer, Inc. All rights reserved.
25: *
26: * EventDriver.m - Event System module, ObjC implementation.
27: *
28: * The EventDriver is a pseudo-device driver.
29: *
30: * HISTORY
31: * 31-Mar-92 Mike Paquette at NeXT
32: * Created.
33: * 4 Aug 1993 Erik Kay at NeXT
34: * minor API cleanup
35: */
36:
37: #import <driverkit/generalFuncs.h>
38: #import <machkit/NXLock.h>
39: #import <driverkit/Device_ddm.h>
40: #import <driverkit/kernelDriver.h>
41: #import <mach/notify.h>
42: #import <bsd/dev/evio.h>
43: #import <kern/queue.h>
44: #import <bsd/dev/machine/ev_private.h> /* Per-machine configuration info */
45: #import <driverkit/EventDriver.h>
46: #import <driverkit/EventInput.h>
47: #import <bsd/dev/evsio.h>
48:
49: #define EVSRC_PRINT 0
50: #if EVSRC_PRINT
51: #undef xpr_evsrc
52: #define xpr_evsrc(x,a,b,c,d,e) printf(x,a,b,c,d,e)
53: #endif EVSRC_PRINT
54:
55: static EventDriver *evInstance = (EventDriver *)nil;
56: static volatile void EventListener(EventDriver *inst);
57:
58: typedef void * kern_port_t;
59: #define KERN_PORT_NULL ((kern_port_t) 0)
60:
61: /*
62: * Template for evIoOpMsg.
63: */
64: static evIoOpMsg opMsgTemplate = {
65:
66: { // header
67: 0, // msg_unused
68: 1, // msg_simple
69: sizeof(evIoOpMsg), // msg_size
70: MSG_TYPE_NORMAL, // msg_type
71: PORT_NULL, // msg_local_port
72: PORT_NULL, // msg_remote_port - TO
73: // BE FILLED IN
74: (int)EV_IO_OP_MSG_ID // msg_id
75: },
76: { // type
77: MSG_TYPE_UNSTRUCTURED, // msg_type_name
78: sizeof(evIoOpBuf) * 8, // msg_type_size
79: 1, // msg_type_number
80: 1, // msg_type_inline
81: 0, // msg_type_longform
82: 0, // msg_type_deallocate
83: 0 // msg_type_unused
84: },
85: { 0 } /* evIoOpBuf - TO BE
86: * FILLED IN */
87: };
88:
89: static void nsecs_to_packed_ns(ns_time_t *nsecs, unsigned int *pnsecs)
90: {
91: _NX_packed_time_t data;
92: int i;
93:
94: data.tval = *nsecs; // nsecs to ns_time_t
95: for ( i = 0; i < EVS_PACKED_TIME_SIZE; ++i )
96: pnsecs[i] = data.itval[i];
97: }
98:
99: static void packed_nsecs_to_nsecs(unsigned int *pnsecs, ns_time_t *nsecs)
100: {
101: _NX_packed_time_t data;
102: int i;
103:
104: for ( i = 0; i < EVS_PACKED_TIME_SIZE; ++i )
105: data.itval[i] = pnsecs[i];
106: *nsecs = data.tval;
107: }
108:
109: @implementation EventDriver: IODevice
110:
111: /* Probe routine for a pseudo-device driver. */
112: + (BOOL)probe : deviceDescription
113: {
114: if ( evInstance != nil )
115: return YES;
116:
117: evInstance = [self alloc];
118: /*
119: * Take care of private stuff...
120: */
121: evInstance->devicePort = PORT_NULL;
122: [evInstance setUnit:0];
123: [evInstance setName:"event0"];
124: [evInstance setDeviceKind:"event"];
125:
126: return ([evInstance init] ? YES : NO);
127: }
128:
129: + (IODeviceStyle)deviceStyle
130: {
131: return IO_PseudoDevice;
132: }
133:
134: /* subclass specific methods */
135:
136: /* Return the current instance of the EventDriver, or nil if none. */
137: + instance
138: {
139: return (id)evInstance;
140: }
141:
142: /*
143: * Perform reusable initialization actions here.
144: */
145: - init
146: {
147: kern_return_t krtn;
148: IOReturn drtn;
149: IOThread thread;
150: #ifdef KERNEL
151: extern kern_port_t ev_port_list[];
152: #endif
153:
154: driverLock = [NXLock new]; // Event driver data protection lock
155: eventSrcListLock = [NXLock new];
156: kickConsumerLock = [NXLock new];
157:
158: /*
159: * Set up the ports we'll be using.
160: */
161: krtn = port_allocate(task_self(), &ev_port);
162: if(krtn) {
163: xpr_err("Ev init: port_allocate returned %d\n", krtn, 2,3,4,5);
164: return nil;
165: }
166:
167: krtn = port_allocate(task_self(), &evs_port);
168: if(krtn) {
169: xpr_err("Ev init: port_allocate returned %d\n", krtn, 2,3,4,5);
170: return nil;
171: }
172: krtn = port_allocate(task_self(), ¬ify_port);
173: if(krtn) {
174: xpr_err("Ev init: port_allocate returned %d\n", krtn, 2,3,4,5);
175: return nil;
176: }
177: #ifdef KERNEL
178: /*
179: * Get a kern_port_t version of same for use with
180: * msg_send_from_kernel().
181: */
182: ev_port_list[0] = (kern_port_t)IOGetKernPort(ev_port);
183: ev_port_list[1] = (kern_port_t)IOGetKernPort(evs_port);
184: notify_kern_port = IOGetKernPort(notify_port);
185: #endif KERNEL
186: krtn = port_set_allocate(task_self(), &ev_port_set);
187: if(krtn) {
188: xpr_err("adbInit: port_set_allocate returned %d\n",
189: krtn, 2,3,4,5);
190: return nil;
191: }
192: krtn = port_set_add(task_self(), ev_port_set, ev_port);
193: if(krtn) {
194: xpr_err("Ev init: port_set_add returned %d\n", krtn, 2,3,4,5);
195: return nil;
196: }
197: krtn = port_set_add(task_self(), ev_port_set, evs_port);
198: if(krtn) {
199: xpr_err("Ev init: port_set_add returned %d\n", krtn, 2,3,4,5);
200: return nil;
201: }
202: krtn = port_set_add(task_self(), ev_port_set, notify_port);
203: if(krtn) {
204: xpr_err("Ev init: port_set_add returned %d\n", krtn, 2,3,4,5);
205: return nil;
206: }
207:
208: /*
209: * Initialize the eventSrc list.
210: */
211: queue_init(&eventSrcList);
212:
213: /*
214: * Have IODevice do its thing.
215: */
216: [super init];
217:
218: /* A few details to be set up... */
219: pointerLoc.x = INIT_CURSOR_X;
220: pointerLoc.y = INIT_CURSOR_Y;
221:
222: /*
223: * Start up the I/O thread and wait for it to finish
224: * initialization via an AIO_PING command.
225: */
226: thread = IOForkThread((IOThreadFunc)EventListener, self);
227: (void) IOSetThreadPolicy(thread, POLICY_FIXEDPRI);
228: (void) IOSetThreadPriority(thread, 28); /* XXX */
229:
230: if ( ! hasRegistered )
231: {
232: [self registerDevice];
233: hasRegistered = YES;
234: }
235: return self;
236: }
237:
238: /*
239: * Free locally allocated resources, and then ourselves.
240: */
241: - free
242: {
243: /* Initiates a normal close if open */
244: [self evClose:ev_port token:eventPort];
245:
246: /*
247: * Destroy the ports and port set listenerThread is using.
248: * This will cause it to return from msg_receive() with an
249: * error. It should take this as a clue to exit.
250: */
251: port_deallocate(task_self(), ev_port);
252: port_deallocate(task_self(), evs_port);
253: port_deallocate(task_self(), notify_port);
254: port_set_deallocate(task_self(), ev_port_set);
255:
256: /* Release locally allocated resources */
257: [eventSrcListLock free];
258: [driverLock free];
259: return [super free];
260: }
261:
262: /*
263: * Open the driver for business. This call must be made before
264: * any other calls to the Event driver. We can only be opened by
265: * one user at a time.
266: */
267: - (IOReturn)evOpen:(port_t)dev_port token:(port_t)event_port
268: {
269: IOReturn r = IO_R_SUCCESS;
270:
271: if ( dev_port != ev_port )
272: return IO_R_INVALID_ARG;
273:
274: [driverLock lock];
275:
276: if ( evOpenCalled == YES )
277: {
278: r = IO_R_BUSY;
279: goto done;
280: }
281: evOpenCalled = YES;
282:
283: if (!evInitialized)
284: {
285: evInitialized = YES;
286: curBright = EV_SCREEN_MAX_BRIGHTNESS; // FIXME: Set from NVRAM?
287: curVolume = EV_AUDIO_MAX_VOLUME / 2; // FIXME: Set from NVRAM?
288: // Put code here that is to run on the first open ONLY.
289: }
290:
291: [self setEventPort:event_port];
292: // Init local state
293: // IODDMMasks[XPR_EVENTDRIVER_INDEX] |= XPR_EVSRC;
294: // IODDMMasks[XPR_IODEVICE_INDEX] |= XPR_ADB;
295: done:
296: [driverLock unlock];
297: return r;
298: }
299:
300: - (IOReturn)evClose:(port_t)dev_port token:(port_t)event_port
301: {
302: [driverLock lock];
303: if ( evOpenCalled == NO || event_port != eventPort )
304: {
305: [driverLock unlock];
306: return IO_R_INVALID_ARG;
307: }
308: // Early close actions here
309: [self forceAutoDimState:NO];
310: [self hideCursor];
311:
312: [driverLock unlock];
313:
314: // Release the input devices.
315: [self detachEventSources];
316:
317: // Tear down the shared memory area if set up
318: if ( eventsOpen == YES )
319: [self unmapEventShmem:eventPort];
320:
321: [driverLock lock];
322: // Clear screens registry and related data
323: if ( evScreen != (void *)0 )
324: {
325: IOFree( (void *)evScreen, evScreenSize );
326: evScreen = (void *)0;
327: evScreenSize = 0;
328: screens = 0;
329: lastShmemPtr = (void *)0;
330: }
331: // Remove port notification for the eventPort and clear the port out
332: [self setEventPort:PORT_NULL];
333:
334: // Clear local state to shutdown
335: evOpenCalled = NO;
336: [driverLock unlock];
337:
338: return IO_R_SUCCESS;
339: }
340:
341: - (IOReturn)evFrameBufferDevicePort:(port_t)event_port
342: unitName:(IOString)name
343: unitClass:(IOString)class
344: unitPort:(port_t *)port
345: {
346: id instance;
347: IOReturn r;
348:
349: *port = PORT_NULL;
350: if ( evOpenCalled == NO || event_port != eventPort )
351: return IO_R_INVALID_ARG;
352:
353: if ( (r = IOGetObjectForDeviceName( name, &instance )) != IO_R_SUCCESS )
354: { // Not checked in yet. Lookup class and force a probe
355: if ( (instance = objc_getClass(class)) == nil )
356: return r;
357: if ( [instance respondsTo:@selector(probe)] == NO )
358: return r;
359: if ( (instance = [instance probe]) == nil )
360: return r;
361: }
362:
363: if ( [instance respondsTo:@selector(devicePort)] == NO )
364: return IO_R_PRIVILEGE;
365:
366: *port = [instance devicePort];
367: return IO_R_SUCCESS;
368: }
369:
370: /*
371: * General get/set parameter methods for use with the
372: * event system. These replace the old evs ioctl calls.
373: *
374: * We could wind up not needing any of these, in which case we should
375: * toss them out and let inheritance take care of the messages.
376: */
377: - (IOReturn)getIntValues : (unsigned *)parameterArray
378: forParameter : (IOParameterName)parameterName
379: count : (unsigned *)count; // in/out
380: {
381: IOReturn r = IO_R_INVALID_ARG;
382: IOReturn retval;
383: attachedEventSrc *device;
384: id srcInstance;
385: ns_time_t nst;
386: unsigned maxCount = *count;
387: unsigned returnedCount = 0;
388:
389: // Report the ID for the last left/right button down event
390: if ( strcmp( parameterName, EVIOEVNUM ) == 0 )
391: {
392: if ( maxCount >= EVIOEVNUM_SIZE )
393: {
394: returnedCount = EVIOEVNUM_SIZE;
395: [driverLock lock];
396: parameterArray[EVIOEVNUM_LEFT] = leftENum;
397: parameterArray[EVIOEVNUM_RIGHT] = rightENum;
398: [driverLock unlock];
399: r = IO_R_SUCCESS;
400: }
401: }
402: else if ( strcmp( parameterName, EVIOSHMEMSIZE ) == 0 )
403: {
404: if ( maxCount >= EVIOSHMEMSIZE_SIZE )
405: {
406: returnedCount = EVIOSHMEMSIZE_SIZE;
407: parameterArray[0] = shmem_size;
408: r = IO_R_SUCCESS;
409: }
410: }
411: else if ( strcmp( parameterName, EVSIOCWINFO ) == 0 )
412: {
413: if ( maxCount >= EVSIOCWINFO_SIZE )
414: {
415: returnedCount = EVSIOCWINFO_SIZE;
416: [driverLock lock];
417: if ( eventsOpen == YES )
418: nst = EV_TICK_TO_NS(((EvGlobals*)evg)->waitThreshold);
419: else
420: nst = 0ULL;
421: nsecs_to_packed_ns(&nst,¶meterArray[EVSIOCWINFO_THRESH]);
422: nsecs_to_packed_ns(&waitSustain,
423: ¶meterArray[EVSIOCWINFO_SUSTAIN]);
424: nsecs_to_packed_ns(&waitFrameRate,
425: ¶meterArray[EVSIOCWINFO_FINTERVAL]);
426: [driverLock unlock];
427: r = IO_R_SUCCESS;
428: }
429: }
430: else if ( strcmp( parameterName, EVSIO_DCTLINFO ) == 0 )
431: {
432: if ( maxCount >= EVSIO_DCTLINFO_SIZE )
433: {
434: returnedCount = EVSIO_DCTLINFO_SIZE;
435: [driverLock lock];
436: parameterArray[EVSIO_DCTLINFO_BRIGHT] =
437: [self brightness];
438: // EVSIO_DCTLINFO_ATTEN obsolete once libc-67 is released
439: parameterArray[EVSIO_DCTLINFO_ATTEN] = curVolume;
440: parameterArray[EVSIO_DCTLINFO_AUTODIMBRIGHT] =
441: [self autoDimBrightness];
442: [driverLock unlock];
443: r = IO_R_SUCCESS;
444: }
445: }
446: else if ( strcmp( parameterName, EVSIOCCT ) == 0 )
447: {
448: if ( maxCount >= EVSIOCCT_SIZE )
449: {
450: returnedCount = EVSIOCCT_SIZE;
451: [driverLock lock];
452: nst = EV_TICK_TO_NS(clickTimeThresh);
453: nsecs_to_packed_ns(&nst,¶meterArray[0]);
454: [driverLock unlock];
455: r = IO_R_SUCCESS;
456: }
457: }
458: else if ( strcmp( parameterName, EVSIOCADT ) == 0 )
459: {
460: if ( maxCount >= EVSIOCADT_SIZE )
461: {
462: returnedCount = EVSIOCADT_SIZE;
463: [driverLock lock];
464: nst = EV_TICK_TO_NS(autoDimPeriod);
465: nsecs_to_packed_ns(&nst,¶meterArray[0]);
466: [driverLock unlock];
467: r = IO_R_SUCCESS;
468: }
469: }
470: else if ( strcmp( parameterName, EVSIOGDADT ) == 0 )
471: {
472: if ( maxCount >= EVSIOGDADT_SIZE )
473: {
474: returnedCount = EVSIOGDADT_SIZE;
475: [driverLock lock];
476: if ( eventsOpen == YES )
477: {
478: if ( autoDimmed )
479: nst = EV_TICK_TO_NS(0);
480: else
481: nst = EV_TICK_TO_NS(autoDimTime -
482: ((EvGlobals*)evg)->VertRetraceClock);
483: }
484: else
485: nst = EV_TICK_TO_NS(autoDimPeriod);
486: nsecs_to_packed_ns(&nst,¶meterArray[0]);
487: [driverLock unlock];
488: r = IO_R_SUCCESS;
489: }
490: }
491: // added april 7, 1994 EK - to fix bug 41768
492: else if ( strcmp( parameterName, EVSIOIDLE ) == 0 )
493: {
494: if (maxCount >= EVSIOIDLE_SIZE)
495: {
496: returnedCount = EVSIOIDLE_SIZE;
497: [driverLock lock];
498: if (eventsOpen == YES)
499: {
500: if (autoDimmed)
501: nst = EV_TICK_TO_NS(((EvGlobals*)evg)->VertRetraceClock
502: - (autoDimTime - autoDimPeriod));
503: else
504: nst = EV_TICK_TO_NS(autoDimPeriod - (autoDimTime -
505: ((EvGlobals*)evg)->VertRetraceClock));
506: }
507: else
508: nst = EV_TICK_TO_NS(0); // user is active
509: nsecs_to_packed_ns(&nst,¶meterArray[0]);
510: [driverLock unlock];
511: r = IO_R_SUCCESS;
512: }
513: }
514: else if ( strcmp( parameterName, EVSIOCCS ) == 0 )
515: {
516: if ( maxCount >= EVSIOCCS_SIZE )
517: {
518: returnedCount = EVSIOCCS_SIZE;
519: [driverLock lock];
520: parameterArray[EVSIOCCS_X] = clickSpaceThresh.x;
521: parameterArray[EVSIOCCS_Y] = clickSpaceThresh.y;
522: [driverLock unlock];
523: r = IO_R_SUCCESS;
524: }
525: }
526: else if ( strcmp( parameterName, EVSIOCADS ) == 0 )
527: {
528: if ( maxCount >= EVSIOCADS_SIZE )
529: {
530: returnedCount = EVSIOCADS_SIZE;
531: [driverLock lock];
532: parameterArray[0] = autoDimmed;
533: [driverLock unlock];
534: r = IO_R_SUCCESS;
535: }
536: }
537: else if ( strcmp( parameterName, EVSIOINFO ) == 0 )
538: {
539: NXEventSystemDevice dp;
540: unsigned int cnt;
541:
542: [eventSrcListLock lock];
543: device = (attachedEventSrc *)queue_first(&eventSrcList);
544: while( ! queue_end(&eventSrcList, (queue_t)device)
545: && maxCount >= (sizeof(NXEventSystemDevice) / sizeof(int)) )
546: {
547: srcInstance = device->info.eventSrc;
548: device = (attachedEventSrc *)device->link.next;
549: cnt = 0;
550: retval = [srcInstance
551: getIntValues:¶meterArray[returnedCount]
552: forParameter : parameterName
553: count : &cnt];
554: if ( retval == IO_R_SUCCESS )
555: {
556: maxCount -= cnt;
557: returnedCount += cnt;
558: }
559: }
560: [eventSrcListLock unlock];
561: r = IO_R_SUCCESS;
562:
563: }
564: else
565: {
566: // Try sending the operation out to the attached
567: // event sources.
568: returnedCount = *count;
569: [eventSrcListLock lock];
570: device = (attachedEventSrc *)queue_first(&eventSrcList);
571: while(!queue_end(&eventSrcList, (queue_t)device))
572: {
573: srcInstance = device->info.eventSrc;
574: device = (attachedEventSrc *)device->link.next;
575: retval = [srcInstance getIntValues:parameterArray
576: forParameter:parameterName
577: count:&returnedCount];
578: if ( retval != IO_R_INVALID_ARG )
579: {
580: r = retval;
581: break;
582: }
583: }
584: [eventSrcListLock unlock];
585:
586: if ( r == IO_R_INVALID_ARG )
587: {
588: r = [super getIntValues:parameterArray
589: forParameter : parameterName
590: count : &returnedCount];
591: }
592: }
593: *count = returnedCount;
594: return r;
595: }
596:
597: - (IOReturn)getCharValues : (unsigned char *)parameterArray
598: forParameter : (IOParameterName)parameterName
599: count : (unsigned *)count
600: {
601: IOReturn r = IO_R_INVALID_ARG;
602: IOReturn retval;
603: attachedEventSrc *device;
604: id srcInstance;
605: unsigned maxCount = *count;
606: unsigned returnedCount = 0;
607:
608: if ( 0 )
609: {
610: }
611: else
612: {
613: // Try sending the operation out to the attached
614: // event sources.
615: returnedCount = *count;
616: [eventSrcListLock lock];
617: device = (attachedEventSrc *)queue_first(&eventSrcList);
618: while(!queue_end(&eventSrcList, (queue_t)device))
619: {
620: srcInstance = device->info.eventSrc;
621: device = (attachedEventSrc *)device->link.next;
622: retval = [srcInstance getCharValues:parameterArray
623: forParameter:parameterName
624: count:&returnedCount];
625: if ( retval != IO_R_INVALID_ARG )
626: {
627: r = retval;
628: break;
629: }
630: }
631: [eventSrcListLock unlock];
632:
633: if ( r == IO_R_INVALID_ARG )
634: {
635: r = [super getCharValues:parameterArray
636: forParameter : parameterName
637: count : &returnedCount];
638: }
639: }
640: *count = returnedCount;
641: return r;
642: }
643:
644:
645: - (IOReturn)setIntValues : (unsigned *)parameterArray
646: forParameter : (IOParameterName)parameterName
647: count : (unsigned)count;
648: {
649: IOReturn r = IO_R_INVALID_ARG;
650: IOReturn retval;
651: attachedEventSrc *device;
652: id srcInstance;
653: Point p;
654: _NX_packed_event_t event;
655: ns_time_t nst;
656:
657: if ( strcmp( parameterName, EVIOSETSCREEN ) == 0 )
658: {
659: if ( count == EVIOSETSCREEN_SIZE )
660: r = [self evSetScreen:parameterArray];
661: }
662: else if ( strcmp( parameterName, EVIOST ) == 0 )
663: {
664: [self startCursor];
665: r = IO_R_SUCCESS;
666: }
667: else if ( strcmp( parameterName, EVIOSM ) == 0 )
668: {
669: if ( count == EVIOSM_SIZE )
670: {
671: p.x = parameterArray[EVIOSM_LOC_X];
672: p.y = parameterArray[EVIOSM_LOC_Y];
673: [driverLock lock];
674: [self setCursorPosition:&p];
675: [driverLock unlock];
676: r = IO_R_SUCCESS;
677: }
678: }
679: else if ( strcmp( parameterName, EVSIOSWT ) == 0 )
680: {
681: packed_nsecs_to_nsecs(parameterArray, &nst);
682: [driverLock lock];
683: if ( eventsOpen )
684: ((EvGlobals*)evg)->waitThreshold = EV_NS_TO_TICK(nst);
685: [driverLock unlock];
686: r = IO_R_SUCCESS;
687: }
688: else if ( strcmp( parameterName, EVSIOSWS ) == 0 )
689: {
690: [driverLock lock];
691: packed_nsecs_to_nsecs(parameterArray, &waitSustain);
692: [driverLock unlock];
693: r = IO_R_SUCCESS;
694: }
695: else if ( strcmp( parameterName, EVSIOSWFI ) == 0 )
696: {
697: [driverLock lock];
698: packed_nsecs_to_nsecs(parameterArray, &waitFrameRate);
699: [driverLock unlock];
700: r = IO_R_SUCCESS;
701: }
702: else if ( strcmp( parameterName, EVSIOSB ) == 0 )
703: {
704: [driverLock lock];
705: [self setBrightness:parameterArray[0]];
706: [driverLock unlock];
707: r = IO_R_SUCCESS;
708: }
709: else if ( strcmp( parameterName, EVSIOSA ) == 0 )
710: { // Obsolete once libc-67 is released
711: [driverLock lock];
712: [self setUserAudioVolume:parameterArray[0]];
713: [driverLock unlock];
714: r = IO_R_SUCCESS;
715: }
716: else if ( strcmp( parameterName, EVSIOSADB ) == 0 )
717: {
718: [driverLock lock];
719: [self setAutoDimBrightness:parameterArray[0]];
720: [driverLock unlock];
721: r = IO_R_SUCCESS;
722: }
723: else if ( strcmp( parameterName, EVSIOSCT ) == 0 )
724: {
725: packed_nsecs_to_nsecs(parameterArray, &nst);
726: [driverLock lock];
727: clickTimeThresh = EV_NS_TO_TICK(nst);
728: [driverLock unlock];
729: r = IO_R_SUCCESS;
730: }
731: else if ( strcmp( parameterName, EVSIOSCS ) == 0 )
732: {
733: [driverLock lock];
734: clickSpaceThresh.x = parameterArray[EVSIOSCS_X];
735: clickSpaceThresh.y = parameterArray[EVSIOSCS_Y];
736: [driverLock unlock];
737: r = IO_R_SUCCESS;
738: }
739: else if ( strcmp( parameterName, EVSIOSADT ) == 0 )
740: {
741: packed_nsecs_to_nsecs(parameterArray, &nst);
742: [driverLock lock];
743: autoDimTime = autoDimTime - autoDimPeriod + EV_NS_TO_TICK(nst);
744: autoDimPeriod = EV_NS_TO_TICK(nst);
745: [driverLock unlock];
746: r = IO_R_SUCCESS;
747: }
748: else if ( strcmp( parameterName, EVSIOSADS ) == 0 )
749: {
750: [driverLock lock];
751: [self forceAutoDimState:parameterArray[0]];
752: [driverLock unlock];
753: r = IO_R_SUCCESS;
754: }
755: else if ( strcmp( parameterName, EVSIORMS ) == 0 )
756: {
757: [self _resetMouseParameters];
758: r = IO_R_SUCCESS;
759: }
760: else if ( strcmp( parameterName, EVSIORKBD ) == 0 )
761: {
762: [self _resetKeyboardParameters];
763: r = IO_R_SUCCESS;
764: }
765: else if ( strcmp( parameterName, EVIOLLPE ) == 0
766: || strcmp( parameterName, EVIOPTRLLPE ) == 0 )
767: {
768: if ( count == EVIOLLPE_SIZE )
769: {
770: p.x = parameterArray[EVIOLLPE_LOC_X];
771: p.y = parameterArray[EVIOLLPE_LOC_Y];
772: event.idata[0] = parameterArray[EVIOLLPE_DATA0];
773: event.idata[1] = parameterArray[EVIOLLPE_DATA1];
774: event.idata[2] = parameterArray[EVIOLLPE_DATA2];
775: [driverLock lock];
776: if ( strcmp( parameterName, EVIOPTRLLPE ) == 0 )
777: [self setCursorPosition:&p];
778: [self postEvent:parameterArray[EVIOLLPE_TYPE]
779: at:&p
780: atTime:EvTickTimeValue()
781: withData:&event.data];
782: [driverLock unlock];
783: r = IO_R_SUCCESS;
784: }
785: }
786: else
787: {
788: // Try sending the operation out to the attached
789: // event sources.
790: [eventSrcListLock lock];
791: device = (attachedEventSrc *)queue_first(&eventSrcList);
792: while(!queue_end(&eventSrcList, (queue_t)device))
793: {
794: srcInstance = device->info.eventSrc;
795: device = (attachedEventSrc *)device->link.next;
796: retval = [srcInstance setIntValues:parameterArray
797: forParameter:parameterName
798: count:count];
799: if ( retval != IO_R_INVALID_ARG )
800: r = retval;
801: }
802: [eventSrcListLock unlock];
803:
804: // Nobody wants it? Kick the message upstairs.
805: if ( r == IO_R_INVALID_ARG )
806: {
807: r = [super setIntValues:parameterArray
808: forParameter:parameterName
809: count:count];
810: }
811: }
812: return r;
813: }
814:
815: - (IOReturn)setCharValues : (unsigned char *)parameterArray
816: forParameter : (IOParameterName)parameterName
817: count : (unsigned)count;
818: {
819: IOReturn r = IO_R_INVALID_ARG;
820: IOReturn retval;
821: attachedEventSrc *device;
822: id srcInstance;
823:
824: if ( 0 )
825: {
826: }
827: else
828: {
829: // Try sending the operation out to the attached
830: // event sources.
831: [eventSrcListLock lock];
832: device = (attachedEventSrc *)queue_first(&eventSrcList);
833: while(!queue_end(&eventSrcList, (queue_t)device))
834: {
835: srcInstance = device->info.eventSrc;
836: device = (attachedEventSrc *)device->link.next;
837: retval = [srcInstance setCharValues:parameterArray
838: forParameter:parameterName
839: count:count];
840: if ( retval != IO_R_INVALID_ARG )
841: r = retval;
842: }
843: [eventSrcListLock unlock];
844:
845: if ( r == IO_R_INVALID_ARG )
846: {
847: r = [super setCharValues: parameterArray
848: forParameter:parameterName
849: count:count];
850: }
851: }
852: return r;
853: }
854:
855: //
856: // Reset instance variables to their default state for mice/pointers
857: //
858: - _resetMouseParameters
859: {
860: attachedEventSrc *device;
861: id srcInstance;
862: unsigned int parameterArray[EVSIORMS_SIZE];
863:
864: [driverLock lock];
865: if ( eventsOpen == NO )
866: {
867: [driverLock unlock];
868: return self;
869: }
870: clickTimeThresh = EV_DCLICKTIME;
871: clickSpaceThresh.x = clickSpaceThresh.y = EV_DCLICKSPACE;
872: clickTime = -EV_DCLICKTIME;
873: clickLoc.x = clickLoc.y = -EV_DCLICKSPACE;
874: clickState = 1;
875: autoDimTime = ((EvGlobals*)evg)->VertRetraceClock + DAUTODIMPERIOD;
876: autoDimPeriod = DAUTODIMPERIOD;
877: dimmedBrightness = DDIMBRIGHTNESS;
878:
879: [driverLock unlock];
880: // Go down the Event Src list looking for devices which respond to
881: // a EVSIORMS message. Ping these.
882: [eventSrcListLock lock];
883: device = (attachedEventSrc *)queue_first(&eventSrcList);
884: while(!queue_end(&eventSrcList, (queue_t)device))
885: {
886: srcInstance = device->info.eventSrc;
887: device = (attachedEventSrc *)device->link.next;
888: [srcInstance setIntValues:parameterArray
889: forParameter:EVSIORMS
890: count:EVSIORMS_SIZE];
891: }
892: [eventSrcListLock unlock];
893:
894: return self;
895: }
896:
897: - _resetKeyboardParameters
898: {
899: attachedEventSrc *device;
900: id srcInstance;
901: unsigned int parameterArray[EVSIORKBD_SIZE];
902:
903: // Go down the Event Src list looking for devices which respond to
904: // a EVSIORKBD message. Ping these.
905: [eventSrcListLock lock];
906: device = (attachedEventSrc *)queue_first(&eventSrcList);
907: while(!queue_end(&eventSrcList, (queue_t)device))
908: {
909: srcInstance = device->info.eventSrc;
910: device = (attachedEventSrc *)device->link.next;
911: [srcInstance setIntValues:parameterArray
912: forParameter:EVSIORKBD
913: count:EVSIORKBD_SIZE];
914: }
915: [eventSrcListLock unlock];
916: return self;
917: }
918:
919: /*
920: * Methods exported by the EventDriver.
921: *
922: * The screenRegister protocol is used by frame buffer drivers to register
923: * themselves with the Event Driver. These methods are called in response
924: * to a registerSelf or unregisterSelf message received from the Event
925: * Driver.
926: */
927: /* @protocol screenRegister */
928:
929: - (int) registerScreen: (id)instance
930: bounds:(Bounds *)bp
931: shmem:(void **)addr
932: size:(int *)size
933: {
934: EvScreen *esp;
935:
936: if ( eventsOpen == NO )
937: {
938: *addr = (void *)0;
939: *size = 0;
940: return -1;
941: }
942: if ( lastShmemPtr == (void *)0 )
943: lastShmemPtr = evs;
944:
945: /* shmemSize and bounds already set */
946: esp = &((EvScreen*)evScreen)[screens];
947: esp->instance = instance;
948: /* If this driver wants private shmem, then set its shmemPtr */
949: if (esp->shmemSize)
950: esp->shmemPtr = lastShmemPtr;
951: lastShmemPtr += esp->shmemSize;
952: /* Fill in parameters for the requesting instance */
953: *addr = esp->shmemPtr;
954: *size = esp->shmemSize;
955: bcopy( (char *)&esp->bounds, (char *)bp, sizeof (Bounds) );
956: return(SCREENTOKEN + screens++);
957: }
958:
959:
960: - (void) unregisterScreen:(int)index
961: {
962: int i;
963:
964: index -= SCREENTOKEN;
965:
966: [driverLock lock];
967: if ( eventsOpen == NO || index < 0 || index >= screens )
968: {
969: [driverLock unlock];
970: return;
971: }
972: [self hideCursor];
973: // clear the state for the screen
974: ((EvScreen*)evScreen)[index].instance = nil;
975: // Put the cursor someplace reasonable if it was on the destroyed screen
976: if ( currentScreen == index ) // Uh oh...
977: {
978: for ( i = screens; --i != -1; ) // Pick a new currentScreen
979: {
980: if ( ((EvScreen*)evScreen)[i].instance != nil )
981: {
982: currentScreen = i;
983: break;
984: }
985: }
986: // This will jump the cursor back on screen
987: [self setCursorPosition:(Point *)&((EvGlobals*)evg)->cursorLoc];
988: }
989: else
990: [self showCursor];
991: [driverLock unlock];
992: return;
993: }
994:
995: /* @end screenRegister */
996:
997: /* Private methods specific to this driver */
998:
999: #if KERNEL
1000: //
1001: // Allocate a private array of EvScreen structures based on the screen count
1002: // passed in by PostScript and copy in each screen's bounds and shmemSize.
1003: // Also calculate the total size of shared memory and return it to PostScript.
1004: // PostScript will later call mapEventShmem to map in the page(s) at which
1005: // point the ev driver will fill out the EvOffsets structure partly
1006: // based on each driver's shmemSize. NOTE: Can't access evg pointer yet!
1007: //
1008:
1009: - (IOReturn)evSetScreen:(unsigned int *)parameterArray
1010: {
1011: int i = parameterArray[EVIOSETSCREEN_INDEX];
1012: EvScreen * screen;
1013:
1014: if ( evOpenCalled == NO ) // Try to screen out cruft...
1015: return IO_R_PRIVILEGE;
1016:
1017: if (!evScreen) {
1018: /* if first time through, allocate screen array */
1019: evScreenSize = sizeof(EvScreen)
1020: * parameterArray[EVIOSETSCREEN_TOTALSCREENS];
1021: evScreen = (void *) IOMalloc(evScreenSize);
1022: bzero(evScreen, evScreenSize);
1023: /* The following initial shmem size can change in the kernel if
1024: * more space is required. This lets the kernel shmem structure
1025: * expand if needed without breaking PostScript.
1026: */
1027: shmem_size = sizeof(EvGlobals) + sizeof(EvOffsets);
1028: // Set up screen registration variables
1029: lastShmemPtr = (void *)0;
1030: screens = 0;
1031: workSpace.minx = workSpace.miny = workSpace.maxx = workSpace.maxy = 0;
1032: }
1033: if ( i < 0 || i >= (evScreenSize / sizeof(EvScreen)) ) // Sanity check
1034: return IO_R_INVALID_ARG;
1035: screen = &((EvScreen*)evScreen)[i];
1036: screen->bounds.minx = parameterArray[EVIOSETSCREEN_MINX];
1037: screen->bounds.maxx = parameterArray[EVIOSETSCREEN_MAXX];
1038: screen->bounds.miny = parameterArray[EVIOSETSCREEN_MINY];
1039: screen->bounds.maxy = parameterArray[EVIOSETSCREEN_MAXY];
1040: screen->shmemSize = parameterArray[EVIOSETSCREEN_SHMEMSIZE];
1041: shmem_size += parameterArray[EVIOSETSCREEN_SHMEMSIZE];
1042: // Update our idea of workSpace bounds
1043: if ( screen->bounds.minx < workSpace.minx )
1044: workSpace.minx = screen->bounds.minx;
1045: if ( screen->bounds.miny < workSpace.miny )
1046: workSpace.miny = screen->bounds.miny;
1047: if ( screen->bounds.maxx < workSpace.maxx )
1048: workSpace.maxx = screen->bounds.maxx;
1049: if ( screen->bounds.maxy < workSpace.maxy )
1050: workSpace.maxy = screen->bounds.maxy;
1051: return IO_R_SUCCESS;
1052: }
1053:
1054: /* Member of EventClient protocol
1055: *
1056: * Absolute position input devices and some specialized output devices
1057: * may need to know the bounding rectangle for all attached displays.
1058: * The following method returns a Bounds* for the workspace. Please note
1059: * that the bounds are kept as signed values, and that on a multi-display
1060: * system the minx and miny values may very well be negative.
1061: */
1062: - (Bounds *)workspaceBounds
1063: {
1064: return &workSpace;
1065: }
1066:
1067: /*
1068: * Set up the shared memory area between the Window Server and the kernel.
1069: *
1070: * Obtain page aligned wired kernel memory for 'size' bytes using
1071: * kmem_alloc().
1072: * Find a similar sized region in the Window Server task VM map using
1073: * vm_map_find(). This function will find an appropriately sized region,
1074: * create a memory object, and insert it in the VM map.
1075: * For each physical page in the kernel's wired memory we got from
1076: * kmem_alloc(), enter that page at the appropriate location in the page
1077: * map for the Window Server, in the address range we allocated using
1078: * vm_map_find().
1079: */
1080: - (IOReturn) mapEventShmem : (port_t) event_port
1081: task : (port_t)task // in
1082: size : (vm_size_t)size // in
1083: at : (vm_offset_t *)addr // out
1084: {
1085: vm_offset_t off;
1086: vm_offset_t phys_addr;
1087: IOReturn krtn;
1088: void * task_map;
1089: vm_offset_t task_addr;
1090:
1091: if ( event_port != eventPort || evOpenCalled == NO )
1092: return IO_R_PRIVILEGE;
1093: if ( task == PORT_NULL || size == 0 ) // malformed request
1094: return IO_R_INVALID_ARG;
1095: if ( owner_task != PORT_NULL || owner != NULL )
1096: return IO_R_INVALID_ARG; // Mapping set up already
1097:
1098: krtn = createEventShmem(task,size,&task_map,&task_addr,&shmem_addr);
1099: if ( krtn != KERN_SUCCESS )
1100: {
1101: IOLog("%s: createEventShmem fails (%d).\n",[self name],krtn);
1102: return krtn;
1103: }
1104:
1105: [driverLock lock];
1106: shmem_size = size;
1107: owner_task = task;
1108: owner_addr = task_addr;
1109: *addr = task_addr;
1110: owner = task_map;
1111: [self initShmem];
1112: [driverLock unlock];
1113:
1114: [self _resetMouseParameters];
1115: [self _resetKeyboardParameters];
1116: // Start the cursor control callouts
1117: [driverLock lock];
1118: [self scheduleNextPeriodicEvent];
1119: [driverLock unlock];
1120:
1121: return IO_R_SUCCESS;
1122: }
1123:
1124: //
1125: // Unmap the shared memory area and release the wired memory.
1126: //
1127: - (IOReturn) unmapEventShmem : (port_t)event_port;
1128: {
1129: vm_offset_t off;
1130: IOReturn r;
1131:
1132: // Since the shared memory area is being torn down, set eventsOpen
1133: // to NO to keep the cursor thread from futzing with the shared area.
1134: // We need to implement a lock to guard the shmem, and acquire the
1135: // lock before tearing the area down.
1136: xpr_ev_shmemlock("unmapEventShmem: will lock %x\n",
1137: driverLock, 3, 4, 5, 6);
1138: [driverLock lock];
1139: xpr_ev_shmemlock("unmapEventShmem: did lock %x\n",
1140: driverLock, 3, 4, 5, 6);
1141:
1142: if (event_port != eventPort || evOpenCalled == NO || eventsOpen == NO)
1143: {
1144: [driverLock unlock];
1145: return IO_R_PRIVILEGE;
1146: }
1147: eventsOpen = NO;
1148:
1149: r=destroyEventShmem(owner_task,owner,shmem_size,owner_addr,shmem_addr);
1150: if ( r != KERN_SUCCESS )
1151: {
1152: IOLog("%s: destroyEventShmem fails (%d).\n", [self name], r);
1153: }
1154: shmem_addr = owner_addr = (vm_offset_t)0;
1155: shmem_size = 0;
1156: owner = NULL;
1157: owner_task = PORT_NULL;
1158: [driverLock unlock];
1159: xpr_ev_shmemlock("unmapEventShmem: did unlock %x\n",
1160: driverLock, 3, 4, 5, 6);
1161: return r;
1162: }
1163: #endif
1164:
1165: // Initialize the shared memory area.
1166: //
1167: // On entry, the driverLock should be set.
1168: - initShmem
1169: {
1170: int i;
1171: EvOffsets *eop;
1172: EvGlobals *glob;
1173:
1174: pointerLoc.x = INIT_CURSOR_X;
1175: pointerLoc.y = INIT_CURSOR_Y;
1176:
1177: /* top of sharedMem is EvOffsets structure */
1178: eop = (EvOffsets *) shmem_addr;
1179:
1180: /* fill in EvOffsets structure */
1181: eop->evGlobalsOffset = sizeof(EvOffsets);
1182: eop->evShmemOffset = eop->evGlobalsOffset + sizeof(EvGlobals);
1183:
1184: /* find pointers to start of globals and private shmem region */
1185: glob = (EvGlobals *) ((char *)shmem_addr + eop->evGlobalsOffset);
1186: evs = (void *)((char *)shmem_addr + eop->evShmemOffset);
1187:
1188: /* Set default wait cursor parameters */
1189: glob->waitCursorEnabled = TRUE;
1190: glob->globalWaitCursorEnabled = TRUE;
1191: glob->waitThreshold = EV_NS_TO_TICK(DefaultWCThreshold);
1192: waitFrameRate = DefaultWCFrameRate;
1193: waitSustain = DefaultWCSustain;
1194: waitSusTime = 0ULL;
1195: waitFrameTime = 0ULL;
1196:
1197: /* Set up low-level queues */
1198: lleqSize = LLEQSIZE;
1199: for (i=lleqSize; --i != -1; ) {
1200: glob->lleq[i].event.type = 0;
1201: glob->lleq[i].event.time = 0;
1202: glob->lleq[i].event.flags = 0;
1203: ev_init_lock(&glob->lleq[i].sema);
1204: glob->lleq[i].next = i+1;
1205: }
1206: glob->LLELast = 0;
1207: glob->lleq[lleqSize-1].next = 0;
1208: glob->LLEHead =
1209: glob->lleq[glob->LLELast].next;
1210: glob->LLETail =
1211: glob->lleq[glob->LLELast].next;
1212: glob->buttons = 0;
1213: glob->eNum = INITEVENTNUM;
1214: glob->eventFlags = 0;
1215: glob->VertRetraceClock = EvTickTimeValue();
1216: glob->cursorLoc = pointerLoc;
1217: glob->dontCoalesce = 0;
1218: glob->dontWantCoalesce = 0;
1219: glob->wantPressure = 0;
1220: glob->wantPrecision = 0;
1221: glob->mouseRectValid = 0;
1222: glob->movedMask = 0;
1223: ev_init_lock( &glob->cursorSema );
1224: ev_init_lock( &glob->waitCursorSema );
1225: evg = (void *)glob;
1226: // Set eventsOpen last to avoid race conditions.
1227: eventsOpen = YES;
1228:
1229: return self;
1230: }
1231:
1232: //
1233: // Set the event port. The event port is both an ownership token
1234: // and a live port we hold send rights on. The port is owned by our client,
1235: // the WindowServer. We arrange to be notified on a port death so that
1236: // we can tear down any active resources set up during this session.
1237: // An argument of PORT_NULL will cause us to forget any port death
1238: // notification that's set up.
1239: //
1240: // The driverLock should be held on entry.
1241: //
1242: - setEventPort:(port_t)port
1243: {
1244: static struct _eventMsg init_msg =
1245: { { 0, 1, sizeof(msg_header_t)+sizeof(msg_type_t),
1246: MSG_TYPE_NORMAL, (port_t)0, (port_t)0, 0 },
1247: { MSG_TYPE_UNSTRUCTURED, 0, 0, 1, 0, 0 } };
1248: if ( port == PORT_NULL )
1249: {
1250: event_kern_port = (port_t)KERN_PORT_NULL;
1251: }
1252: else if ( port != eventPort ) // Set up a new notification
1253: {
1254: event_kern_port = IOGetKernPort(port);
1255: port_request_notification((kern_port_t)event_kern_port,
1256: (kern_port_t)notify_kern_port);
1257: }
1258: if ( eventMsg == NULL )
1259: eventMsg = IOMalloc( sizeof (struct _eventMsg) );
1260: eventPort = port;
1261: // Initialize the events available message.
1262: *((struct _eventMsg *)eventMsg) = init_msg;
1263:
1264: ((struct _eventMsg *)eventMsg)->h.msg_remote_port = port;
1265: return self;
1266: }
1267:
1268: //
1269: // Set the port to be used for a special key notification. This could be more
1270: // robust about letting ports be set...
1271: //
1272: - (IOReturn) setSpecialKeyPort : (port_t)dev_port
1273: keyFlavor : (int)special_key
1274: keyPort : (port_t)key_port
1275: {
1276: if ( dev_port != ev_port )
1277: return IO_R_PRIVILEGE;
1278:
1279: if ( special_key >= 0 && special_key < NX_NUM_SCANNED_SPECIALKEYS )
1280: specialKeyPort[special_key] = key_port;
1281: return IO_R_SUCCESS;
1282: }
1283:
1284: - (port_t)specialKeyPort: (int)special_key
1285: {
1286: if ( special_key >= 0 && special_key < NX_NUM_SCANNED_SPECIALKEYS )
1287: return specialKeyPort[special_key];
1288: return PORT_NULL;
1289: }
1290:
1291: // Return ports used for Mach interface
1292: - (port_t)ev_port
1293: {
1294: return ev_port;
1295: }
1296:
1297: - (port_t)evs_port
1298: {
1299: return evs_port;
1300: }
1301:
1302: //
1303: // Dispatch mechanism for special key press. If a port has been registered,
1304: // a message is built to be sent out to that port notifying that the key has
1305: // changed state. A level in the range 0-64 is provided for convenience.
1306: //
1307: - evSpecialKeyMsg: (unsigned)key
1308: direction:(unsigned)dir
1309: flags:(unsigned)f
1310: level:(unsigned)l
1311: {
1312: port_t dst_port;
1313: struct evioSpecialKeyMsg *msg;
1314: static const struct evioSpecialKeyMsg init_msg =
1315: { { 0, 1, sizeof (struct evioSpecialKeyMsg),
1316: MSG_TYPE_NORMAL, (port_t)0, (port_t)0,
1317: EV_SPECIAL_KEY_MSG_ID },
1318: { MSG_TYPE_INTEGER_32, 32, 1, TRUE, FALSE, FALSE },
1319: 0, /* key */
1320: { MSG_TYPE_INTEGER_32, 32, 1, TRUE, FALSE, FALSE },
1321: 0, /* direction */
1322: { MSG_TYPE_INTEGER_32, 32, 1, TRUE, FALSE, FALSE },
1323: 0, /* flags */
1324: { MSG_TYPE_INTEGER_32, 32, 1, TRUE, FALSE, FALSE },
1325: 0 /* level */
1326: };
1327:
1328: if ( (dst_port = [self specialKeyPort:key]) == PORT_NULL )
1329: return self;
1330: msg = (struct evioSpecialKeyMsg *) IOMalloc(
1331: sizeof (struct evioSpecialKeyMsg) );
1332: if ( msg == NULL )
1333: return self;
1334:
1335: // Initialize the message.
1336: bcopy( &init_msg, msg, sizeof (struct evioSpecialKeyMsg) );
1337: msg->Head.msg_remote_port = dst_port;
1338: msg->key = key;
1339: msg->direction = dir;
1340: msg->flags = f;
1341: msg->level = l;
1342:
1343: // Send the message out from the I/O thread.
1344: [self sendIOThreadAsyncMsg :@selector(_performSpecialKeyMsg:)
1345: to :self
1346: with :(void *)msg];
1347:
1348: return self;
1349: }
1350:
1351: /*
1352: * This is run in the I/O thread, to perform the actual message send operation.
1353: */
1354: - _performSpecialKeyMsg:(id)data
1355: {
1356: kern_return_t r;
1357: struct evioSpecialKeyMsg *msg;
1358:
1359: msg = (struct evioSpecialKeyMsg *)data;
1360: xpr_ev_post("_performSpecialKeyMsg 0x%x\n", msg,2,3,4,5);
1361:
1362: r = msg_send( &msg->Head, SEND_TIMEOUT, 0 ); /* Don't block */
1363: xpr_ev_post("_performSpecialKeyMsg: msg_send() == %d\n",
1364: r,2,3,4,5);
1365: if ( r != SEND_SUCCESS )
1366: {
1367: IOLog("%s: _performSpecialKeyMsg msg_send returned %d\n",
1368: [self name], r);
1369: }
1370: if ( r == SEND_INVALID_PORT ) /* Invalidate the port */
1371: {
1372: [self setSpecialKeyPort : ev_port
1373: keyFlavor : msg->key
1374: keyPort : PORT_NULL];
1375: }
1376: IOFree( (void *)msg, sizeof (struct evioSpecialKeyMsg) );
1377: return self;
1378: }
1379:
1380: //
1381: // Dispatch state to screens registered with the Event Driver
1382: // Pending state changes for a device may be coalesced.
1383: //
1384: //
1385: // On entry, the driverLock should be set.
1386: //
1387: - evDispatch:(int)screen command:(EvCmd)evcmd
1388: {
1389: Point p;
1390: EvScreen *esp = &((EvScreen*)evScreen)[screen];
1391:
1392: if ( eventsOpen == NO )
1393: return self;
1394:
1395: p = ((EvGlobals*)evg)->cursorLoc; // Copy from shmem.
1396: if ( esp->instance != nil )
1397: {
1398: switch ( evcmd )
1399: {
1400: case EVMOVE:
1401: [esp->instance moveCursor:&p
1402: frame:((EvGlobals*)evg)->frame
1403: token:(screen + SCREENTOKEN)];
1404: break;
1405:
1406: case EVSHOW:
1407: [esp->instance showCursor:&p
1408: frame:((EvGlobals*)evg)->frame
1409: token:(screen + SCREENTOKEN)];
1410: break;
1411:
1412: case EVHIDE:
1413: [esp->instance hideCursor:(screen + SCREENTOKEN)];
1414: break;
1415:
1416: case EVLEVEL:
1417: [esp->instance setBrightness:[self currentBrightness]
1418: token:(screen + SCREENTOKEN)];
1419: }
1420: }
1421: return self;
1422: }
1423:
1424: //
1425: // Helper functions for postEvent
1426: //
1427: static inline int myAbs(int a) { return(a > 0 ? a : -a); }
1428:
1429: static inline short UniqueEventNum(EventDriver * instance)
1430: {
1431: EvGlobals *evg = (EvGlobals *)instance->evg;
1432: while (++evg->eNum == NULLEVENTNUM)
1433: ; /* sic */
1434: return(evg->eNum);
1435: }
1436:
1437: // postEvent
1438: //
1439: // This routine actually places events in the event queue which is in
1440: // the EvGlobals structure. It is called from all parts of the ev
1441: // driver.
1442: //
1443: // On entry, the driverLock should be set.
1444: //
1445:
1446: - postEvent:(int)what
1447: at:(Point *)location
1448: atTime:(unsigned)theClock
1449: withData:(NXEventData *)myData
1450: {
1451: EvGlobals *glob = (EvGlobals *)evg;
1452: NXEQElement *theHead = (NXEQElement *) &glob->lleq[glob->LLEHead];
1453: NXEQElement *theLast = (NXEQElement *) &glob->lleq[glob->LLELast];
1454: NXEQElement *theTail = (NXEQElement *) &glob->lleq[glob->LLETail];
1455: int wereEvents;
1456:
1457: /* Some events affect screen dimming */
1458: if (EventCodeMask(what) & NX_UNDIMMASK) {
1459: autoDimTime = theClock + autoDimPeriod;
1460: if (autoDimmed)
1461: [self undoAutoDim];
1462: }
1463: // Update the PS VertRetraceClock off of the timestamp if it looks sane
1464: if ( theClock > glob->VertRetraceClock
1465: && theClock < (glob->VertRetraceClock + (20 * EV_TICK_TIME)) )
1466: glob->VertRetraceClock = theClock;
1467:
1468: wereEvents = EventsInQueue();
1469:
1470: xpr_ev_post("postEvent: what %d, X %d Y %d Q %d, needKick %d\n",
1471: what,location->x,location->y,
1472: EventsInQueue(), needToKickEventConsumer);
1473:
1474: if ((!glob->dontCoalesce) /* Coalescing enabled */
1475: && (theHead != theTail)
1476: && (theLast->event.type == what)
1477: && (EventCodeMask(what) & COALESCEEVENTMASK)
1478: && ev_try_lock(&theLast->sema)) {
1479: /* coalesce events */
1480: theLast->event.location.x = location->x;
1481: theLast->event.location.y = location->y;
1482: theLast->event.time = theClock;
1483: if (myData != NULL)
1484: theLast->event.data = *myData;
1485: ev_unlock(&theLast->sema);
1486: } else if (theTail->next != glob->LLEHead) {
1487: /* store event in tail */
1488: theTail->event.type = what;
1489: theTail->event.location.x = location->x;
1490: theTail->event.location.y = location->y;
1491: theTail->event.flags = glob->eventFlags;
1492: theTail->event.time = theClock;
1493: theTail->event.window = 0;
1494: if (myData != NULL)
1495: theTail->event.data = *myData;
1496: switch(what) {
1497: case NX_LMOUSEDOWN:
1498: theTail->event.data.mouse.eventNum =
1499: leftENum = UniqueEventNum(self);
1500: break;
1501: case NX_RMOUSEDOWN:
1502: theTail->event.data.mouse.eventNum =
1503: rightENum = UniqueEventNum(self);
1504: break;
1505: case NX_LMOUSEUP:
1506: theTail->event.data.mouse.eventNum = leftENum;
1507: leftENum = NULLEVENTNUM;
1508: break;
1509: case NX_RMOUSEUP:
1510: theTail->event.data.mouse.eventNum = rightENum;
1511: rightENum = NULLEVENTNUM;
1512: break;
1513: }
1514: if (EventCodeMask(what) & PRESSUREEVENTMASK) {
1515: theTail->event.data.mouse.pressure = lastPressure;
1516: }
1517: if (EventCodeMask(what) & MOUSEEVENTMASK) { /* Click state */
1518: if (((theClock - clickTime) <= clickTimeThresh)
1519: && (myAbs(location->x - clickLoc.x) <= clickSpaceThresh.x)
1520: && (myAbs(location->y - clickLoc.y) <= clickSpaceThresh.y)) {
1521: theTail->event.data.mouse.click =
1522: ((what == NX_LMOUSEDOWN)||(what == NX_RMOUSEDOWN)) ?
1523: (clickTime=theClock,++clickState) : clickState ;
1524: } else if ((what == NX_LMOUSEDOWN)||(what == NX_RMOUSEDOWN)) {
1525: clickLoc = *location;
1526: clickTime = theClock;
1527: clickState = 1;
1528: theTail->event.data.mouse.click = clickState;
1529: } else
1530: theTail->event.data.mouse.click = 0;
1531: }
1532: #if PMON
1533: pmon_log_event(PMON_SOURCE_EV,
1534: KP_EV_POST_EVENT,
1535: what,
1536: glob->eventFlags,
1537: theClock);
1538: #endif
1539: glob->LLETail = theTail->next;
1540: glob->LLELast = theLast->next;
1541: if ( ! wereEvents ) // Events available, so wake event consumer
1542: [self kickEventConsumer];
1543: }
1544: else
1545: {
1546: /*
1547: * if queue is full, ignore event, too hard to take care of all cases
1548: */
1549: IOLog("%s: postEvent LLEventQueue overflow.\n", [self name]);
1550: [self kickEventConsumer];
1551: #if PMON
1552: pmon_log_event( PMON_SOURCE_EV,
1553: KP_EV_QUEUE_FULL,
1554: what,
1555: glob->eventFlags,
1556: theClock);
1557: #endif
1558: }
1559: }
1560:
1561: /*
1562: * - kickEventConsumer
1563: *
1564: * Try to send a message out to let the event consumer know that
1565: * there are now events available for consumption.
1566: */
1567: - kickEventConsumer
1568: {
1569: [kickConsumerLock lock];
1570: xpr_ev_post("kickEventConsumer (need == %d)\n",
1571: needToKickEventConsumer,2,3,4,5);
1572: if ( needToKickEventConsumer == YES )
1573: {
1574: [kickConsumerLock unlock];
1575: return self; // Request is already pending
1576: }
1577: needToKickEventConsumer = YES; // Posting a request now
1578: [kickConsumerLock unlock];
1579: [self sendIOThreadAsyncMsg :@selector(_performKickEventConsumer:)
1580: to :self
1581: with :(void *)0];
1582:
1583: return self;
1584: }
1585:
1586: /*
1587: * This is run in the I/O thread, to perform the actual message send operation.
1588: * Note that we perform a non-blocking send. The Event port in the event
1589: * consumer has a queue depth of 1 message. Once the consumer picks up that
1590: * message, it runs until the event queue is exhausted before trying to read
1591: * another message. If a message is pending,there is no need to enqueue a
1592: * second one. This also keeps us from blocking the I/O thread in a msg_send
1593: * which could result in a deadlock if the consumer were to make a call into
1594: * the event driver.
1595: */
1596: - _performKickEventConsumer:(id)data
1597: {
1598: kern_return_t r;
1599:
1600: xpr_ev_post("_performKickEventConsumer\n", 1,2,3,4,5);
1601: [kickConsumerLock lock];
1602: needToKickEventConsumer = NO; // Request received and processed
1603: [kickConsumerLock unlock];
1604:
1605: r = msg_send( (msg_header_t *)eventMsg, SEND_TIMEOUT, 0 );
1606: xpr_ev_post("_performKickEventConsumer: msg_send() == %d\n",
1607: r,2,3,4,5);
1608: switch ( r )
1609: {
1610: case SEND_TIMED_OUT: /* Already has a message posted */
1611: case SEND_SUCCESS: /* Message is posted */
1612: break;
1613: default: /* Log the error */
1614: IOLog("%s: _performKickEventConsumer msg_send returned %d\n",
1615: [self name], r);
1616: break;
1617: }
1618: return self;
1619: }
1620:
1621: /*
1622: * Event sources may need to use an I/O thread from time to time.
1623: * Rather than have each instance running it's own thread, we provide
1624: * a callback mechanism to let all the instances share a common Event I/O
1625: * thread running in the IOTask space, and managed by the Event Driver.
1626: * Returns self, or nil on error.
1627: */
1628: - (IOReturn)sendIOThreadMsg: (SEL)selector // Selector to call back on
1629: to : (id)instance // Instance to call back
1630: with : (id)data; // Data to pass back
1631: {
1632: evIoOpParams params;
1633:
1634: params.callback.instance = instance;
1635: params.callback.selector = selector;
1636: params.callback.data = data;
1637:
1638: return [self _threadOpCommon : EVENT_LISTENER_CALLBACK
1639: opParams : (void *)¶ms
1640: async : NO];
1641: }
1642:
1643: - sendIOThreadAsyncMsg: (SEL)selector // Selector to call back on
1644: to : (id)instance // Instance to call back
1645: with : (id)data; // Data to pass back
1646: {
1647: evIoOpParams params;
1648:
1649: params.callback.instance = instance;
1650: params.callback.selector = selector;
1651: params.callback.data = data;
1652:
1653: [self _threadOpCommon : EVENT_LISTENER_CALLBACK
1654: opParams : (void *)¶ms
1655: async : YES];
1656: return self;
1657: }
1658:
1659: /*
1660: * This routine is run within the I/O thread, on demand from the
1661: * sendIOThreadMsg::: methods above. We attempt to dispatch a message
1662: * to the specified selector and instance.
1663: */
1664: - (IOReturn) _doPerformInIOThread:(void *)data
1665: {
1666: IOReturn ret;
1667: evCallback *msg = data;
1668: if ( [msg->instance respondsTo:msg->selector] )
1669: {
1670: [msg->instance perform:msg->selector with:msg->data];
1671: ret = IO_R_SUCCESS;
1672: }
1673: else
1674: {
1675: IOLog("%s: _doPerformInIOThread: [%s] does not respond to SEL [%s]\n",
1676: [self name],
1677: object_getClassName(msg->instance),
1678: sel_getName(msg->selector) );
1679: ret = IO_R_IPC_FAILURE;
1680: }
1681: return ret;
1682: }
1683:
1684: /*
1685: * Common thread dispatch code used to drive
1686: * I/O operations. The operation to be performed is encoded
1687: * in a Mach message, which we send to our I/O thread. This
1688: * thread then performs the requested operations, returning a
1689: * status
1690: */
1691: - (IOReturn)_threadOpCommon : (int)op
1692: opParams : (void *)data
1693: async : (BOOL)async
1694: {
1695: evIoOpParams * opParams = data;
1696: evIoOpMsg opMsg;
1697: kern_return_t krtn;
1698: IOReturn rtn;
1699: #ifdef KERNEL
1700: extern kern_port_t ev_port_list[];
1701: #endif
1702:
1703: xpr_ev_post("_threadOpCommon: op %d\n",op , 2,3,4,5);
1704:
1705: /*
1706: * First, an evIoOpMsg.
1707: */
1708: opMsg = opMsgTemplate;
1709: opMsg.header.msg_local_port = PORT_NULL;
1710:
1711: /*
1712: * Next, the evIoOpBuf.
1713: */
1714: opMsg.opBuf.op = op;
1715: if ( async == NO )
1716: {
1717: opMsg.opBuf.cmdLock = [NXConditionLock alloc];
1718: [opMsg.opBuf.cmdLock initWith:CMD_INPROGRESS];
1719: opMsg.opBuf.status = &rtn;
1720: rtn = IO_R_INVALID_ARG;
1721: }
1722: opMsg.opBuf.params = *opParams;
1723:
1724: /*
1725: * Go for it. Send the message to the I/O thread and wait for
1726: * I/O complete. We use msg_send_from_kernel becuase this is called
1727: * from exported methods; we could be in a user task.
1728: */
1729: #ifdef KERNEL
1730: opMsg.header.msg_remote_port = (port_t)ev_port_list[0];
1731: krtn = msg_send_from_kernel(&opMsg.header, MSG_OPTION_NONE, 0);
1732: #else KERNEL
1733: opMsg.header.msg_remote_port = ev_port;
1734: krtn = msg_send(&opMsg.header, MSG_OPTION_NONE, 0);
1735: #endif KERNEL
1736: if(krtn) {
1737: IOLog("%s: _threadOpCommon msg_send returned %d\n",
1738: [self name], krtn);
1739: rtn = IO_R_IPC_FAILURE;
1740: goto out;
1741: }
1742: if ( async == NO )
1743: {
1744: [opMsg.opBuf.cmdLock lockWhen:CMD_DONE]; // Wait for completion
1745: }
1746: else
1747: rtn = IO_R_SUCCESS;
1748: out:
1749: if ( async == NO )
1750: [opMsg.opBuf.cmdLock free];
1751: xpr_ev_post("_threadOpCommon: status %s\n",
1752: [self stringFromReturn:rtn], 2,3,4,5);
1753: return rtn;
1754: }
1755:
1756:
1757: /*
1758: * The following methods are executed from the I/O thread only.
1759: */
1760:
1761: /*
1762: * Service incoming client evIoOp.
1763: */
1764: - (void)_ioOpHandler : (void *)data
1765: {
1766: IOReturn ret;
1767: evIoOpBuf *opBuf = data;
1768:
1769: xpr_ev_post("_ioOpHandler: op %d\n",opBuf->op, 2,3,4,5);
1770:
1771: if ( opBuf->status != NULL )
1772: *opBuf->status = IO_R_SUCCESS;
1773: switch(opBuf->op) {
1774:
1775: case EVENT_LISTENER_PING:
1776: /*
1777: * This is just used for the init thread to know when we've
1778: * come this far.
1779: */
1780: break;
1781:
1782: case EVENT_LISTENER_EXIT:
1783: /*
1784: * First I/O complete this request, then terminate.
1785: */
1786: [opBuf->cmdLock unlockWith:CMD_DONE];
1787: IOExitThread();
1788:
1789: case EVENT_LISTENER_CALLBACK:
1790: ret = [self _doPerformInIOThread:&(opBuf->params.callback)];
1791: if ( opBuf->status != NULL )
1792: *opBuf->status = ret;
1793: break;
1794:
1795: default:
1796: IOPanic("EventDriver: Bogus opBuf.op");
1797: }
1798:
1799: /*
1800: * Release caller for synchronous operations.
1801: */
1802: if ( opBuf->cmdLock != nil )
1803: [opBuf->cmdLock unlockWith:CMD_DONE];
1804: }
1805:
1806: /*
1807: * Listen for and dispatch messages for the ev and evs clients
1808: * Messages received on these ports are used to control input devices, the
1809: * display, and the cursor.
1810: *
1811: * These ports replace the old /dev/ev0 and /dev/evs0 devices.
1812: * Programs which use the published event status driver API in
1813: * Release 3.0 will continue to work. Programs which directly manipulated
1814: * /dev/ev0 and /dev/evs0 are out of luck.
1815: *
1816: * Message buffers: The reply buffer is allocated when an RPC is generated,
1817: * and is freed after we have sent the reply out. While this may seem
1818: * expensive, we normally only have between 4 and 12 RPCs in a session, with
1819: * almost all occuring at WindowServer startup and login time. IOMalloc()
1820: * is fast enough to prevent any detectable delay. The design opts to reduce
1821: * wired memory at the cost of a few extra lines of code.
1822: */
1823: static volatile void EventListener(EventDriver *inst)
1824: {
1825: msg_header_t *in;
1826: int in_size;
1827: msg_header_t *out;
1828: int out_size;
1829: msg_return_t r;
1830: boolean_t result;
1831: boolean_t ok = TRUE;
1832: EvInMsg in_msg; // Big enough for most input
1833: extern boolean_t Event_server();
1834: extern boolean_t EventStatus_server();
1835:
1836: in_size = sizeof in_msg;
1837: in = &in_msg.hdr;
1838: out_size = 0;
1839: out = (msg_header_t *)NULL; // Dynamically alloc as needed
1840:
1841: while ( ok )
1842: {
1843: in->msg_local_port = inst->ev_port_set;
1844: in->msg_size = in_size;
1845:
1846: r = msg_receive( in, RCV_LARGE, 0 );
1847: switch( r )
1848: {
1849: case RCV_SUCCESS:
1850: break;
1851:
1852: case RCV_TOO_LARGE:
1853: /* If we already grew it, free grown buffer */
1854: if ( in_size > (sizeof in_msg) )
1855: IOFree( (void *)in, in_size );
1856: /* Get a new buffer of an appropriate size. */
1857: in_size = in->msg_size;
1858: in = (msg_header_t *)IOMalloc( in_size );
1859: xpr_ev_post(
1860: "EventListener: msg ID %d insize %d: 0x%x\n",
1861: in->msg_id, in_size,in,4,5);
1862: continue;
1863:
1864: case RCV_INVALID_PORT: /* Driver is being freed */
1865: ok = FALSE;
1866: continue;
1867:
1868: default:
1869: IOLog("%s: error on msg_receive (%d)\n",
1870: [inst name], r);
1871: continue;
1872: }
1873: xpr_ev_post("EventListener: msg ID %d size %d\n",
1874: in->msg_id, in->msg_size,3,4,5);
1875: /*
1876: * We have arranged for notification when the WindowServer
1877: * dies. The eventPort, owned by the WindowServer, has been
1878: * checked in for port death notification.
1879: * In the event of it's death, we assume that the WindowServer
1880: * has met an unfortunate fate, and invoke our device close
1881: * actions.
1882: */
1883: if ( in->msg_local_port == inst->notify_port )
1884: {
1885: notification_t *nmsg = (notification_t *)in;
1886:
1887: if ( nmsg->notify_port == inst->event_kern_port &&
1888: inst->event_kern_port!= (port_t)KERN_PORT_NULL )
1889: {
1890: [inst evClose:inst->ev_port token:inst->eventPort];
1891: #ifdef DEBUG
1892: IOLog("%s: client token invalidated\n", [inst name]);
1893: #endif
1894: }
1895: continue;
1896: }
1897: /*
1898: * We got a request. If it's on the privileged ev_port,
1899: * test the message to see if it's a control message for us.
1900: * If it's not a control message, try passing it to the
1901: * Event_server.
1902: */
1903: result = FALSE;
1904: switch( in->msg_id )
1905: {
1906: case EV_IO_OP_MSG_ID:
1907: if ( in->msg_local_port == inst->ev_port )
1908: {
1909: [inst _ioOpHandler:&((evIoOpMsg *)in)->opBuf];
1910: result = TRUE;
1911: }
1912: break;
1913:
1914: default:
1915: /* A real RPC needs a reply buffer. Make one. */
1916: if ( out == (msg_header_t *)NULL )
1917: {
1918: out_size = sizeof (EvOutMsg);
1919: out = (msg_header_t *)IOMalloc( out_size );
1920: xpr_ev_post(
1921: "EventListener: msg ID %d replysize %d: 0x%x\n",
1922: in->msg_id, out_size,out,4,5);
1923: }
1924: result = Event_server( in, out );
1925: break;
1926: }
1927:
1928: if ( result == FALSE )
1929: {
1930: IOLog("%s: invalid message ID %d\n",
1931: [inst name], in->msg_id );
1932: }
1933: else /* result == TRUE */
1934: {
1935: if(in->msg_remote_port!=PORT_NULL && out!=(msg_header_t*)NULL)
1936: {
1937: /*
1938: * We were passed a reply port. Set up and send a
1939: * reply message. If this fails, it's because of
1940: * a MiG error. No big deal. Just log it and try to go on.
1941: */
1942: if ( out->msg_size > out_size ) /* Mem smasher? panic? */
1943: IOLog("%s: reply msg overflow (%d > %d)\n",
1944: [inst name], out->msg_size, out_size);
1945: r = msg_send(out, MSG_OPTION_NONE, 0);
1946: xpr_ev_post("EventListener: msg ID %d reply stat %d\n",
1947: in->msg_id, r,3,4,5);
1948: if ( r != SEND_SUCCESS )
1949: IOLog("%s: error on msg_send (%d)\n",
1950: [inst name], r);
1951: }
1952: }
1953: /*
1954: * Done with messages. Free the reply buffer, and shrink the
1955: * input buffer as needed.
1956: */
1957: if ( out != (msg_header_t *)NULL )
1958: {
1959: IOFree( (void *)out, out_size );
1960: out = (msg_header_t *)NULL;
1961: out_size = 0;
1962: }
1963: if ( in_size > (sizeof in_msg) )
1964: {
1965: IOFree( (void *)in, in_size );
1966: in_size = sizeof in_msg;
1967: in = &in_msg.hdr;
1968: }
1969: }
1970:
1971: (volatile void) IOExitThread();
1972: }
1973:
1974: @end
1975:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.