[apple/xnu.git] / iokit / IOKit / pci / IOPCIBridge.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) 1998-2000 Apple Computer, Inc.  All rights reserved. 
 *
 * HISTORY
 *
 */


#ifndef _IOKIT_IOPCIBRIDGE_H
#define _IOKIT_IOPCIBRIDGE_H

#include <IOKit/IOService.h>
#include <IOKit/IODeviceMemory.h>
#include <IOKit/pci/IOAGPDevice.h>


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

class IOPCIBridge : public IOService
{
    friend IOPCIDevice;

    OSDeclareAbstractStructors(IOPCIBridge)

private:
    IORegistryEntry * findMatching( OSIterator * in, IOPCIAddressSpace space );
    void publishNubs( OSIterator * kids, UInt32 index );
    virtual bool isDTNub( IOPCIDevice * nub );
    static void nvLocation( IORegistryEntry * entry,
	UInt8 * busNum, UInt8 * deviceNum, UInt8 * functionNum );

protected:
    IORangeAllocator *	bridgeMemoryRanges;
    IORangeAllocator *	bridgeIORanges;

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

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

protected:
    virtual void probeBus( IOService * provider, UInt8 busNum );

    virtual UInt8 firstBusNum( void );
    virtual UInt8 lastBusNum( void );

    virtual void spaceFromProperties( OSDictionary * propTable,
					IOPCIAddressSpace * space );
    virtual OSDictionary * constructProperties( IOPCIAddressSpace space );

    virtual IOPCIDevice * createNub( OSDictionary * from );

    virtual bool initializeNub( IOPCIDevice * nub, OSDictionary * from );

    virtual bool publishNub( IOPCIDevice * nub, UInt32 index );

    virtual bool addBridgeMemoryRange( IOPhysicalAddress start,
				 	IOPhysicalLength length, bool host );

    virtual bool addBridgeIORange( IOByteCount start, IOByteCount length );

    virtual bool constructRange( IOPCIAddressSpace * flags,
                                 IOPhysicalAddress phys, IOPhysicalLength len,
                                 OSArray * array );

    virtual bool matchNubWithPropertyTable( IOService * nub,
					    OSDictionary * propertyTable,
                                            SInt32 * score );

    virtual bool compareNubName( const IOService * nub, OSString * name,
				 OSString ** matched = 0 ) const;

    virtual bool pciMatchNub( IOPCIDevice * nub,
                                OSDictionary * table, SInt32 * score);

    virtual bool matchKeys( IOPCIDevice * nub, const char * keys,
				UInt32 defaultMask, UInt8 regNum );

    virtual IOReturn getNubResources( IOService * nub );

    virtual IOReturn getNubAddressing( IOPCIDevice * nub );

    virtual IOReturn getDTNubAddressing( IOPCIDevice * nub );

public:

    virtual bool start( IOService * provider );

    virtual bool configure( IOService * provider );

    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    virtual IODeviceMemory * ioDeviceMemory( void ) = 0;

    virtual UInt32 configRead32( IOPCIAddressSpace space, UInt8 offset ) = 0;
    virtual void configWrite32( IOPCIAddressSpace space,
					UInt8 offset, UInt32 data ) = 0;
    virtual UInt16 configRead16( IOPCIAddressSpace space, UInt8 offset ) = 0;
    virtual void configWrite16( IOPCIAddressSpace space,
					UInt8 offset, UInt16 data ) = 0;
    virtual UInt8 configRead8( IOPCIAddressSpace space, UInt8 offset ) = 0;
    virtual void configWrite8( IOPCIAddressSpace space,
					UInt8 offset, UInt8 data ) = 0;

    virtual IOPCIAddressSpace getBridgeSpace( void ) = 0;

    virtual UInt32 findPCICapability( IOPCIAddressSpace space,
                                      UInt8 capabilityID, UInt8 * offset = 0 );

    virtual IOReturn setDevicePowerState( IOPCIDevice * device,
                                          unsigned long whatToDo );
    virtual IOReturn saveDeviceState( IOPCIDevice * device,
                                      IOOptionBits options = 0 );
    virtual IOReturn restoreDeviceState( IOPCIDevice * device,
                                         IOOptionBits options = 0 );

    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    virtual IOReturn createAGPSpace( IOAGPDevice * master,
				     IOOptionBits options,
				     IOPhysicalAddress * address, 
				     IOPhysicalLength * length );

    virtual IOReturn destroyAGPSpace( IOAGPDevice * master );

    virtual IORangeAllocator * getAGPRangeAllocator( IOAGPDevice * master );

    virtual IOOptionBits getAGPStatus( IOAGPDevice * master,
				       IOOptionBits options = 0 );
    virtual IOReturn resetAGPDevice( IOAGPDevice * master,
                                     IOOptionBits options = 0 );

    virtual IOReturn getAGPSpace( IOAGPDevice * master,
                                  IOPhysicalAddress * address, 
				  IOPhysicalLength * length );

    virtual IOReturn commitAGPMemory( IOAGPDevice * master, 
				      IOMemoryDescriptor * memory,
				      IOByteCount agpOffset,
				      IOOptionBits options );

    virtual IOReturn releaseAGPMemory(  IOAGPDevice * master, 
				      	IOMemoryDescriptor * memory, 
					IOByteCount agpOffset,
					IOOptionBits options );

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

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#define kIOPCIBridgeRegs (32)

class IOPCI2PCIBridge : public IOPCIBridge
{
    OSDeclareDefaultStructors(IOPCI2PCIBridge)

private:

    IOPCIDevice * bridgeDevice;
    UInt32        bridgeState[kIOPCIBridgeRegs];

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

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

    virtual UInt8 firstBusNum( void );
    virtual UInt8 lastBusNum( void );

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

    virtual bool configure( IOService * provider );

    virtual void saveBridgeState( void );

    virtual void restoreBridgeState( void );

    virtual bool publishNub( IOPCIDevice * nub, UInt32 index );

    virtual IODeviceMemory * ioDeviceMemory( void );

    virtual IOPCIAddressSpace getBridgeSpace( void );

    virtual UInt32 configRead32( IOPCIAddressSpace space, UInt8 offset );
    virtual void configWrite32( IOPCIAddressSpace space,
					UInt8 offset, UInt32 data );
    virtual UInt16 configRead16( IOPCIAddressSpace space, UInt8 offset );
    virtual void configWrite16( IOPCIAddressSpace space,
					UInt8 offset, UInt16 data );
    virtual UInt8 configRead8( IOPCIAddressSpace space, UInt8 offset );
    virtual void configWrite8( IOPCIAddressSpace space,
					UInt8 offset, UInt8 data );

    // Unused Padding
    OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge,  0);
    OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge,  1);
    OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge,  2);
    OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge,  3);
    OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge,  4);
    OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge,  5);
    OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge,  6);
    OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge,  7);
    OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge,  8);
};

#endif /* ! _IOKIT_IOPCIBRIDGE_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) 1998-2000 Apple Computer, Inc. All rights reserved.
	24	*
	25	* HISTORY
	26	*
	27	*/
	28
	29
	30	#ifndef _IOKIT_IOPCIBRIDGE_H
	31	#define _IOKIT_IOPCIBRIDGE_H
	32
	33	#include <IOKit/IOService.h>
	34	#include <IOKit/IODeviceMemory.h>
	35	#include <IOKit/pci/IOAGPDevice.h>
	36
	37
	38	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	39
	40	class IOPCIBridge : public IOService
	41	{
	42	friend IOPCIDevice;
	43
	44	OSDeclareAbstractStructors(IOPCIBridge)
	45
	46	private:
	47	IORegistryEntry * findMatching( OSIterator * in, IOPCIAddressSpace space );
	48	void publishNubs( OSIterator * kids, UInt32 index );
	49	virtual bool isDTNub( IOPCIDevice * nub );
	50	static void nvLocation( IORegistryEntry * entry,
	51	UInt8 * busNum, UInt8 * deviceNum, UInt8 * functionNum );
	52
	53	protected:
	54	IORangeAllocator * bridgeMemoryRanges;
	55	IORangeAllocator * bridgeIORanges;
	56
	57	/*! @struct ExpansionData
	58	@discussion This structure will be used to expand the capablilties of the IOWorkLoop in the future.
	59	*/
	60	struct ExpansionData { };
	61
	62	/*! @var reserved
	63	Reserved for future use. (Internal use only) */
	64	ExpansionData *reserved;
65
66	protected:
67	virtual void probeBus( IOService * provider, UInt8 busNum );
68
69	virtual UInt8 firstBusNum( void );
70	virtual UInt8 lastBusNum( void );
71
72	virtual void spaceFromProperties( OSDictionary * propTable,
73	IOPCIAddressSpace * space );
74	virtual OSDictionary * constructProperties( IOPCIAddressSpace space );
75
76	virtual IOPCIDevice * createNub( OSDictionary * from );
77
78	virtual bool initializeNub( IOPCIDevice * nub, OSDictionary * from );
79
80	virtual bool publishNub( IOPCIDevice * nub, UInt32 index );
81
82	virtual bool addBridgeMemoryRange( IOPhysicalAddress start,
83	IOPhysicalLength length, bool host );
84
85	virtual bool addBridgeIORange( IOByteCount start, IOByteCount length );
86
87	virtual bool constructRange( IOPCIAddressSpace * flags,
88	IOPhysicalAddress phys, IOPhysicalLength len,
89	OSArray * array );
90
91	virtual bool matchNubWithPropertyTable( IOService * nub,
92	OSDictionary * propertyTable,
93	SInt32 * score );
94
95	virtual bool compareNubName( const IOService * nub, OSString * name,
96	OSString ** matched = 0 ) const;
97
98	virtual bool pciMatchNub( IOPCIDevice * nub,
99	OSDictionary * table, SInt32 * score);
100
101	virtual bool matchKeys( IOPCIDevice * nub, const char * keys,
102	UInt32 defaultMask, UInt8 regNum );
103
104	virtual IOReturn getNubResources( IOService * nub );
105
106	virtual IOReturn getNubAddressing( IOPCIDevice * nub );
107
108	virtual IOReturn getDTNubAddressing( IOPCIDevice * nub );
109
110	public:
111
112	virtual bool start( IOService * provider );
113
114	virtual bool configure( IOService * provider );
115
116	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * */
117
118	virtual IODeviceMemory * ioDeviceMemory( void ) = 0;
119
120	virtual UInt32 configRead32( IOPCIAddressSpace space, UInt8 offset ) = 0;
121	virtual void configWrite32( IOPCIAddressSpace space,
122	UInt8 offset, UInt32 data ) = 0;
123	virtual UInt16 configRead16( IOPCIAddressSpace space, UInt8 offset ) = 0;
124	virtual void configWrite16( IOPCIAddressSpace space,
125	UInt8 offset, UInt16 data ) = 0;
126	virtual UInt8 configRead8( IOPCIAddressSpace space, UInt8 offset ) = 0;
127	virtual void configWrite8( IOPCIAddressSpace space,
128	UInt8 offset, UInt8 data ) = 0;
129
130	virtual IOPCIAddressSpace getBridgeSpace( void ) = 0;
131
132	virtual UInt32 findPCICapability( IOPCIAddressSpace space,
133	UInt8 capabilityID, UInt8 * offset = 0 );
134
135	virtual IOReturn setDevicePowerState( IOPCIDevice * device,
0b4e3aa0	136	unsigned long whatToDo );
1c79356b A	137	virtual IOReturn saveDeviceState( IOPCIDevice * device,
	138	IOOptionBits options = 0 );
	139	virtual IOReturn restoreDeviceState( IOPCIDevice * device,
	140	IOOptionBits options = 0 );
	141
	142	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	143
	144	virtual IOReturn createAGPSpace( IOAGPDevice * master,
	145	IOOptionBits options,
	146	IOPhysicalAddress * address,
	147	IOPhysicalLength * length );
	148
	149	virtual IOReturn destroyAGPSpace( IOAGPDevice * master );
	150
	151	virtual IORangeAllocator * getAGPRangeAllocator( IOAGPDevice * master );
	152
	153	virtual IOOptionBits getAGPStatus( IOAGPDevice * master,
	154	IOOptionBits options = 0 );
	155	virtual IOReturn resetAGPDevice( IOAGPDevice * master,
	156	IOOptionBits options = 0 );
	157
	158	virtual IOReturn getAGPSpace( IOAGPDevice * master,
	159	IOPhysicalAddress * address,
	160	IOPhysicalLength * length );
	161
	162	virtual IOReturn commitAGPMemory( IOAGPDevice * master,
	163	IOMemoryDescriptor * memory,
	164	IOByteCount agpOffset,
	165	IOOptionBits options );
	166
	167	virtual IOReturn releaseAGPMemory( IOAGPDevice * master,
	168	IOMemoryDescriptor * memory,
	169	IOByteCount agpOffset,
	170	IOOptionBits options );
	171
	172	// Unused Padding
	173	OSMetaClassDeclareReservedUnused(IOPCIBridge, 0);
	174	OSMetaClassDeclareReservedUnused(IOPCIBridge, 1);
	175	OSMetaClassDeclareReservedUnused(IOPCIBridge, 2);
	176	OSMetaClassDeclareReservedUnused(IOPCIBridge, 3);
	177	OSMetaClassDeclareReservedUnused(IOPCIBridge, 4);
	178	OSMetaClassDeclareReservedUnused(IOPCIBridge, 5);
	179	OSMetaClassDeclareReservedUnused(IOPCIBridge, 6);
	180	OSMetaClassDeclareReservedUnused(IOPCIBridge, 7);
	181	OSMetaClassDeclareReservedUnused(IOPCIBridge, 8);
	182	OSMetaClassDeclareReservedUnused(IOPCIBridge, 9);
	183	OSMetaClassDeclareReservedUnused(IOPCIBridge, 10);
	184	OSMetaClassDeclareReservedUnused(IOPCIBridge, 11);
	185	OSMetaClassDeclareReservedUnused(IOPCIBridge, 12);
	186	OSMetaClassDeclareReservedUnused(IOPCIBridge, 13);
	187	OSMetaClassDeclareReservedUnused(IOPCIBridge, 14);
	188	OSMetaClassDeclareReservedUnused(IOPCIBridge, 15);
	189	OSMetaClassDeclareReservedUnused(IOPCIBridge, 16);
	190	OSMetaClassDeclareReservedUnused(IOPCIBridge, 17);
	191	OSMetaClassDeclareReservedUnused(IOPCIBridge, 18);
	192	OSMetaClassDeclareReservedUnused(IOPCIBridge, 19);
	193	OSMetaClassDeclareReservedUnused(IOPCIBridge, 20);
	194	OSMetaClassDeclareReservedUnused(IOPCIBridge, 21);
	195	OSMetaClassDeclareReservedUnused(IOPCIBridge, 22);
	196	OSMetaClassDeclareReservedUnused(IOPCIBridge, 23);
	197	OSMetaClassDeclareReservedUnused(IOPCIBridge, 24);
	198	OSMetaClassDeclareReservedUnused(IOPCIBridge, 25);
	199	OSMetaClassDeclareReservedUnused(IOPCIBridge, 26);
	200	OSMetaClassDeclareReservedUnused(IOPCIBridge, 27);
201	OSMetaClassDeclareReservedUnused(IOPCIBridge, 28);
202	OSMetaClassDeclareReservedUnused(IOPCIBridge, 29);
203	OSMetaClassDeclareReservedUnused(IOPCIBridge, 30);
204	OSMetaClassDeclareReservedUnused(IOPCIBridge, 31);
205	};
206
207	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
208
209	#define kIOPCIBridgeRegs (32)
210
211	class IOPCI2PCIBridge : public IOPCIBridge
212	{
213	OSDeclareDefaultStructors(IOPCI2PCIBridge)
214
215	private:
216
217	IOPCIDevice * bridgeDevice;
218	UInt32 bridgeState[kIOPCIBridgeRegs];
219
220	protected:
221	/*! @struct ExpansionData
222	@discussion This structure will be used to expand the capablilties of the IOWorkLoop in the future.
223	*/
224	struct ExpansionData { };
225
226	/*! @var reserved
227	Reserved for future use. (Internal use only) */
228	ExpansionData *reserved;
229
230	virtual UInt8 firstBusNum( void );
231	virtual UInt8 lastBusNum( void );
232
233	public:
234	virtual IOService * probe( IOService * provider,
235	SInt32 * score );
236
237	virtual bool configure( IOService * provider );
238
239	virtual void saveBridgeState( void );
240
241	virtual void restoreBridgeState( void );
242
243	virtual bool publishNub( IOPCIDevice * nub, UInt32 index );
244
245	virtual IODeviceMemory * ioDeviceMemory( void );
246
247	virtual IOPCIAddressSpace getBridgeSpace( void );
248
249	virtual UInt32 configRead32( IOPCIAddressSpace space, UInt8 offset );
250	virtual void configWrite32( IOPCIAddressSpace space,
251	UInt8 offset, UInt32 data );
252	virtual UInt16 configRead16( IOPCIAddressSpace space, UInt8 offset );
253	virtual void configWrite16( IOPCIAddressSpace space,
254	UInt8 offset, UInt16 data );
255	virtual UInt8 configRead8( IOPCIAddressSpace space, UInt8 offset );
256	virtual void configWrite8( IOPCIAddressSpace space,
257	UInt8 offset, UInt8 data );
258
259	// Unused Padding
260	OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge, 0);
261	OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge, 1);
262	OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge, 2);
263	OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge, 3);
264	OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge, 4);
265	OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge, 5);
266	OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge, 6);
267	OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge, 7);
268	OSMetaClassDeclareReservedUnused(IOPCI2PCIBridge, 8);
269	};
270
271	#endif /* ! _IOKIT_IOPCIBRIDGE_H */