[apple/xnu.git] / iokit / Drivers / network / drvMaceEnet / MaceEnet.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) 1995-1996 NeXT Software, Inc.
 *
 * Interface definition for the Mace Ethernet chip 
 *
 * HISTORY
 *
 * 16-Sept-97	 
 *	Created.
 */

#ifndef _MACEENET_H
#define _MACEENET_H

#include <IOKit/network/IOEthernetController.h>
#include <IOKit/network/IOEthernetInterface.h>
#include <IOKit/network/IOGatedOutputQueue.h>
#include <IOKit/IOInterruptEventSource.h>
#include <IOKit/IOTimerEventSource.h>
#include <IOKit/network/IOMbufMemoryCursor.h>
#include <IOKit/IODeviceMemory.h>
#include <IOKit/ppc/IODBDMA.h>
#include <string.h>			/* bcopy */

#if 0
#include <kern/kdebug.h>				/* Performance tracepoints */
#else
#define KERNEL_DEBUG(x,a,b,c,d,e)
#endif

#include "MaceEnetRegisters.h"

extern "C" {
#include <sys/param.h>
#include <sys/mbuf.h>
}

#if 0
#define IOLog kprintf
#endif

typedef void  *		IOPPCAddress;

typedef struct enet_dma_cmd_t
{
    IODBDMADescriptor		desc_seg[2];
} enet_dma_cmd_t;

typedef struct enet_txdma_cmd_t
{
    IODBDMADescriptor		desc_seg[4];
} enet_txdma_cmd_t;

class MaceEnet : public IOEthernetController
{
	OSDeclareDefaultStructors(MaceEnet)

private:
    volatile IOPPCAddress       ioBaseEnet;
    volatile IOPPCAddress		ioBaseEnetROM;
    volatile IODBDMAChannelRegisters 	*ioBaseEnetRxDMA;	
    volatile IODBDMAChannelRegisters 	*ioBaseEnetTxDMA;

    u_int16_t				chipId;	

    IOEthernetAddress		myAddress;
    IOEthernetInterface *	networkInterface;
	IOGatedOutputQueue *    transmitQueue;
	IOPacketQueue *			debugQueue;
	IOKernelDebugger *      debugger;
    bool					isPromiscuous;
    bool					multicastEnabled;
	bool					ready;
	bool					netifClient;
	bool					debugClient;
	bool					debugTxPoll;

    IOWorkLoop *            workLoop;
	IOInterruptEventSource *rxIntSrc;
	IOInterruptEventSource *txIntSrc;
	IOMemoryMap *			maps[MEMORY_MAP_COUNT];
	IOMemoryMap *			romMap;
	IONetworkStats *		netStats;
	IOTimerEventSource *	timerSrc;
	IOMbufBigMemoryCursor *	mbufCursor;

    struct mbuf *			txMbuf[TX_RING_LENGTH];
    struct mbuf *			rxMbuf[RX_RING_LENGTH];
	struct mbuf *			txDebuggerPkt;

    unsigned int			txCommandHead; /* Transmit ring descriptor index */
    unsigned int			txCommandTail;
    unsigned int       		txMaxCommand;		
    unsigned int			rxCommandHead;	/* Receive ring descriptor index */
    unsigned int			rxCommandTail;
    unsigned int        	rxMaxCommand;		

	struct {
		void	*ptr;
		u_int	size;
		void	*ptrReal;
		u_int	sizeReal;
	} dmaMemory;

    unsigned char *			dmaCommands;
    enet_txdma_cmd_t *		txDMACommands;		/* TX descriptor ring ptr */
    unsigned int			txDMACommandsPhys;

    enet_dma_cmd_t *		rxDMACommands;		/* RX descriptor ring ptr */
    unsigned int			rxDMACommandsPhys;

    u_int32_t				txWDInterrupts;
    u_int32_t				txWDTimeouts;
    bool					txWDForceReset;

    void *					debuggerPkt;
    u_int32_t				debuggerPktSize;
   
    u_int16_t				hashTableUseCount[64];
    u_int8_t         		hashTableMask[8];

	bool _allocateMemory();
	bool _initTxRing();
	bool _initRxRing();
	bool _initChip();
	void _resetChip();
	void _disableAdapterInterrupts();
	void _enableAdapterInterrupts();
	void _startChip();
	void _restartChip();
	void _stopReceiveDMA();
	void _stopTransmitDMA();
	bool _transmitPacket(struct mbuf * packet);
	bool _transmitInterruptOccurred(bool fDebugger = false);
	bool _receiveInterruptOccurred();
	bool _receivePackets(bool fDebugger);
	void _packetToDebugger(struct mbuf * packet, u_int size);
	bool _updateDescriptorFromMbuf(struct mbuf * m,  enet_dma_cmd_t *desc,
			bool isReceive);
	void _resetHashTableMask();
	void _addToHashTableMask(u_int8_t *addr);
	void _removeFromHashTableMask(u_int8_t *addr);
	void _updateHashTableMask();
#ifdef DEBUG
	void _dumpRegisters();
	void _dumpDesc(void * addr, u_int32_t size);
#endif
	IOReturn _setPromiscuousMode(IOEnetPromiscuousMode mode);
	void MaceEnet::_sendTestPacket();

	/*
	 * Kernel Debugger
	 */
	void _sendPacket(void *pkt, unsigned int pkt_len);
	void _receivePacket(void *pkt, unsigned int *pkt_len, unsigned int 
		timeout);

	bool resetAndEnable(bool enable);	
	void interruptOccurredForSource(IOInterruptEventSource *src, int count);
	void timeoutOccurred(IOTimerEventSource *timer);

public:
	virtual MaceEnet * MaceEnet::probe(IOService * provider,
                           unsigned int * score,
                           unsigned int * specificity);
	virtual bool init(OSDictionary * properties = 0);
	virtual bool start(IOService * provider);
	virtual void free();
	
    virtual bool         createWorkLoop();
    virtual IOWorkLoop * getWorkLoop() const;

	virtual IOReturn enable(IONetworkInterface * netif);
	virtual IOReturn disable(IONetworkInterface * netif);

	virtual IOReturn enable(IOKernelDebugger * debugger);
	virtual IOReturn disable(IOKernelDebugger * debugger);

	virtual IOReturn getHardwareAddress(IOEthernetAddress *addr);

	virtual IOReturn setMulticastMode(IOEnetMulticastMode mode);
	virtual IOReturn setMulticastList(IOEthernetAddress *addrs, UInt32 count);

	virtual IOReturn setPromiscuousMode(IOEnetPromiscuousMode mode);
	
	virtual IOOutputQueue * createOutputQueue();

	virtual UInt32 outputPacket(struct mbuf * m, void * param);

	virtual void sendPacket(void *pkt, UInt32 pkt_len);
	virtual void receivePacket(void *pkt, UInt32 *pkt_len, UInt32 timeout);

	virtual const OSString * newVendorString() const;
	virtual const OSString * newModelString() const;
	virtual const OSString * newRevisionString() const;
};

#if 0	// no power management stuff in IOKit yet.
/*
 * Power management methods. 
 */
- (IOReturn)getPowerState:(PMPowerState *)state_p;
- (IOReturn)setPowerState:(PMPowerState)state;
- (IOReturn)getPowerManagement:(PMPowerManagementState *)state_p;
- (IOReturn)setPowerManagement:(PMPowerManagementState)state;
#endif

/*
 * Performance tracepoints
 *
 * DBG_MACE_RXIRQ     	- Receive  ISR run time
 * DBG_MACE_TXIRQ     	- Transmit ISR run time
 * DBG_MACE_TXQUEUE     - Transmit packet passed from network stack
 * DBG_MACE_TXCOMPLETE  - Transmit packet sent
 * DBG_MACE_RXCOMPLETE  - Receive packet passed to network stack
 */
#define DBG_MACE_ENET		0x0800
#define DBG_MACE_RXIRQ 		DRVDBG_CODE(DBG_DRVNETWORK,(DBG_MACE_ENET+1)) 	
#define DBG_MACE_TXIRQ	 	DRVDBG_CODE(DBG_DRVNETWORK,(DBG_MACE_ENET+2))	
#define DBG_MACE_TXQUEUE 	DRVDBG_CODE(DBG_DRVNETWORK,(DBG_MACE_ENET+3))	
#define DBG_MACE_TXCOMPLETE	DRVDBG_CODE(DBG_DRVNETWORK,(DBG_MACE_ENET+4))	
#define DBG_MACE_RXCOMPLETE	DRVDBG_CODE(DBG_DRVNETWORK,(DBG_MACE_ENET+5))	

#endif /* !_MACEENET_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) 1995-1996 NeXT Software, Inc.
	24	*
	25	* Interface definition for the Mace Ethernet chip
	26	*
	27	* HISTORY
	28	*
	29	* 16-Sept-97
	30	* Created.
	31	*/
	32
	33	#ifndef _MACEENET_H
	34	#define _MACEENET_H
	35
	36	#include <IOKit/network/IOEthernetController.h>
	37	#include <IOKit/network/IOEthernetInterface.h>
	38	#include <IOKit/network/IOGatedOutputQueue.h>
	39	#include <IOKit/IOInterruptEventSource.h>
	40	#include <IOKit/IOTimerEventSource.h>
	41	#include <IOKit/network/IOMbufMemoryCursor.h>
	42	#include <IOKit/IODeviceMemory.h>
	43	#include <IOKit/ppc/IODBDMA.h>
	44	#include <string.h> /* bcopy */
	45
	46	#if 0
	47	#include <kern/kdebug.h> /* Performance tracepoints */
	48	#else
	49	#define KERNEL_DEBUG(x,a,b,c,d,e)
	50	#endif
	51
	52	#include "MaceEnetRegisters.h"
	53
	54	extern "C" {
	55	#include <sys/param.h>
	56	#include <sys/mbuf.h>
	57	}
	58
	59	#if 0
	60	#define IOLog kprintf
	61	#endif
	62
	63	typedef void * IOPPCAddress;
	64
65	typedef struct enet_dma_cmd_t
66	{
67	IODBDMADescriptor desc_seg[2];
68	} enet_dma_cmd_t;
69
70	typedef struct enet_txdma_cmd_t
71	{
72	IODBDMADescriptor desc_seg[4];
73	} enet_txdma_cmd_t;
74
75	class MaceEnet : public IOEthernetController
76	{
77	OSDeclareDefaultStructors(MaceEnet)
78
79	private:
80	volatile IOPPCAddress ioBaseEnet;
81	volatile IOPPCAddress ioBaseEnetROM;
82	volatile IODBDMAChannelRegisters *ioBaseEnetRxDMA;
83	volatile IODBDMAChannelRegisters *ioBaseEnetTxDMA;
84
85	u_int16_t chipId;
86
87	IOEthernetAddress myAddress;
88	IOEthernetInterface * networkInterface;
89	IOGatedOutputQueue * transmitQueue;
90	IOPacketQueue * debugQueue;
91	IOKernelDebugger * debugger;
92	bool isPromiscuous;
93	bool multicastEnabled;
94	bool ready;
95	bool netifClient;
96	bool debugClient;
97	bool debugTxPoll;
98
99	IOWorkLoop * workLoop;
100	IOInterruptEventSource *rxIntSrc;
101	IOInterruptEventSource *txIntSrc;
102	IOMemoryMap * maps[MEMORY_MAP_COUNT];
103	IOMemoryMap * romMap;
104	IONetworkStats * netStats;
105	IOTimerEventSource * timerSrc;
106	IOMbufBigMemoryCursor * mbufCursor;
107
108	struct mbuf * txMbuf[TX_RING_LENGTH];
109	struct mbuf * rxMbuf[RX_RING_LENGTH];
110	struct mbuf * txDebuggerPkt;
111
112	unsigned int txCommandHead; /* Transmit ring descriptor index */
113	unsigned int txCommandTail;
114	unsigned int txMaxCommand;
115	unsigned int rxCommandHead; /* Receive ring descriptor index */
116	unsigned int rxCommandTail;
117	unsigned int rxMaxCommand;
118
119	struct {
120	void *ptr;
121	u_int size;
122	void *ptrReal;
123	u_int sizeReal;
124	} dmaMemory;
125
126	unsigned char * dmaCommands;
127	enet_txdma_cmd_t * txDMACommands; /* TX descriptor ring ptr */
128	unsigned int txDMACommandsPhys;
129
130	enet_dma_cmd_t * rxDMACommands; /* RX descriptor ring ptr */
131	unsigned int rxDMACommandsPhys;
132
133	u_int32_t txWDInterrupts;
134	u_int32_t txWDTimeouts;
135	bool txWDForceReset;
136
137	void * debuggerPkt;
138	u_int32_t debuggerPktSize;
139
140	u_int16_t hashTableUseCount[64];
141	u_int8_t hashTableMask[8];
142
143	bool _allocateMemory();
144	bool _initTxRing();
145	bool _initRxRing();
146	bool _initChip();
147	void _resetChip();
148	void _disableAdapterInterrupts();
149	void _enableAdapterInterrupts();
150	void _startChip();
151	void _restartChip();
152	void _stopReceiveDMA();
153	void _stopTransmitDMA();
154	bool _transmitPacket(struct mbuf * packet);
155	bool _transmitInterruptOccurred(bool fDebugger = false);
156	bool _receiveInterruptOccurred();
157	bool _receivePackets(bool fDebugger);
158	void _packetToDebugger(struct mbuf * packet, u_int size);
159	bool _updateDescriptorFromMbuf(struct mbuf * m, enet_dma_cmd_t *desc,
160	bool isReceive);
161	void _resetHashTableMask();
162	void _addToHashTableMask(u_int8_t *addr);
163	void _removeFromHashTableMask(u_int8_t *addr);
164	void _updateHashTableMask();
165	#ifdef DEBUG
166	void _dumpRegisters();
167	void _dumpDesc(void * addr, u_int32_t size);
168	#endif
169	IOReturn _setPromiscuousMode(IOEnetPromiscuousMode mode);
170	void MaceEnet::_sendTestPacket();
171
172	/*
173	* Kernel Debugger
174	*/
175	void _sendPacket(void *pkt, unsigned int pkt_len);
176	void _receivePacket(void pkt, unsigned int pkt_len, unsigned int
177	timeout);
178
179	bool resetAndEnable(bool enable);
180	void interruptOccurredForSource(IOInterruptEventSource *src, int count);
181	void timeoutOccurred(IOTimerEventSource *timer);
182
183	public:
184	virtual MaceEnet * MaceEnet::probe(IOService * provider,
185	unsigned int * score,
186	unsigned int * specificity);
187	virtual bool init(OSDictionary * properties = 0);
188	virtual bool start(IOService * provider);
189	virtual void free();
190
191	virtual bool createWorkLoop();
192	virtual IOWorkLoop * getWorkLoop() const;
193
194	virtual IOReturn enable(IONetworkInterface * netif);
195	virtual IOReturn disable(IONetworkInterface * netif);
196
197	virtual IOReturn enable(IOKernelDebugger * debugger);
198	virtual IOReturn disable(IOKernelDebugger * debugger);
199
200	virtual IOReturn getHardwareAddress(IOEthernetAddress *addr);
201
202	virtual IOReturn setMulticastMode(IOEnetMulticastMode mode);
203	virtual IOReturn setMulticastList(IOEthernetAddress *addrs, UInt32 count);
204
205	virtual IOReturn setPromiscuousMode(IOEnetPromiscuousMode mode);
206
207	virtual IOOutputQueue * createOutputQueue();
208
209	virtual UInt32 outputPacket(struct mbuf * m, void * param);
210
211	virtual void sendPacket(void *pkt, UInt32 pkt_len);
212	virtual void receivePacket(void pkt, UInt32 pkt_len, UInt32 timeout);
213
214	virtual const OSString * newVendorString() const;
215	virtual const OSString * newModelString() const;
216	virtual const OSString * newRevisionString() const;
217	};
218
219	#if 0 // no power management stuff in IOKit yet.
220	/*
221	* Power management methods.
222	*/
223	- (IOReturn)getPowerState:(PMPowerState *)state_p;
224	- (IOReturn)setPowerState:(PMPowerState)state;
225	- (IOReturn)getPowerManagement:(PMPowerManagementState *)state_p;
226	- (IOReturn)setPowerManagement:(PMPowerManagementState)state;
227	#endif
228
229	/*
230	* Performance tracepoints
231	*
232	* DBG_MACE_RXIRQ - Receive ISR run time
233	* DBG_MACE_TXIRQ - Transmit ISR run time
234	* DBG_MACE_TXQUEUE - Transmit packet passed from network stack
235	* DBG_MACE_TXCOMPLETE - Transmit packet sent
236	* DBG_MACE_RXCOMPLETE - Receive packet passed to network stack
237	*/
238	#define DBG_MACE_ENET 0x0800
239	#define DBG_MACE_RXIRQ DRVDBG_CODE(DBG_DRVNETWORK,(DBG_MACE_ENET+1))
240	#define DBG_MACE_TXIRQ DRVDBG_CODE(DBG_DRVNETWORK,(DBG_MACE_ENET+2))
241	#define DBG_MACE_TXQUEUE DRVDBG_CODE(DBG_DRVNETWORK,(DBG_MACE_ENET+3))
242	#define DBG_MACE_TXCOMPLETE DRVDBG_CODE(DBG_DRVNETWORK,(DBG_MACE_ENET+4))
243	#define DBG_MACE_RXCOMPLETE DRVDBG_CODE(DBG_DRVNETWORK,(DBG_MACE_ENET+5))
244
245	#endif /* !_MACEENET_H */