IOHIDEventService.h [plain text]
#ifndef _IOKIT_HID_IOHIDEVENTSERVICE_H
#define _IOKIT_HID_IOHIDEVENTSERVICE_H
#include <TargetConditionals.h>
#include <IOKit/IOService.h>
#include <IOKit/IOWorkLoop.h>
#include <IOKit/IOTimerEventSource.h>
#include <IOKit/hidsystem/IOHIDTypes.h>
#include <IOKit/hid/IOHIDInterface.h>
#include <IOKit/hid/IOHIDElement.h>
#include <IOKit/hid/IOHIDKeys.h>
#if TARGET_OS_EMBEDDED
#include <IOKit/hid/IOHIDEvent.h>
#endif
enum
{
kHIDDispatchOptionPointerNoAcceleration = 0x01,
kHIDDispatchOptionPointerAffixToScreen = 0x02,
kHIDDispatchOptionPointerAbsolutToRelative = 0x04
};
enum
{
kHIDDispatchOptionScrollNoAcceleration = 0x001,
kHIDDispatchOptionScrollMomentumAny = 0x00e,
kHIDDispatchOptionScrollMomentumContinue = 0x002,
kHIDDispatchOptionScrollMomentumStart = 0x004,
kHIDDispatchOptionScrollMomentumEnd = 0x008,
kHIDDispatchOptionPhaseAny = 0xff0,
kHIDDispatchOptionPhaseBegan = 0x010,
kHIDDispatchOptionPhaseChanged = 0x020,
kHIDDispatchOptionPhaseEnded = 0x040,
kHIDDispatchOptionPhaseCanceled = 0x080,
kHIDDispatchOptionPhaseMayBegin = 0x800,
};
enum
{
kHIDDispatchOptionKeyboardNoRepeat = 0x01
};
class IOHIDPointing;
class IOHIDKeyboard;
class IOHIDConsumer;
struct TransducerData;
class IOHIDEventService: public IOService
{
OSDeclareAbstractStructors( IOHIDEventService )
friend class IOHIDPointing;
friend class IOHIDKeyboard;
friend class IOHIDConsumer;
friend class AppleEmbeddedKeyboard;
friend class IOHIDEventServiceUserClient;
private:
IOHIDKeyboard * _keyboardNub;
IOHIDPointing * _pointingNub;
IOHIDConsumer * _consumerNub;
IONotifier * _publishNotify;
IORecursiveLock * _nubLock;
OSArray * _transducerDataArray;
bool _readyForInputReports;
struct ExpansionData {
IOService * provider;
IOWorkLoop * workLoop;
OSArray * deviceUsagePairs;
IOCommandGate * commandGate;
#if TARGET_OS_EMBEDDED
OSDictionary * clientDict;
#endif
struct {
bool range;
bool touch;
SInt32 x;
SInt32 y;
SInt32 z;
} digitizer;
struct {
struct {
UInt32 delayMS;
IOTimerEventSource * timer;
UInt32 state;
IOOptionBits options;
} eject;
struct {
UInt32 delayMS;
IOTimerEventSource * timer;
UInt32 state;
IOOptionBits options;
} caps;
#if TARGET_OS_EMBEDDED
struct {
UInt32 startMask;
UInt32 mask;
IOTimerEventSource * timer;
} debug;
bool swapISO;
#endif
} keyboard;
struct {
IOFixed x;
IOFixed y;
IOFixed z;
IOFixed rX;
IOFixed rY;
IOFixed rZ;
UInt32 buttonState;
IOOptionBits options;
IOTimerEventSource * timer;
} multiAxis;
};
ExpansionData * _reserved;
IOHIDPointing * newPointingShim (
UInt32 buttonCount = 1,
IOFixed pointerResolution = (400 << 16),
IOFixed scrollResolution = 0,
IOOptionBits options = 0 );
IOHIDKeyboard * newKeyboardShim (
UInt32 supportedModifiers = 0,
IOOptionBits options = 0 );
IOHIDConsumer * newConsumerShim ( IOOptionBits options = 0 );
void parseSupportedElements (
OSArray * elementArray,
UInt32 bootProtocol );
void processTabletElement ( IOHIDElement * element );
void processTransducerData ();
TransducerData * createTransducerData ( UInt32 transducerID );
TransducerData * getTransducerData ( UInt32 transducerID );
IOFixed determineResolution ( IOHIDElement * element );
static bool _publishMatchingNotificationHandler(void * target, void * ref, IOService * newService, IONotifier * notifier);
void ejectTimerCallback(IOTimerEventSource *sender);
void capsTimerCallback(IOTimerEventSource *sender);
#if TARGET_OS_EMBEDDED
void debuggerTimerCallback(IOTimerEventSource *sender);
#endif
void multiAxisTimerCallback(IOTimerEventSource *sender);
void calculateCapsLockDelay();
void calculateStandardType();
protected:
virtual void free();
virtual bool handleOpen(IOService * client,
IOOptionBits options,
void * argument);
virtual void handleClose(IOService * client, IOOptionBits options);
virtual bool handleIsOpen(const IOService * client) const;
virtual bool handleStart( IOService * provider );
virtual void handleStop( IOService * provider );
virtual OSString * getTransport ();
virtual UInt32 getLocationID ();
virtual UInt32 getVendorID ();
virtual UInt32 getVendorIDSource ();
virtual UInt32 getProductID ();
virtual UInt32 getVersion ();
virtual UInt32 getCountryCode ();
virtual OSString * getManufacturer ();
virtual OSString * getProduct ();
virtual OSString * getSerialNumber ();
virtual OSArray * getReportElements();
virtual void setElementValue (
UInt32 usagePage,
UInt32 usage,
UInt32 value );
virtual UInt32 getElementValue (
UInt32 usagePage,
UInt32 usage );
virtual void dispatchKeyboardEvent(
AbsoluteTime timeStamp,
UInt32 usagePage,
UInt32 usage,
UInt32 value,
IOOptionBits options = 0 );
virtual void dispatchRelativePointerEvent(
AbsoluteTime timeStamp,
SInt32 dx,
SInt32 dy,
UInt32 buttonState,
IOOptionBits options = 0 );
virtual void dispatchAbsolutePointerEvent(
AbsoluteTime timeStamp,
SInt32 x,
SInt32 y,
IOGBounds * bounds,
UInt32 buttonState,
bool inRange,
SInt32 tipPressure,
SInt32 tipPressureMin,
SInt32 tipPressureMax,
IOOptionBits options = 0 );
virtual void dispatchScrollWheelEvent(
AbsoluteTime timeStamp,
SInt32 deltaAxis1,
SInt32 deltaAxis2,
SInt32 deltaAxis3,
IOOptionBits options = 0 );
virtual void dispatchTabletPointerEvent(
AbsoluteTime timeStamp,
UInt32 transducerID,
SInt32 x,
SInt32 y,
SInt32 z,
IOGBounds * bounds,
UInt32 buttonState,
SInt32 tipPressure,
SInt32 tipPressureMin,
SInt32 tipPressureMax,
SInt32 barrelPressure,
SInt32 barrelPressureMin,
SInt32 barrelPressureMax,
SInt32 tiltX,
SInt32 tiltY,
UInt32 twist,
IOOptionBits options = 0 );
virtual void dispatchTabletProximityEvent(
AbsoluteTime timeStamp,
UInt32 transducerID,
bool inRange,
bool invert,
UInt32 vendorTransducerUniqueID = 0,
UInt32 vendorTransducerSerialNumber = 0,
IOOptionBits options = 0 );
public:
bool readyForReports();
virtual bool init(OSDictionary * properties = 0);
virtual bool start( IOService * provider );
virtual void stop( IOService * provider );
virtual bool matchPropertyTable(OSDictionary * table, SInt32 * score);
virtual IOReturn setSystemProperties( OSDictionary * properties );
virtual IOReturn setProperties( OSObject * properties );
protected:
OSMetaClassDeclareReservedUsed(IOHIDEventService, 0);
virtual OSArray * getDeviceUsagePairs();
OSMetaClassDeclareReservedUsed(IOHIDEventService, 1);
virtual UInt32 getReportInterval();
OSMetaClassDeclareReservedUsed(IOHIDEventService, 2);
enum {
kMultiAxisOptionRotationForTranslation = (1<<0),
kMultiAxisOptionZForScroll = (1<<1)
};
virtual void dispatchMultiAxisPointerEvent(
AbsoluteTime timeStamp,
UInt32 buttonState,
IOFixed x,
IOFixed y,
IOFixed z,
IOFixed rX = 0,
IOFixed rY = 0,
IOFixed rZ = 0,
IOOptionBits options = 0 );
enum {
kDigitizerInvert = (1<<0)
};
enum {
kDigitizerTransducerTypeStylus = 0,
kDigitizerTransducerTypePuck,
kDigitizerTransducerTypeFinger,
kDigitizerTransducerTypeHand
};
typedef UInt32 DigitizerTransducerType;
OSMetaClassDeclareReservedUsed(IOHIDEventService, 3);
virtual void dispatchDigitizerEvent(
AbsoluteTime timeStamp,
UInt32 transducerID,
DigitizerTransducerType type,
bool inRange,
UInt32 buttonState,
IOFixed x,
IOFixed y,
IOFixed z = 0,
IOFixed tipPressure = 0,
IOFixed auxPressure = 0,
IOFixed twist = 0,
IOOptionBits options = 0 );
OSMetaClassDeclareReservedUsed(IOHIDEventService, 4);
virtual void dispatchDigitizerEventWithTiltOrientation(
AbsoluteTime timeStamp,
UInt32 ID,
DigitizerTransducerType type,
bool inRange,
UInt32 buttonState,
IOFixed x,
IOFixed y,
IOFixed z = 0,
IOFixed tipPressure = 0, IOFixed auxPressure = 0, IOFixed twist = 0,
IOFixed tiltX = 0,
IOFixed tiltY = 0,
IOOptionBits options = 0 );
OSMetaClassDeclareReservedUsed(IOHIDEventService, 5);
virtual void dispatchDigitizerEventWithPolarOrientation(
AbsoluteTime timeStamp,
UInt32 transducerID,
DigitizerTransducerType type,
bool inRange,
UInt32 buttonState,
IOFixed x,
IOFixed y,
IOFixed z = 0,
IOFixed tipPressure = 0, IOFixed tanPressure = 0, IOFixed twist = 0,
IOFixed altitude = 0,
IOFixed azimuth = 0,
IOOptionBits options = 0 );
private:
enum {
kDigitizerOrientationTypeTilt = 0,
kDigitizerOrientationTypePolar,
kDigitizerOrientationTypeQuality
};
typedef UInt32 DigitizerOrientationType;
void dispatchDigitizerEventWithOrientation(
AbsoluteTime timeStamp,
UInt32 transducerID,
DigitizerTransducerType type,
bool inRange,
UInt32 buttonState,
IOFixed x,
IOFixed y,
IOFixed z = 0,
IOFixed tipPressure = 0,
IOFixed auxPressure = 0,
IOFixed twist = 0,
DigitizerOrientationType orientationType = kDigitizerOrientationTypeTilt,
IOFixed * orientationParams = NULL,
UInt32 orientationParamCount = 0,
IOOptionBits options = 0 );
#if TARGET_OS_EMBEDDED
public:
typedef void (*Action)(OSObject *target, OSObject * sender, void *context, OSObject *event, IOOptionBits options);
OSMetaClassDeclareReservedUsed(IOHIDEventService, 6);
virtual bool open(
IOService * client,
IOOptionBits options,
void * context,
Action action);
protected:
OSMetaClassDeclareReservedUsed(IOHIDEventService, 7);
virtual void dispatchEvent(IOHIDEvent * event, IOOptionBits options=0);
OSMetaClassDeclareReservedUsed(IOHIDEventService, 8);
virtual UInt32 getPrimaryUsagePage();
OSMetaClassDeclareReservedUsed(IOHIDEventService, 9);
virtual UInt32 getPrimaryUsage();
public:
OSMetaClassDeclareReservedUsed(IOHIDEventService, 10);
virtual IOHIDEvent * copyEvent(
IOHIDEventType type,
IOHIDEvent * matching = 0,
IOOptionBits options = 0);
protected:
#else
OSMetaClassDeclareReservedUnused(IOHIDEventService, 6);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 7);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 8);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 9);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 10);
#endif
OSMetaClassDeclareReservedUnused(IOHIDEventService, 11);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 12);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 13);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 14);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 15);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 16);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 17);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 18);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 19);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 20);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 21);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 22);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 23);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 24);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 25);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 26);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 27);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 28);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 29);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 30);
OSMetaClassDeclareReservedUnused(IOHIDEventService, 31);
#if TARGET_OS_EMBEDDED
public:
virtual void close( IOService * forClient, IOOptionBits options = 0 );
private:
bool openGated( IOService *client, IOOptionBits options, void *context, Action action);
void closeGated( IOService * forClient, IOOptionBits options = 0 );
#endif
};
#endif