[apple/xnu.git] / iokit / IOKit / ndrvsupport / IONDRVFramebuffer.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) 1997-1998 Apple Computer, Inc.
 *
 *
 * HISTORY
 *
 * sdouglas  22 Oct 97 - first checked in.
 * sdouglas  24 Jul 98 - start IOKit.
 * sdouglas  15 Dec 98 - cpp.
 *
 */

#ifndef _IOKIT_IONDRVFRAMEBUFFER_H
#define _IOKIT_IONDRVFRAMEBUFFER_H

#include <IOKit/graphics/IOFramebuffer.h>
#include <IOKit/ndrvsupport/IOMacOSVideo.h>
#include <IOKit/ndrvsupport/IONDRVSupport.h>


#define kIONDRVDisableKey	"AAPL,disable-ndrv"


class IONDRVFramebuffer : public IOFramebuffer
{
    OSDeclareDefaultStructors(IONDRVFramebuffer)

protected:
/*! @struct ExpansionData
    @discussion This structure will be used to expand the capablilties of this class in the future.
    */    
    struct ExpansionData { };

/*! @var reserved
    Reserved for future use.  (Internal use only)  */
    ExpansionData * reserved;

protected:

    IOService *			nub;
    class IONDRV *		ndrv;

    // current configuration
    IODisplayModeID		currentDisplayMode;
    IOIndex			currentDepth;
    IOIndex			currentPage;
    bool			directMode;

    IOPhysicalAddress		physicalFramebuffer;
    IODeviceMemory	*	vramRange;

    UInt8			startAt8;
    UInt8			grayMode;
    UInt8			lastGrayMode;
    VDClutBehavior		lastClutSetting;
    UInt8			platformDeepSleep;

    bool			consoleDevice;
    UInt32			powerState;
    UInt32			ndrvState;
    SInt32			ndrvEnter;
    OSArray *			detailedTimings;
    UInt32			detailedTimingsSeed;
    UInt32 *			detailedTimingsCurrent;

    IODeviceMemory *		vramMemory;

    VDResolutionInfoRec		cachedVDResolution;

    struct _VSLService *	vslServices;

    UInt32			accessFlags;
    UInt8			shouldDoI2CPower;

    UInt8			__reservedB[3];
    UInt32			__reservedA[31];

private:
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 0);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 1);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 2);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 3);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 4);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 5);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 6);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 7);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 8);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 9);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 10);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 11);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 12);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 13);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 14);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 15);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 16);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 17);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 18);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 19);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 20);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 21);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 22);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 23);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 24);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 25);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 26);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 27);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 28);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 29);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 30);
    OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 31);

private:

    void initForPM ( void );
    IOReturn setPowerState( unsigned long, IOService* );
    unsigned long maxCapabilityForDomainState( IOPMPowerFlags );
    unsigned long initialPowerStateForDomainState( IOPMPowerFlags );
    unsigned long powerStateForDomainState( IOPMPowerFlags );

    virtual IOReturn checkDriver( void );
    virtual UInt32 iterateAllModes( IODisplayModeID * displayModeIDs );
    virtual IOReturn getResInfoForMode( IODisplayModeID modeID,
                                    IODisplayModeInformation * theInfo );
    virtual IOReturn getResInfoForArbMode( IODisplayModeID modeID,
                                    IODisplayModeInformation * theInfo );
    virtual IOReturn validateDisplayMode(
            IODisplayModeID mode, IOOptionBits flags,
            VDDetailedTimingRec ** detailed );
    virtual IOReturn setDetailedTiming(
            IODisplayModeID mode, IOOptionBits options,
            void * description, IOByteCount descripSize );
    virtual void getCurrentConfiguration( void );
    static const IOTVector * _undefinedSymbolHandler( void * self, 
                            const char * libraryName, const char * symbolName );
    void displayI2CPower( bool enable );
    static bool _videoJackStateChangeHandler( void * target, void * ref,
                                                IOService * resourceService );

public:
    virtual IOReturn doControl( UInt32 code, void * params );
    virtual IOReturn doStatus( UInt32 code, void * params );

public:

    virtual IOService * probe(	IOService * 	provider,
				SInt32 *	score );

    virtual bool start( IOService * provider );

    virtual void free( void );

    virtual IOReturn setProperties( OSObject * properties );

    virtual IOReturn enableController( void );

    virtual IODeviceMemory * makeSubRange( IOPhysicalAddress start,
                                           IOPhysicalLength length );
    virtual IODeviceMemory * getApertureRange( IOPixelAperture aperture );
    virtual IODeviceMemory * getVRAMRange( void );

    virtual IODeviceMemory * findVRAM( void );

    virtual bool isConsoleDevice( void );

    virtual const IOTVector * undefinedSymbolHandler( const char * libraryName,
                                                      const char * symbolName );

    virtual const char * getPixelFormats( void );

    // Array of supported display modes
    virtual IOItemCount getDisplayModeCount( void );
    virtual IOReturn getDisplayModes( IODisplayModeID * allDisplayModes );

    // Info about a display mode
    virtual IOReturn getInformationForDisplayMode( IODisplayModeID displayMode,
                    IODisplayModeInformation * info );

    // Mask of pixel formats available in mode and depth
    virtual UInt64  getPixelFormatsForDisplayMode( IODisplayModeID displayMode,
                    IOIndex depth );

    virtual IOReturn getPixelInformation(
	IODisplayModeID displayMode, IOIndex depth,
	IOPixelAperture aperture, IOPixelInformation * pixelInfo );

    // Framebuffer info

    // Current display mode and depth
    virtual IOReturn getCurrentDisplayMode( IODisplayModeID * displayMode,
                            IOIndex * depth );

    // Set display mode and depth
    virtual IOReturn setDisplayMode( IODisplayModeID displayMode,
                            IOIndex depth );

    // For pages
    virtual IOReturn setApertureEnable( IOPixelAperture aperture,
		    IOOptionBits enable );

    virtual IOReturn setStartupDisplayMode( IODisplayModeID displayMode,
                            IOIndex depth );
    virtual IOReturn getStartupDisplayMode( IODisplayModeID * displayMode,
                            IOIndex * depth );

    //// CLUTs

    virtual IOReturn setCLUTWithEntries( IOColorEntry * colors, UInt32 index,
                UInt32 numEntries, IOOptionBits options );

    //// Gamma

    virtual IOReturn setGammaTable( UInt32 channelCount, UInt32 dataCount,
                    UInt32 dataWidth, void * data );

    //// Display mode timing information

    virtual IOReturn getTimingInfoForDisplayMode( IODisplayModeID displayMode,
                IOTimingInformation * info );

    //// Detailed timing information

    virtual IOReturn validateDetailedTiming(
                    void * description, IOByteCount descripSize );

    virtual IOReturn setDetailedTimings( OSArray * array );

    //// Controller attributes

    virtual IOReturn getAttribute( IOSelect attribute, UInt32 * value );

    //// Connections

    virtual IOItemCount getConnectionCount( void );

    virtual IOReturn getAttributeForConnection( IOIndex connectIndex,
                    IOSelect attribute, UInt32  * value );
    
    virtual IOReturn setAttributeForConnection( IOIndex connectIndex,
                    IOSelect attribute, UInt32  info );

    // Apple sensing

    virtual IOReturn getAppleSense( IOIndex connectIndex,
            UInt32 * senseType,
            UInt32 * primary,
            UInt32 * extended,
            UInt32 * displayType );

    virtual IOReturn connectFlags( IOIndex connectIndex,
                    IODisplayModeID displayMode, IOOptionBits * flags );

    //// IOHighLevelDDCSense

    virtual bool hasDDCConnect( IOIndex connectIndex );
    virtual IOReturn getDDCBlock( IOIndex connectIndex, UInt32 blockNumber,
                    IOSelect blockType, IOOptionBits options,
                    UInt8 * data, IOByteCount * length );

    //// Interrupts

    virtual IOReturn registerForInterruptType( IOSelect interruptType,
            	        IOFBInterruptProc proc, OSObject * target, void * ref,
			void ** interruptRef );
    virtual IOReturn unregisterInterrupt( void * interruptRef );
    virtual IOReturn setInterruptState( void * interruptRef, UInt32 state );

    //// HW Cursors

    virtual IOReturn setCursorImage( void * cursorImage );
    virtual IOReturn setCursorState( SInt32 x, SInt32 y, bool visible );

    //// VSL calls

    static OSStatus VSLNewInterruptService(
                            void * entryID,
                            UInt32 serviceType,
                            _VSLService ** serviceID );
    static OSStatus VSLDisposeInterruptService( _VSLService * serviceID );
    static OSStatus VSLDoInterruptService( _VSLService * serviceID );
    static Boolean  VSLPrepareCursorForHardwareCursor(
                            void * cursorRef,
                            IOHardwareCursorDescriptor * hwDesc,
                            IOHardwareCursorInfo * hwCursorInfo );
};

#endif /* ! _IOKIT_IONDRVFRAMEBUFFER_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	/*
	23	* Copyright (c) 1997-1998 Apple Computer, Inc.
	24	*
	25	*
	26	* HISTORY
	27	*
	28	* sdouglas 22 Oct 97 - first checked in.
	29	* sdouglas 24 Jul 98 - start IOKit.
	30	* sdouglas 15 Dec 98 - cpp.
	31	*
	32	*/
	33
	34	#ifndef _IOKIT_IONDRVFRAMEBUFFER_H
	35	#define _IOKIT_IONDRVFRAMEBUFFER_H
	36
	37	#include <IOKit/graphics/IOFramebuffer.h>
	38	#include <IOKit/ndrvsupport/IOMacOSVideo.h>
	39	#include <IOKit/ndrvsupport/IONDRVSupport.h>
	40
	41
	42	#define kIONDRVDisableKey "AAPL,disable-ndrv"
	43
	44
	45	class IONDRVFramebuffer : public IOFramebuffer
	46	{
	47	OSDeclareDefaultStructors(IONDRVFramebuffer)
	48
	49	protected:
	50	/*! @struct ExpansionData
	51	@discussion This structure will be used to expand the capablilties of this class in the future.
	52	*/
	53	struct ExpansionData { };
	54
	55	/*! @var reserved
	56	Reserved for future use. (Internal use only) */
	57	ExpansionData * reserved;
	58
	59	protected:
	60
	61	IOService * nub;
	62	class IONDRV * ndrv;
	63
	64	// current configuration
65	IODisplayModeID currentDisplayMode;
66	IOIndex currentDepth;
67	IOIndex currentPage;
68	bool directMode;
69
70	IOPhysicalAddress physicalFramebuffer;
71	IODeviceMemory * vramRange;
72
73	UInt8 startAt8;
74	UInt8 grayMode;
75	UInt8 lastGrayMode;
76	VDClutBehavior lastClutSetting;
77	UInt8 platformDeepSleep;
78
79	bool consoleDevice;
80	UInt32 powerState;
81	UInt32 ndrvState;
82	SInt32 ndrvEnter;
83	OSArray * detailedTimings;
84	UInt32 detailedTimingsSeed;
85	UInt32 * detailedTimingsCurrent;
86
87	IODeviceMemory * vramMemory;
88
89	VDResolutionInfoRec cachedVDResolution;
90
91	struct _VSLService * vslServices;
92
93	UInt32 accessFlags;
150bd074	94	UInt8 shouldDoI2CPower;
1c79356b	95
150bd074 A	96	UInt8 __reservedB[3];
150bd074 A	97	UInt32 __reservedA[31];
1c79356b A	98
	99	private:
	100	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 0);
	101	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 1);
	102	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 2);
	103	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 3);
	104	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 4);
	105	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 5);
	106	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 6);
	107	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 7);
	108	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 8);
	109	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 9);
	110	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 10);
	111	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 11);
	112	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 12);
	113	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 13);
	114	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 14);
	115	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 15);
	116	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 16);
	117	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 17);
	118	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 18);
	119	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 19);
	120	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 20);
	121	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 21);
	122	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 22);
	123	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 23);
	124	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 24);
	125	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 25);
	126	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 26);
	127	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 27);
	128	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 28);
	129	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 29);
	130	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 30);
	131	OSMetaClassDeclareReservedUnused(IONDRVFramebuffer, 31);
	132
	133	private:
	134
	135	void initForPM ( void );
	136	IOReturn setPowerState( unsigned long, IOService* );
	137	unsigned long maxCapabilityForDomainState( IOPMPowerFlags );
	138	unsigned long initialPowerStateForDomainState( IOPMPowerFlags );
	139	unsigned long powerStateForDomainState( IOPMPowerFlags );
	140
	141	virtual IOReturn checkDriver( void );
	142	virtual UInt32 iterateAllModes( IODisplayModeID * displayModeIDs );
	143	virtual IOReturn getResInfoForMode( IODisplayModeID modeID,
	144	IODisplayModeInformation * theInfo );
	145	virtual IOReturn getResInfoForArbMode( IODisplayModeID modeID,
	146	IODisplayModeInformation * theInfo );
	147	virtual IOReturn validateDisplayMode(
	148	IODisplayModeID mode, IOOptionBits flags,
	149	VDDetailedTimingRec ** detailed );
	150	virtual IOReturn setDetailedTiming(
	151	IODisplayModeID mode, IOOptionBits options,
	152	void * description, IOByteCount descripSize );
	153	virtual void getCurrentConfiguration( void );
	154	static const IOTVector * _undefinedSymbolHandler( void * self,
	155	const char * libraryName, const char * symbolName );
150bd074	156	void displayI2CPower( bool enable );
e7c99d92 A	157	static bool _videoJackStateChangeHandler( void * target, void * ref,
e7c99d92 A	158	IOService * resourceService );
1c79356b A	159
	160	public:
	161	virtual IOReturn doControl( UInt32 code, void * params );
	162	virtual IOReturn doStatus( UInt32 code, void * params );
	163
	164	public:
	165
	166	virtual IOService * probe( IOService * provider,
	167	SInt32 * score );
	168
	169	virtual bool start( IOService * provider );
	170
	171	virtual void free( void );
	172
	173	virtual IOReturn setProperties( OSObject * properties );
	174
	175	virtual IOReturn enableController( void );
	176
	177	virtual IODeviceMemory * makeSubRange( IOPhysicalAddress start,
	178	IOPhysicalLength length );
	179	virtual IODeviceMemory * getApertureRange( IOPixelAperture aperture );
	180	virtual IODeviceMemory * getVRAMRange( void );
	181
	182	virtual IODeviceMemory * findVRAM( void );
	183
	184	virtual bool isConsoleDevice( void );
	185
	186	virtual const IOTVector * undefinedSymbolHandler( const char * libraryName,
	187	const char * symbolName );
	188
	189	virtual const char * getPixelFormats( void );
	190
	191	// Array of supported display modes
	192	virtual IOItemCount getDisplayModeCount( void );
	193	virtual IOReturn getDisplayModes( IODisplayModeID * allDisplayModes );
	194
	195	// Info about a display mode
	196	virtual IOReturn getInformationForDisplayMode( IODisplayModeID displayMode,
	197	IODisplayModeInformation * info );
	198
	199	// Mask of pixel formats available in mode and depth
	200	virtual UInt64 getPixelFormatsForDisplayMode( IODisplayModeID displayMode,
	201	IOIndex depth );
	202
	203	virtual IOReturn getPixelInformation(
	204	IODisplayModeID displayMode, IOIndex depth,
	205	IOPixelAperture aperture, IOPixelInformation * pixelInfo );
	206
	207	// Framebuffer info
	208
	209	// Current display mode and depth
	210	virtual IOReturn getCurrentDisplayMode( IODisplayModeID * displayMode,
	211	IOIndex * depth );
	212
	213	// Set display mode and depth
	214	virtual IOReturn setDisplayMode( IODisplayModeID displayMode,
	215	IOIndex depth );
	216
	217	// For pages
	218	virtual IOReturn setApertureEnable( IOPixelAperture aperture,
	219	IOOptionBits enable );
	220
	221	virtual IOReturn setStartupDisplayMode( IODisplayModeID displayMode,
	222	IOIndex depth );
223	virtual IOReturn getStartupDisplayMode( IODisplayModeID * displayMode,
224	IOIndex * depth );
225
226	//// CLUTs
227
228	virtual IOReturn setCLUTWithEntries( IOColorEntry * colors, UInt32 index,
229	UInt32 numEntries, IOOptionBits options );
230
231	//// Gamma
232
233	virtual IOReturn setGammaTable( UInt32 channelCount, UInt32 dataCount,
234	UInt32 dataWidth, void * data );
235
236	//// Display mode timing information
237
238	virtual IOReturn getTimingInfoForDisplayMode( IODisplayModeID displayMode,
239	IOTimingInformation * info );
240
241	//// Detailed timing information
242
243	virtual IOReturn validateDetailedTiming(
244	void * description, IOByteCount descripSize );
245
246	virtual IOReturn setDetailedTimings( OSArray * array );
247
248	//// Controller attributes
249
250	virtual IOReturn getAttribute( IOSelect attribute, UInt32 * value );
251
252	//// Connections
253
254	virtual IOItemCount getConnectionCount( void );
255
256	virtual IOReturn getAttributeForConnection( IOIndex connectIndex,
257	IOSelect attribute, UInt32 * value );
258
259	virtual IOReturn setAttributeForConnection( IOIndex connectIndex,
260	IOSelect attribute, UInt32 info );
261
262	// Apple sensing
263
264	virtual IOReturn getAppleSense( IOIndex connectIndex,
265	UInt32 * senseType,
266	UInt32 * primary,
267	UInt32 * extended,
268	UInt32 * displayType );
269
270	virtual IOReturn connectFlags( IOIndex connectIndex,
271	IODisplayModeID displayMode, IOOptionBits * flags );
272
273	//// IOHighLevelDDCSense
274
275	virtual bool hasDDCConnect( IOIndex connectIndex );
276	virtual IOReturn getDDCBlock( IOIndex connectIndex, UInt32 blockNumber,
277	IOSelect blockType, IOOptionBits options,
278	UInt8 * data, IOByteCount * length );
279
280	//// Interrupts
281
282	virtual IOReturn registerForInterruptType( IOSelect interruptType,
283	IOFBInterruptProc proc, OSObject * target, void * ref,
284	void ** interruptRef );
285	virtual IOReturn unregisterInterrupt( void * interruptRef );
286	virtual IOReturn setInterruptState( void * interruptRef, UInt32 state );
287
288	//// HW Cursors
289
290	virtual IOReturn setCursorImage( void * cursorImage );
291	virtual IOReturn setCursorState( SInt32 x, SInt32 y, bool visible );
292
293	//// VSL calls
294
295	static OSStatus VSLNewInterruptService(
296	void * entryID,
297	UInt32 serviceType,
298	_VSLService ** serviceID );
299	static OSStatus VSLDisposeInterruptService( _VSLService * serviceID );
300	static OSStatus VSLDoInterruptService( _VSLService * serviceID );
301	static Boolean VSLPrepareCursorForHardwareCursor(
302	void * cursorRef,
303	IOHardwareCursorDescriptor * hwDesc,
304	IOHardwareCursorInfo * hwCursorInfo );
305	};
306
307	#endif /* ! _IOKIT_IONDRVFRAMEBUFFER_H */
308
309