[apple/xnu.git] / iokit / IOKit / ppc / IODBDMA.h

/*
 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The 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, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1997 Apple Computer, Inc.
 *
 *
 * HISTORY
 *
 * Simon Douglas  10 Nov 97
 * - first checked in, mostly from MacOS DBDMA.i, machdep/ppc/dbdma.h
 *	but use byte reverse ops.
 */

#ifndef _IODBDMA_H_
#define _IODBDMA_H_

#include <IOKit/IOTypes.h>
#include <libkern/OSByteOrder.h>


/* DBDMA definitions */

struct IODBDMAChannelRegisters {
    volatile unsigned long 	channelControl;
    volatile unsigned long 	channelStatus;
    volatile unsigned long 	commandPtrHi;		/* implementation optional*/
    volatile unsigned long 	commandPtrLo;
    volatile unsigned long 	interruptSelect;	/* implementation optional*/
    volatile unsigned long 	branchSelect;		/* implementation optional*/
    volatile unsigned long 	waitSelect;		/* implementation optional*/
    volatile unsigned long 	transferModes;		/* implementation optional*/
    volatile unsigned long 	data2PtrHi;		/* implementation optional*/
    volatile unsigned long 	data2PtrLo;		/* implementation optional*/

    volatile unsigned long 	reserved1;
    volatile unsigned long 	addressHi;		/* implementation optional*/
    volatile unsigned long 	reserved2[4];
    volatile unsigned long 	unimplemented[16];

/* This structure must remain fully padded to 256 bytes.*/
    volatile unsigned long 	undefined[32];
};
typedef struct IODBDMAChannelRegisters IODBDMAChannelRegisters;

/* These constants define the DB-DMA channel control words and status flags.*/

enum {
	kdbdmaRun	= 0x00008000,
	kdbdmaPause	= 0x00004000,
	kdbdmaFlush	= 0x00002000,
	kdbdmaWake	= 0x00001000,
	kdbdmaDead	= 0x00000800,
	kdbdmaActive	= 0x00000400,
	kdbdmaBt	= 0x00000100,
	kdbdmaS7	= 0x00000080,
	kdbdmaS6	= 0x00000040,
	kdbdmaS5	= 0x00000020,
	kdbdmaS4	= 0x00000010,
	kdbdmaS3	= 0x00000008,
	kdbdmaS2	= 0x00000004,
	kdbdmaS1	= 0x00000002,
	kdbdmaS0	= 0x00000001
};


#define	IOSetDBDMAChannelControlBits(mask)	( ((mask) | (mask) << 16) )
#define	IOClearDBDMAChannelControlBits(mask)	( (mask) << 16)


/* This structure defines the DB-DMA channel command descriptor.*/

/*
   *** WARNING:	Endian-ness issues must be considered when performing load/store! ***
*/

struct IODBDMADescriptor {
	unsigned long            operation;   /* cmd || key || i || b || w || reqCount*/
	unsigned long            address;
	volatile unsigned long   cmdDep;
	volatile unsigned long   result;      /* xferStatus || resCount*/
};
typedef struct IODBDMADescriptor IODBDMADescriptor;

/* These constants define the DB-DMA channel command operations and modifiers.*/


enum {
/* Command.cmd operations*/
	kdbdmaOutputMore	= 0,
	kdbdmaOutputLast	= 1,
	kdbdmaInputMore		= 2,
	kdbdmaInputLast		= 3,
	kdbdmaStoreQuad		= 4,
	kdbdmaLoadQuad		= 5,
	kdbdmaNop		= 6,
	kdbdmaStop		= 7
};


enum {
/* Command.key modifiers (choose one for INPUT, OUTPUT, LOAD, and STORE)*/
	kdbdmaKeyStream0	= 0,	/* default modifier*/
	kdbdmaKeyStream1	= 1,
	kdbdmaKeyStream2	= 2,
	kdbdmaKeyStream3	= 3,
	kdbdmaKeyRegs		= 5,
	kdbdmaKeySystem		= 6,
	kdbdmaKeyDevice		= 7,

	kdbdmaIntNever		= 0,	/* default modifier*/
	kdbdmaIntIfTrue		= 1,
	kdbdmaIntIfFalse	= 2,
	kdbdmaIntAlways		= 3,

	kdbdmaBranchNever	= 0,	/* default modifier*/
	kdbdmaBranchIfTrue	= 1,
	kdbdmaBranchIfFalse	= 2,
	kdbdmaBranchAlways	= 3,

	kdbdmaWaitNever		= 0,	/* default modifier*/
	kdbdmaWaitIfTrue	= 1,
	kdbdmaWaitIfFalse	= 2,
	kdbdmaWaitAlways	= 3,

	kdbdmaCommandMask	= (long)0xFFFF0000,
	kdbdmaReqCountMask	= 0x0000FFFF
};


/* These constants define the DB-DMA channel command results.*/

enum {
	/* result masks*/
	kdbdmaStatusRun		= kdbdmaRun << 16,
	kdbdmaStatusPause	= kdbdmaPause << 16,
	kdbdmaStatusFlush	= kdbdmaFlush << 16,
	kdbdmaStatusWake	= kdbdmaWake << 16,
	kdbdmaStatusDead	= kdbdmaDead << 16,
	kdbdmaStatusActive	= kdbdmaActive << 16,
	kdbdmaStatusBt		= kdbdmaBt << 16,
	kdbdmaStatusS7		= kdbdmaS7 << 16,
	kdbdmaStatusS6		= kdbdmaS6 << 16,
	kdbdmaStatusS5		= kdbdmaS5 << 16,
	kdbdmaStatusS4		= kdbdmaS4 << 16,
	kdbdmaStatusS3		= kdbdmaS3 << 16,
	kdbdmaStatusS2		= kdbdmaS2 << 16,
	kdbdmaStatusS1		= kdbdmaS1 << 16,
	kdbdmaStatusS0		= kdbdmaS0 << 16,
	kdbdmaResCountMask	= 0x0000FFFF,
	kdbdmaXferStatusMask	= 0xFFFF0000
};


/*  These macros are are IODBDMAChannelRegisters accessor functions. */

#define IOSetDBDMAChannelRegister(registerSetPtr,field,value)	\
OSWriteSwapInt32(registerSetPtr,offsetof(IODBDMAChannelRegisters,field),value)

#define IOGetDBDMAChannelRegister(registerSetPtr, field)	\
OSReadSwapInt32(registerSetPtr,offsetof(IODBDMAChannelRegisters, field))


/* 	void IOSetDBDMAChannelControl (IODBDMAChannelRegisters *registerSetPtr, unsigned long ctlValue); */

#define IOSetDBDMAChannelControl(registerSetPtr,ctlValue)		\
do {									\
    eieio();								\
    IOSetDBDMAChannelRegister(registerSetPtr,channelControl,ctlValue);	\
    eieio();								\
} while(0)

/* 	unsigned long IOGetDBDMAChannelStatus (IODBDMAChannelRegisters *registerSetPtr); */

#define IOGetDBDMAChannelStatus(registerSetPtr)		\
	IOGetDBDMAChannelRegister(registerSetPtr,channelStatus)

/* 	unsigned long IOGetDBDMACommandPtr (IODBDMAChannelRegisters *registerSetPtr); */

#define IOGetDBDMACommandPtr(registerSetPtr)			\
	IOGetDBDMAChannelRegister(registerSetPtr,commandPtrLo)

/* 	void IOSetDBDMACommandPtr (IODBDMAChannelRegisters *registerSetPtr, unsigned long cclPtr); */

#define IOSetDBDMACommandPtr(registerSetPtr,cclPtr)			\
do {									\
    IOSetDBDMAChannelRegister(registerSetPtr,commandPtrHi,0);		\
    eieio();								\
    IOSetDBDMAChannelRegister(registerSetPtr,commandPtrLo,cclPtr);	\
    eieio();								\
} while(0)


/* 	unsigned long IOGetDBDMAInterruptSelect (IODBDMAChannelRegisters *registerSetPtr); */

#define IOGetDBDMAInterruptSelect(registerSetPtr)		\
        IOGetDBDMAChannelRegister(registerSetPtr,interruptSelect)

/* 	void IOSetDBDMAInterruptSelect (IODBDMAChannelRegisters *registerSetPtr, unsigned long intSelValue); */

#define IOSetDBDMAInterruptSelect(registerSetPtr,intSelValue)		   \
do {									   \
    IOSetDBDMAChannelRegister(registerSetPtr,interruptSelect,intSelValue); \
    eieio();								   \
} while(0)

/* 	unsigned long IOGetDBDMABranchSelect (IODBDMAChannelRegisters *registerSetPtr); */

#define IOGetDBDMABranchSelect(registerSetPtr)				\
	IOGetDBDMAChannelRegister(registerSetPtr,branchSelect)

/* 	void IOSetDBDMABranchSelect (IODBDMAChannelRegisters *registerSetPtr, unsigned long braSelValue); */

#define IOSetDBDMABranchSelect(registerSetPtr,braSelValue)		\
do {									\
    IOSetDBDMAChannelRegister(registerSetPtr,branchSelect,braSelValue);	\
    eieio();								\
} while(0)

/* 	unsigned long IOGetDBDMAWaitSelect (IODBDMAChannelRegisters *registerSetPtr); */

#define IOGetDBDMAWaitSelect(registerSetPtr)				\
	IOGetDBDMAChannelRegister(registerSetPtr,waitSelect)

/* 	void IOSetDBDMAWaitSelect (IODBDMAChannelRegisters *registerSetPtr, unsigned long waitSelValue); */

#define IOSetDBDMAWaitSelect(registerSetPtr,waitSelValue)		\
do {									\
    IOSetDBDMAChannelRegister(registerSetPtr,waitSelect,waitSelValue);	\
    eieio();								\
} while(0)


/*  These macros are IODBDMADescriptor accessor functions. */

#define IOSetDBDMADescriptor(descPtr,field,value)		\
OSWriteSwapInt32( descPtr, offsetof( IODBDMADescriptor, field), value)

#define IOGetDBDMADescriptor(descPtr,field)	\
OSReadSwapInt32( descPtr, offsetof( IODBDMADescriptor, field))

#define	IOMakeDBDMAOperation(cmd,key,interrupt,branch,wait,count)	\
    ( ((cmd) << 28) | ((key) << 24) | ((interrupt) << 20)		\
      | ((branch) << 18) | ( (wait) << 16) | (count) )

/* void  IOMakeDBDMADescriptor (IODBDMADescriptor *descPtr,
				unsigned long cmd,
				unsigned long key,
				unsigned long interrupt,
				unsigned long branch,
				unsigned long wait,
				unsigned long count,
				unsigned long addr); */

#define IOMakeDBDMADescriptor(descPtr,cmd,key,interrupt,branch,wait,count,addr)\
do {									       \
    IOSetDBDMADescriptor(descPtr, address, addr);			       \
    IOSetDBDMADescriptor(descPtr, cmdDep,  0);				       \
    IOSetDBDMADescriptor(descPtr, result,  0);				       \
    eieio();								       \
    IOSetDBDMADescriptor(descPtr, operation,				       \
        IOMakeDBDMAOperation(cmd,key,interrupt,branch,wait,count));	       \
    eieio();								       \
} while(0)

/* void IOMakeDBDMADescriptorDep (IODBDMADescriptor *descPtr,
				unsigned long cmd,
				unsigned long key,
				unsigned long interrupt,
				unsigned long branch,
				unsigned long wait,
				unsigned long count,
				unsigned long addr,
				unsigned long dep); */

#define IOMakeDBDMADescriptorDep(descPtr,cmd,key,interrupt,branch,wait,count,addr,dep) \
do {									       \
    IOSetDBDMADescriptor(descPtr, address, addr);			       \
    IOSetDBDMADescriptor(descPtr, cmdDep, dep);				       \
    IOSetDBDMADescriptor(descPtr, result, 0);				       \
    eieio();								       \
    IOSetDBDMADescriptor(descPtr, operation,				       \
        IOMakeDBDMAOperation(cmd, key, interrupt, branch, wait, count));       \
    eieio();								       \
} while(0)

/*	Field accessors - NOTE: unsynchronized */

/* 	unsigned long IOGetDBDMAOperation (IODBDMADescriptor *descPtr) */

#define IOGetCCOperation(descPtr)				\
	IOGetDBDMADescriptor(descPtr,operation)

/* 	void IOSetCCOperation (IODBDMADescriptor *descPtr, unsigned long operationValue) */

#define IOSetCCOperation(descPtr,operationValue)		\
	IOSetDBDMADescriptor(descPtr,operation,operationValue)

/* 	unsigned long IOGetCCAddress (IODBDMADescriptor *descPtr) */

#define IOGetCCAddress(descPtr)				\
	IOGetDBDMADescriptor(descPtr,address)

/* 	void IOSetCCAddress (IODBDMADescriptor *descPtr, unsigned long addressValue) */

#define IOSetCCAddress(descPtr,addressValue)		\
	IOSetDBDMADescriptor(descPtr,address, addressValue)

/* 	unsigned long IOGetCCCmdDep (IODBDMADescriptor *descPtr) */

#define IOGetCCCmdDep(descPtr)				\
	IOGetDBDMADescriptor(descPtr,cmdDep)

/* 	void IOSetCCCmdDep (IODBDMADescriptor *descPtr, unsigned long cmdDepValue) */

#define IOSetCCCmdDep(descPtr,cmdDepValue)		\
	IOSetDBDMADescriptor(descPtr,cmdDep,cmdDepValue)

/* 	unsigned long IOGetCCResult (IODBDMADescriptor *descPtr) */

#define IOGetCCResult(descPtr)				\
	IOGetDBDMADescriptor(descPtr,result)

/* 	void IOSetCCResult (IODBDMADescriptor *descPtr, unsigned long resultValue) */

#define IOSetCCResult(descPtr,resultValue)		\
	IOSetDBDMADescriptor(descPtr,result,resultValue)


/* DBDMA routines */

extern void	IODBDMAStart( volatile IODBDMAChannelRegisters *registerSetPtr, volatile IODBDMADescriptor *physicalDescPtr);
extern void	IODBDMAStop( volatile IODBDMAChannelRegisters *registerSetPtr);
extern void	IODBDMAFlush( volatile IODBDMAChannelRegisters *registerSetPtr);
extern void	IODBDMAReset( volatile IODBDMAChannelRegisters *registerSetPtr);
extern void	IODBDMAContinue( volatile IODBDMAChannelRegisters *registerSetPtr);
extern void	IODBDMAPause( volatile IODBDMAChannelRegisters *registerSetPtr);

extern IOReturn	IOAllocatePhysicallyContiguousMemory( unsigned int size, unsigned int options,
				     IOVirtualAddress * logical, IOPhysicalAddress * physical );
extern IOReturn IOFreePhysicallyContiguousMemory( IOVirtualAddress * logical, unsigned int size);

#endif /* !defined(_IODBDMA_H_) */
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
8f6c56a5	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* Copyright (c) 1997 Apple Computer, Inc.
	30	*
	31	*
	32	* HISTORY
	33	*
	34	* Simon Douglas 10 Nov 97
	35	* - first checked in, mostly from MacOS DBDMA.i, machdep/ppc/dbdma.h
	36	* but use byte reverse ops.
	37	*/
	38
	39	#ifndef _IODBDMA_H_
	40	#define _IODBDMA_H_
	41
	42	#include <IOKit/IOTypes.h>
	43	#include <libkern/OSByteOrder.h>
1c79356b A	44
	45
	46	/* DBDMA definitions */
	47
	48	struct IODBDMAChannelRegisters {
	49	volatile unsigned long channelControl;
	50	volatile unsigned long channelStatus;
	51	volatile unsigned long commandPtrHi; /* implementation optional*/
	52	volatile unsigned long commandPtrLo;
	53	volatile unsigned long interruptSelect; /* implementation optional*/
	54	volatile unsigned long branchSelect; /* implementation optional*/
	55	volatile unsigned long waitSelect; /* implementation optional*/
	56	volatile unsigned long transferModes; /* implementation optional*/
	57	volatile unsigned long data2PtrHi; /* implementation optional*/
	58	volatile unsigned long data2PtrLo; /* implementation optional*/
	59
	60	volatile unsigned long reserved1;
	61	volatile unsigned long addressHi; /* implementation optional*/
	62	volatile unsigned long reserved2[4];
	63	volatile unsigned long unimplemented[16];
	64
	65	/* This structure must remain fully padded to 256 bytes.*/
	66	volatile unsigned long undefined[32];
	67	};
	68	typedef struct IODBDMAChannelRegisters IODBDMAChannelRegisters;
	69
	70	/* These constants define the DB-DMA channel control words and status flags.*/
	71
	72	enum {
	73	kdbdmaRun = 0x00008000,
	74	kdbdmaPause = 0x00004000,
	75	kdbdmaFlush = 0x00002000,
	76	kdbdmaWake = 0x00001000,
	77	kdbdmaDead = 0x00000800,
	78	kdbdmaActive = 0x00000400,
	79	kdbdmaBt = 0x00000100,
	80	kdbdmaS7 = 0x00000080,
	81	kdbdmaS6 = 0x00000040,
	82	kdbdmaS5 = 0x00000020,
	83	kdbdmaS4 = 0x00000010,
	84	kdbdmaS3 = 0x00000008,
	85	kdbdmaS2 = 0x00000004,
	86	kdbdmaS1 = 0x00000002,
	87	kdbdmaS0 = 0x00000001
	88	};
	89
	90
	91	#define IOSetDBDMAChannelControlBits(mask) ( ((mask) \| (mask) << 16) )
	92	#define IOClearDBDMAChannelControlBits(mask) ( (mask) << 16)
	93
	94
	95	/* This structure defines the DB-DMA channel command descriptor.*/
	96
	97	/*
	98	* WARNING: Endian-ness issues must be considered when performing load/store! *
	99	*/
	100
	101	struct IODBDMADescriptor {
	102	unsigned long operation; /* cmd \|\| key \|\| i \|\| b \|\| w \|\| reqCount*/
	103	unsigned long address;
	104	volatile unsigned long cmdDep;
	105	volatile unsigned long result; /* xferStatus \|\| resCount*/
	106	};
	107	typedef struct IODBDMADescriptor IODBDMADescriptor;
108
109	/* These constants define the DB-DMA channel command operations and modifiers.*/
110
111
112	enum {
113	/* Command.cmd operations*/
114	kdbdmaOutputMore = 0,
115	kdbdmaOutputLast = 1,
116	kdbdmaInputMore = 2,
117	kdbdmaInputLast = 3,
118	kdbdmaStoreQuad = 4,
119	kdbdmaLoadQuad = 5,
120	kdbdmaNop = 6,
55e303ae	121	kdbdmaStop = 7
1c79356b A	122	};
	123
	124
	125	enum {
	126	/* Command.key modifiers (choose one for INPUT, OUTPUT, LOAD, and STORE)*/
	127	kdbdmaKeyStream0 = 0, /* default modifier*/
	128	kdbdmaKeyStream1 = 1,
	129	kdbdmaKeyStream2 = 2,
	130	kdbdmaKeyStream3 = 3,
	131	kdbdmaKeyRegs = 5,
	132	kdbdmaKeySystem = 6,
	133	kdbdmaKeyDevice = 7,
	134
	135	kdbdmaIntNever = 0, /* default modifier*/
	136	kdbdmaIntIfTrue = 1,
	137	kdbdmaIntIfFalse = 2,
	138	kdbdmaIntAlways = 3,
	139
	140	kdbdmaBranchNever = 0, /* default modifier*/
	141	kdbdmaBranchIfTrue = 1,
	142	kdbdmaBranchIfFalse = 2,
	143	kdbdmaBranchAlways = 3,
	144
	145	kdbdmaWaitNever = 0, /* default modifier*/
	146	kdbdmaWaitIfTrue = 1,
	147	kdbdmaWaitIfFalse = 2,
	148	kdbdmaWaitAlways = 3,
	149
	150	kdbdmaCommandMask = (long)0xFFFF0000,
	151	kdbdmaReqCountMask = 0x0000FFFF
	152	};
	153
	154
	155	/* These constants define the DB-DMA channel command results.*/
	156
	157	enum {
	158	/* result masks*/
	159	kdbdmaStatusRun = kdbdmaRun << 16,
	160	kdbdmaStatusPause = kdbdmaPause << 16,
	161	kdbdmaStatusFlush = kdbdmaFlush << 16,
	162	kdbdmaStatusWake = kdbdmaWake << 16,
	163	kdbdmaStatusDead = kdbdmaDead << 16,
	164	kdbdmaStatusActive = kdbdmaActive << 16,
	165	kdbdmaStatusBt = kdbdmaBt << 16,
	166	kdbdmaStatusS7 = kdbdmaS7 << 16,
	167	kdbdmaStatusS6 = kdbdmaS6 << 16,
	168	kdbdmaStatusS5 = kdbdmaS5 << 16,
	169	kdbdmaStatusS4 = kdbdmaS4 << 16,
	170	kdbdmaStatusS3 = kdbdmaS3 << 16,
	171	kdbdmaStatusS2 = kdbdmaS2 << 16,
	172	kdbdmaStatusS1 = kdbdmaS1 << 16,
	173	kdbdmaStatusS0 = kdbdmaS0 << 16,
	174	kdbdmaResCountMask = 0x0000FFFF,
	175	kdbdmaXferStatusMask = 0xFFFF0000
	176	};
	177
	178
	179	/* These macros are are IODBDMAChannelRegisters accessor functions. */
	180
	181	#define IOSetDBDMAChannelRegister(registerSetPtr,field,value) \
	182	OSWriteSwapInt32(registerSetPtr,offsetof(IODBDMAChannelRegisters,field),value)
	183
	184	#define IOGetDBDMAChannelRegister(registerSetPtr, field) \
	185	OSReadSwapInt32(registerSetPtr,offsetof(IODBDMAChannelRegisters, field))
186
187
188	/* void IOSetDBDMAChannelControl (IODBDMAChannelRegisters registerSetPtr, unsigned long ctlValue); /
189
190	#define IOSetDBDMAChannelControl(registerSetPtr,ctlValue) \
191	do { \
192	eieio(); \
193	IOSetDBDMAChannelRegister(registerSetPtr,channelControl,ctlValue); \
194	eieio(); \
195	} while(0)
196
197	/* unsigned long IOGetDBDMAChannelStatus (IODBDMAChannelRegisters registerSetPtr); /
198
199	#define IOGetDBDMAChannelStatus(registerSetPtr) \
200	IOGetDBDMAChannelRegister(registerSetPtr,channelStatus)
201
202	/* unsigned long IOGetDBDMACommandPtr (IODBDMAChannelRegisters registerSetPtr); /
203
204	#define IOGetDBDMACommandPtr(registerSetPtr) \
205	IOGetDBDMAChannelRegister(registerSetPtr,commandPtrLo)
206
207	/* void IOSetDBDMACommandPtr (IODBDMAChannelRegisters registerSetPtr, unsigned long cclPtr); /
208
209	#define IOSetDBDMACommandPtr(registerSetPtr,cclPtr) \
210	do { \
211	IOSetDBDMAChannelRegister(registerSetPtr,commandPtrHi,0); \
212	eieio(); \
213	IOSetDBDMAChannelRegister(registerSetPtr,commandPtrLo,cclPtr); \
214	eieio(); \
215	} while(0)
216
217
218	/* unsigned long IOGetDBDMAInterruptSelect (IODBDMAChannelRegisters registerSetPtr); /
219
220	#define IOGetDBDMAInterruptSelect(registerSetPtr) \
221	IOGetDBDMAChannelRegister(registerSetPtr,interruptSelect)
222
223	/* void IOSetDBDMAInterruptSelect (IODBDMAChannelRegisters registerSetPtr, unsigned long intSelValue); /
224
225	#define IOSetDBDMAInterruptSelect(registerSetPtr,intSelValue) \
226	do { \
227	IOSetDBDMAChannelRegister(registerSetPtr,interruptSelect,intSelValue); \
228	eieio(); \
229	} while(0)
230
231	/* unsigned long IOGetDBDMABranchSelect (IODBDMAChannelRegisters registerSetPtr); /
232
233	#define IOGetDBDMABranchSelect(registerSetPtr) \
234	IOGetDBDMAChannelRegister(registerSetPtr,branchSelect)
235
236	/* void IOSetDBDMABranchSelect (IODBDMAChannelRegisters registerSetPtr, unsigned long braSelValue); /
237
238	#define IOSetDBDMABranchSelect(registerSetPtr,braSelValue) \
239	do { \
240	IOSetDBDMAChannelRegister(registerSetPtr,branchSelect,braSelValue); \
241	eieio(); \
242	} while(0)
243
244	/* unsigned long IOGetDBDMAWaitSelect (IODBDMAChannelRegisters registerSetPtr); /
245
246	#define IOGetDBDMAWaitSelect(registerSetPtr) \
247	IOGetDBDMAChannelRegister(registerSetPtr,waitSelect)
248
249	/* void IOSetDBDMAWaitSelect (IODBDMAChannelRegisters registerSetPtr, unsigned long waitSelValue); /
250
251	#define IOSetDBDMAWaitSelect(registerSetPtr,waitSelValue) \
252	do { \
253	IOSetDBDMAChannelRegister(registerSetPtr,waitSelect,waitSelValue); \
254	eieio(); \
255	} while(0)
256
257
258	/* These macros are IODBDMADescriptor accessor functions. */
259
260	#define IOSetDBDMADescriptor(descPtr,field,value) \
261	OSWriteSwapInt32( descPtr, offsetof( IODBDMADescriptor, field), value)
262
263	#define IOGetDBDMADescriptor(descPtr,field) \
264	OSReadSwapInt32( descPtr, offsetof( IODBDMADescriptor, field))
265
266	#define IOMakeDBDMAOperation(cmd,key,interrupt,branch,wait,count) \
267	( ((cmd) << 28) \| ((key) << 24) \| ((interrupt) << 20) \
268	\| ((branch) << 18) \| ( (wait) << 16) \| (count) )
269
270	/* void IOMakeDBDMADescriptor (IODBDMADescriptor *descPtr,
271	unsigned long cmd,
272	unsigned long key,
273	unsigned long interrupt,
274	unsigned long branch,
275	unsigned long wait,
276	unsigned long count,
277	unsigned long addr); */
278
279	#define IOMakeDBDMADescriptor(descPtr,cmd,key,interrupt,branch,wait,count,addr)\
280	do { \
281	IOSetDBDMADescriptor(descPtr, address, addr); \
282	IOSetDBDMADescriptor(descPtr, cmdDep, 0); \
283	IOSetDBDMADescriptor(descPtr, result, 0); \
284	eieio(); \
285	IOSetDBDMADescriptor(descPtr, operation, \
286	IOMakeDBDMAOperation(cmd,key,interrupt,branch,wait,count)); \
287	eieio(); \
288	} while(0)
289
290	/* void IOMakeDBDMADescriptorDep (IODBDMADescriptor *descPtr,
291	unsigned long cmd,
292	unsigned long key,
293	unsigned long interrupt,
294	unsigned long branch,
295	unsigned long wait,
296	unsigned long count,
297	unsigned long addr,
298	unsigned long dep); */
299
300	#define IOMakeDBDMADescriptorDep(descPtr,cmd,key,interrupt,branch,wait,count,addr,dep) \
301	do { \
302	IOSetDBDMADescriptor(descPtr, address, addr); \
303	IOSetDBDMADescriptor(descPtr, cmdDep, dep); \
304	IOSetDBDMADescriptor(descPtr, result, 0); \
305	eieio(); \
306	IOSetDBDMADescriptor(descPtr, operation, \
307	IOMakeDBDMAOperation(cmd, key, interrupt, branch, wait, count)); \
308	eieio(); \
309	} while(0)
310
311	/* Field accessors - NOTE: unsynchronized */
312
313	/* unsigned long IOGetDBDMAOperation (IODBDMADescriptor descPtr) /
314
315	#define IOGetCCOperation(descPtr) \
316	IOGetDBDMADescriptor(descPtr,operation)
317
318	/* void IOSetCCOperation (IODBDMADescriptor descPtr, unsigned long operationValue) /
319
320	#define IOSetCCOperation(descPtr,operationValue) \
321	IOSetDBDMADescriptor(descPtr,operation,operationValue)
322
323	/* unsigned long IOGetCCAddress (IODBDMADescriptor descPtr) /
324
325	#define IOGetCCAddress(descPtr) \
326	IOGetDBDMADescriptor(descPtr,address)
327
328	/* void IOSetCCAddress (IODBDMADescriptor descPtr, unsigned long addressValue) /
329
330	#define IOSetCCAddress(descPtr,addressValue) \
331	IOSetDBDMADescriptor(descPtr,address, addressValue)
332
333	/* unsigned long IOGetCCCmdDep (IODBDMADescriptor descPtr) /
334
335	#define IOGetCCCmdDep(descPtr) \
336	IOGetDBDMADescriptor(descPtr,cmdDep)
337
338	/* void IOSetCCCmdDep (IODBDMADescriptor descPtr, unsigned long cmdDepValue) /
339
340	#define IOSetCCCmdDep(descPtr,cmdDepValue) \
341	IOSetDBDMADescriptor(descPtr,cmdDep,cmdDepValue)
342
343	/* unsigned long IOGetCCResult (IODBDMADescriptor descPtr) /
344
345	#define IOGetCCResult(descPtr) \
346	IOGetDBDMADescriptor(descPtr,result)
347
348	/* void IOSetCCResult (IODBDMADescriptor descPtr, unsigned long resultValue) /
349
350	#define IOSetCCResult(descPtr,resultValue) \
351	IOSetDBDMADescriptor(descPtr,result,resultValue)
352
353
354	/* DBDMA routines */
355
356	extern void IODBDMAStart( volatile IODBDMAChannelRegisters registerSetPtr, volatile IODBDMADescriptor physicalDescPtr);
357	extern void IODBDMAStop( volatile IODBDMAChannelRegisters *registerSetPtr);
358	extern void IODBDMAFlush( volatile IODBDMAChannelRegisters *registerSetPtr);
359	extern void IODBDMAReset( volatile IODBDMAChannelRegisters *registerSetPtr);
360	extern void IODBDMAContinue( volatile IODBDMAChannelRegisters *registerSetPtr);
361	extern void IODBDMAPause( volatile IODBDMAChannelRegisters *registerSetPtr);
362
363	extern IOReturn IOAllocatePhysicallyContiguousMemory( unsigned int size, unsigned int options,
364	IOVirtualAddress * logical, IOPhysicalAddress * physical );
365	extern IOReturn IOFreePhysicallyContiguousMemory( IOVirtualAddress * logical, unsigned int size);
366
367	#endif /* !defined(_IODBDMA_H_) */