[apple/xnu.git] / iokit / IOKit / hidsystem / IOHIKeyboard.h

/*
 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/* 	Copyright (c) 1992 NeXT Computer, Inc.  All rights reserved. 
 *
 * EventSrcPCKeyboard.h - PC Keyboard EventSrc subclass definition
 *
 * HISTORY
 * 28 Aug 1992    Joe Pasqua
 *      Created. 
 */

#ifndef _IOHIKEYBOARD_H
#define _IOHIKEYBOARD_H

#include <IOKit/hidsystem/IOHIDevice.h>
#include <IOKit/hidsystem/IOHIKeyboardMapper.h>

/* Start Action Definitions */

/*
 * HISTORICAL NOTE:
 *   The following entry points were part of the IOHIKeyboardEvents
 *   protocol.
 */

typedef void (*KeyboardEventAction)(       OSObject * target,
                    /* eventFlags  */      unsigned   eventType,
                    /* flags */            unsigned   flags,
                    /* keyCode */          unsigned   key,
                    /* charCode */         unsigned   charCode,
                    /* charSet */          unsigned   charSet,
                    /* originalCharCode */ unsigned   origCharCode,
                    /* originalCharSet */  unsigned   origCharSet,
                    /* keyboardType */     unsigned   keyboardType,
                    /* repeat */           bool       repeat,
                    /* atTime */           AbsoluteTime ts);

typedef void (*KeyboardSpecialEventAction)(OSObject * target,
                    /* eventType */        unsigned   eventType,
                    /* flags */            unsigned   flags,
                    /* keyCode */          unsigned   key,
                    /* specialty */        unsigned   flavor,
                    /* source id */        UInt64     guid,
                    /* repeat */           bool       repeat,
                    /* atTime */           AbsoluteTime ts);

typedef void (*UpdateEventFlagsAction)(    OSObject * target,
                     /* flags */           unsigned   flags);

/* End Action Definitions */


/* Default key repeat parameters */
#define EV_DEFAULTINITIALREPEAT 500000000ULL    // 1/2 sec in nanoseconds
#define EV_DEFAULTKEYREPEAT     83333333ULL     // 1/12 sec in nanoseconds
#define EV_MINKEYREPEAT         16700000ULL     // 1/60 sec

class IOHIKeyboard : public IOHIDevice
{
  OSDeclareDefaultStructors(IOHIKeyboard);

protected:
    IOLock *	         _deviceLock;	// Lock for all device access
    IOHIKeyboardMapper * _keyMap;	// KeyMap instance

    // The following fields describe the kind of keyboard
    UInt32		_interfaceType;
    UInt32		_deviceType;

    // The following fields describe the state of the keyboard
    UInt32 *	_keyState;		// kbdBitVector
    IOByteCount _keyStateSize;		// kbdBitVector allocated size
    unsigned	_eventFlags;		// Current eventFlags
    bool	_alphaLock;		// true means alpha lock is on
    bool	_numLock;		// true means num lock is on
    bool	_charKeyActive;		// true means char gen. key active

    // The following fields are used in performing key repeats
    bool 	_isRepeat;		// true means we're generating repeat
    unsigned	_codeToRepeat;		// What we are repeating
    bool	_calloutPending;	// true means we've sched. a callout
    AbsoluteTime	_lastEventTime;		// Time last event was dispatched
    AbsoluteTime	_downRepeatTime;	// Time when we should next repeat
    AbsoluteTime	_keyRepeat;		// Delay between key repeats
    AbsoluteTime	_initialKeyRepeat;	// Delay before initial key repeat
    UInt64		_guid;

    OSObject *                 _keyboardEventTarget;
    KeyboardEventAction        _keyboardEventAction;
    OSObject *                 _keyboardSpecialEventTarget;
    KeyboardSpecialEventAction _keyboardSpecialEventAction;
    OSObject *                 _updateEventFlagsTarget;
    UpdateEventFlagsAction     _updateEventFlagsAction;

protected:
  virtual void dispatchKeyboardEvent(unsigned int keyCode,
		     /* direction */ bool         goingDown,
		     /* timeStamp */ AbsoluteTime time);

public:
  virtual bool init(OSDictionary * properties = 0);
  virtual bool start(IOService * provider);
  virtual void free();

  virtual bool open(IOService *                client,
		    IOOptionBits	       options,
                    KeyboardEventAction        keAction,
                    KeyboardSpecialEventAction kseAction,
                    UpdateEventFlagsAction     uefAction);
  virtual void close(IOService * client, IOOptionBits );

  virtual IOHIDKind hidKind();
  virtual bool 	    updateProperties( void );
  virtual IOReturn  setParamProperties(OSDictionary * dict);

protected: // for subclasses to implement
  virtual const unsigned char * defaultKeymapOfLength(UInt32 * length);
  virtual void setAlphaLockFeedback(bool val);
  virtual void setNumLockFeedback(bool val);
  virtual UInt32 maxKeyCodes();


private:
  virtual bool resetKeyboard();
  virtual void scheduleAutoRepeat();
  static void _autoRepeat(void * arg, void *);
  virtual void autoRepeat();
  virtual void setRepeat(unsigned eventType, unsigned keyCode);

/*
 * HISTORICAL NOTE:
 *   The following methods were part of the KeyMapDelegate protocol;
 *   the declarations have now been merged directly into this class.
 */

public:
  virtual void keyboardEvent(unsigned eventType,
      /* flags */            unsigned flags,
      /* keyCode */          unsigned keyCode,
      /* charCode */         unsigned charCode,
      /* charSet */          unsigned charSet,
      /* originalCharCode */ unsigned origCharCode,
      /* originalCharSet */  unsigned origCharSet);

  virtual void keyboardSpecialEvent(unsigned eventType,
		    /* flags */     unsigned flags,
		    /* keyCode */   unsigned keyCode,
		    /* specialty */ unsigned flavor);

  virtual void updateEventFlags(unsigned flags); // Does not generate events

  virtual unsigned eventFlags();           // Global event flags
  virtual unsigned deviceFlags();          // per-device event flags
  virtual void setDeviceFlags(unsigned flags); // Set device event flags
  virtual bool alphaLock();                // current alpha-lock state
  virtual void setAlphaLock(bool val);     // Set current alpha-lock state
  virtual bool numLock();                
  virtual void setNumLock(bool val);     
  virtual bool charKeyActive();            // Is a character gen. key down?
  virtual void setCharKeyActive(bool val); // Note that a char gen key is down.
  virtual bool doesKeyLock(unsigned key);  //does key lock physically
  virtual unsigned getLEDStatus();  //check hardware for LED status


};

#endif /* !_IOHIKEYBOARD_H */
Commit	Line	Data
1c79356b A	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	/* Copyright (c) 1992 NeXT Computer, Inc. All rights reserved.
	23	*
	24	* EventSrcPCKeyboard.h - PC Keyboard EventSrc subclass definition
	25	*
	26	* HISTORY
	27	* 28 Aug 1992 Joe Pasqua
	28	* Created.
	29	*/
	30
	31	#ifndef _IOHIKEYBOARD_H
	32	#define _IOHIKEYBOARD_H
	33
	34	#include <IOKit/hidsystem/IOHIDevice.h>
	35	#include <IOKit/hidsystem/IOHIKeyboardMapper.h>
	36
	37	/* Start Action Definitions */
	38
	39	/*
	40	* HISTORICAL NOTE:
	41	* The following entry points were part of the IOHIKeyboardEvents
	42	* protocol.
	43	*/
	44
	45	typedef void (KeyboardEventAction)( OSObject target,
	46	/* eventFlags */ unsigned eventType,
	47	/* flags */ unsigned flags,
	48	/* keyCode */ unsigned key,
	49	/* charCode */ unsigned charCode,
	50	/* charSet */ unsigned charSet,
	51	/* originalCharCode */ unsigned origCharCode,
	52	/* originalCharSet */ unsigned origCharSet,
	53	/* keyboardType */ unsigned keyboardType,
	54	/* repeat */ bool repeat,
	55	/* atTime */ AbsoluteTime ts);
	56
	57	typedef void (KeyboardSpecialEventAction)(OSObject target,
	58	/* eventType */ unsigned eventType,
	59	/* flags */ unsigned flags,
	60	/* keyCode */ unsigned key,
	61	/* specialty */ unsigned flavor,
	62	/* source id */ UInt64 guid,
	63	/* repeat */ bool repeat,
	64	/* atTime */ AbsoluteTime ts);
65
66	typedef void (UpdateEventFlagsAction)( OSObject target,
67	/* flags */ unsigned flags);
68
69	/* End Action Definitions */
70
71
72
73	/* Default key repeat parameters */
74	#define EV_DEFAULTINITIALREPEAT 500000000ULL // 1/2 sec in nanoseconds
75	#define EV_DEFAULTKEYREPEAT 83333333ULL // 1/12 sec in nanoseconds
76	#define EV_MINKEYREPEAT 16700000ULL // 1/60 sec
77
78	class IOHIKeyboard : public IOHIDevice
79	{
80	OSDeclareDefaultStructors(IOHIKeyboard);
81
82	protected:
83	IOLock * _deviceLock; // Lock for all device access
84	IOHIKeyboardMapper * _keyMap; // KeyMap instance
85
86	// The following fields describe the kind of keyboard
87	UInt32 _interfaceType;
88	UInt32 _deviceType;
89
90	// The following fields describe the state of the keyboard
91	UInt32 * _keyState; // kbdBitVector
92	IOByteCount _keyStateSize; // kbdBitVector allocated size
93	unsigned _eventFlags; // Current eventFlags
94	bool _alphaLock; // true means alpha lock is on
95	bool _numLock; // true means num lock is on
96	bool _charKeyActive; // true means char gen. key active
97
98	// The following fields are used in performing key repeats
99	bool _isRepeat; // true means we're generating repeat
100	unsigned _codeToRepeat; // What we are repeating
101	bool _calloutPending; // true means we've sched. a callout
102	AbsoluteTime _lastEventTime; // Time last event was dispatched
103	AbsoluteTime _downRepeatTime; // Time when we should next repeat
104	AbsoluteTime _keyRepeat; // Delay between key repeats
105	AbsoluteTime _initialKeyRepeat; // Delay before initial key repeat
106	UInt64 _guid;
107
108	OSObject * _keyboardEventTarget;
109	KeyboardEventAction _keyboardEventAction;
110	OSObject * _keyboardSpecialEventTarget;
111	KeyboardSpecialEventAction _keyboardSpecialEventAction;
112	OSObject * _updateEventFlagsTarget;
113	UpdateEventFlagsAction _updateEventFlagsAction;
114
115	protected:
116	virtual void dispatchKeyboardEvent(unsigned int keyCode,
117	/* direction */ bool goingDown,
118	/* timeStamp */ AbsoluteTime time);
119
120	public:
121	virtual bool init(OSDictionary * properties = 0);
122	virtual bool start(IOService * provider);
123	virtual void free();
124
125	virtual bool open(IOService * client,
126	IOOptionBits options,
127	KeyboardEventAction keAction,
128	KeyboardSpecialEventAction kseAction,
129	UpdateEventFlagsAction uefAction);
130	virtual void close(IOService * client, IOOptionBits );
131
132	virtual IOHIDKind hidKind();
133	virtual bool updateProperties( void );
134	virtual IOReturn setParamProperties(OSDictionary * dict);
135
136	protected: // for subclasses to implement
137	virtual const unsigned char * defaultKeymapOfLength(UInt32 * length);
138	virtual void setAlphaLockFeedback(bool val);
139	virtual void setNumLockFeedback(bool val);
140	virtual UInt32 maxKeyCodes();
141
142
143	private:
144	virtual bool resetKeyboard();
145	virtual void scheduleAutoRepeat();
146	static void _autoRepeat(void * arg, void *);
147	virtual void autoRepeat();
148	virtual void setRepeat(unsigned eventType, unsigned keyCode);
149
150	/*
151	* HISTORICAL NOTE:
152	* The following methods were part of the KeyMapDelegate protocol;
153	* the declarations have now been merged directly into this class.
154	*/
155
156	public:
157	virtual void keyboardEvent(unsigned eventType,
158	/* flags */ unsigned flags,
159	/* keyCode */ unsigned keyCode,
160	/* charCode */ unsigned charCode,
161	/* charSet */ unsigned charSet,
162	/* originalCharCode */ unsigned origCharCode,
163	/* originalCharSet */ unsigned origCharSet);
164
165	virtual void keyboardSpecialEvent(unsigned eventType,
166	/* flags */ unsigned flags,
167	/* keyCode */ unsigned keyCode,
168	/* specialty */ unsigned flavor);
169
170	virtual void updateEventFlags(unsigned flags); // Does not generate events
171
172	virtual unsigned eventFlags(); // Global event flags
173	virtual unsigned deviceFlags(); // per-device event flags
174	virtual void setDeviceFlags(unsigned flags); // Set device event flags
175	virtual bool alphaLock(); // current alpha-lock state
176	virtual void setAlphaLock(bool val); // Set current alpha-lock state
177	virtual bool numLock();
178	virtual void setNumLock(bool val);
179	virtual bool charKeyActive(); // Is a character gen. key down?
180	virtual void setCharKeyActive(bool val); // Note that a char gen key is down.
181	virtual bool doesKeyLock(unsigned key); //does key lock physically
182	virtual unsigned getLEDStatus(); //check hardware for LED status
183
184
185	};
186
187	#endif /* !_IOHIKEYBOARD_H */