[net-next-2.6.git] / drivers / staging / rt2860 / iface / rtmp_usb.h

/*
 *************************************************************************
 * Ralink Tech Inc.
 * 5F., No.36, Taiyuan St., Jhubei City,
 * Hsinchu County 302,
 * Taiwan, R.O.C.
 *
 * (c) Copyright 2002-2007, Ralink Technology, Inc.
 *
 * This program is free software; you can redistribute it and/or modify  *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation; either version 2 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * This program is distributed in the hope that it will be useful,       *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 * GNU General Public License for more details.                          *
 *                                                                       *
 * You should have received a copy of the GNU General Public License     *
 * along with this program; if not, write to the                         *
 * Free Software Foundation, Inc.,                                       *
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 *                                                                       *
 *************************************************************************
*/

#ifndef __RTMP_USB_H__
#define __RTMP_USB_H__

#include "../rtusb_io.h"

#ifdef LINUX
#include <linux/usb.h>

typedef struct usb_device *PUSB_DEV;
typedef struct urb *purbb_t;
typedef struct usb_ctrlrequest devctrlrequest;
#endif // LINUX //

extern UCHAR EpToQueue[6];

#define RXBULKAGGRE_ZISE			12
#define MAX_TXBULK_LIMIT			(LOCAL_TXBUF_SIZE*(BULKAGGRE_ZISE-1))
#define MAX_TXBULK_SIZE			(LOCAL_TXBUF_SIZE*BULKAGGRE_ZISE)
#define MAX_RXBULK_SIZE			(LOCAL_TXBUF_SIZE*RXBULKAGGRE_ZISE)
#define MAX_MLME_HANDLER_MEMORY 20

// Flags for Bulkflags control for bulk out data
//
#define	fRTUSB_BULK_OUT_DATA_NULL				0x00000001
#define	fRTUSB_BULK_OUT_RTS						0x00000002
#define	fRTUSB_BULK_OUT_MLME						0x00000004

#define	fRTUSB_BULK_OUT_PSPOLL					0x00000010
#define	fRTUSB_BULK_OUT_DATA_FRAG				0x00000020
#define	fRTUSB_BULK_OUT_DATA_FRAG_2				0x00000040
#define	fRTUSB_BULK_OUT_DATA_FRAG_3				0x00000080
#define	fRTUSB_BULK_OUT_DATA_FRAG_4				0x00000100

#define	fRTUSB_BULK_OUT_DATA_NORMAL				0x00010000
#define	fRTUSB_BULK_OUT_DATA_NORMAL_2			0x00020000
#define	fRTUSB_BULK_OUT_DATA_NORMAL_3			0x00040000
#define	fRTUSB_BULK_OUT_DATA_NORMAL_4			0x00080000

// TODO:move to ./ate/include/iface/ate_usb.h

#define FREE_HTTX_RING(_pCookie, _pipeId, _txContext)			\
{										\
	if ((_txContext)->ENextBulkOutPosition == (_txContext)->CurWritePosition)	\
	{																	\
		(_txContext)->bRingEmpty = TRUE;			\
	}																	\
	/*NdisInterlockedDecrement(&(_p)->TxCount); */\
}

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

	USB Bulk operation related definitions

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

#ifdef LINUX
#define BULKAGGRE_ZISE          100
#define RT28XX_PUT_DEVICE							usb_put_dev
#define RTUSB_ALLOC_URB(iso)							usb_alloc_urb(iso, GFP_ATOMIC)
#define RTUSB_SUBMIT_URB(pUrb)							usb_submit_urb(pUrb, GFP_ATOMIC)
#define RTUSB_URB_ALLOC_BUFFER(pUsb_Dev, BufSize, pDma_addr)			usb_buffer_alloc(pUsb_Dev, BufSize, GFP_ATOMIC, pDma_addr)
#define RTUSB_URB_FREE_BUFFER(pUsb_Dev, BufSize, pTransferBuf, Dma_addr)	usb_buffer_free(pUsb_Dev, BufSize, pTransferBuf, Dma_addr)

#define RTUSB_FREE_URB(pUrb)	usb_free_urb(pUrb)

// unlink urb
#define RTUSB_UNLINK_URB(pUrb)		usb_kill_urb(pUrb)

extern void dump_urb(struct urb *purb);

#define InterlockedIncrement		atomic_inc
#define NdisInterlockedIncrement	atomic_inc
#define InterlockedDecrement		atomic_dec
#define NdisInterlockedDecrement	atomic_dec
#define InterlockedExchange		atomic_set

#endif // LINUX //

#define NT_SUCCESS(status)			(((status) >=0) ? (TRUE):(FALSE))

#define USBD_TRANSFER_DIRECTION_OUT		0
#define USBD_TRANSFER_DIRECTION_IN		0
#define USBD_SHORT_TRANSFER_OK			0
#define PURB			purbb_t

#define PIRP		PVOID
#define NDIS_OID	UINT
#ifndef USB_ST_NOERROR
#define USB_ST_NOERROR     0
#endif

// vendor-specific control operations
#define CONTROL_TIMEOUT_JIFFIES ( (100 * OS_HZ) / 1000)
#define UNLINK_TIMEOUT_MS		3

VOID RTUSBBulkOutDataPacketComplete(purbb_t purb, struct pt_regs *pt_regs);
VOID RTUSBBulkOutMLMEPacketComplete(purbb_t pUrb, struct pt_regs *pt_regs);
VOID RTUSBBulkOutNullFrameComplete(purbb_t pUrb, struct pt_regs *pt_regs);
VOID RTUSBBulkOutRTSFrameComplete(purbb_t pUrb, struct pt_regs *pt_regs);
VOID RTUSBBulkOutPsPollComplete(purbb_t pUrb, struct pt_regs *pt_regs);
VOID RTUSBBulkRxComplete(purbb_t pUrb, struct pt_regs *pt_regs);

#ifdef KTHREAD_SUPPORT
#define RTUSBMlmeUp(pAd) \
	do{								    \
		RTMP_OS_TASK	*_pTask = &((pAd)->mlmeTask);\
		if (_pTask->kthread_task) \
        { \
			_pTask->kthread_running = TRUE; \
	        wake_up(&_pTask->kthread_q); \
		} \
	}while(0)
#else
#define RTUSBMlmeUp(pAd)	        \
	do{								    \
		RTMP_OS_TASK	*_pTask = &((pAd)->mlmeTask);\
		CHECK_PID_LEGALITY(_pTask->taskPID)		    \
		{ \
			RTMP_SEM_EVENT_UP(&(_pTask->taskSema)); \
		}\
	}while(0)
#endif

#ifdef KTHREAD_SUPPORT
#define RTUSBCMDUp(pAd) \
	do{	\
		RTMP_OS_TASK	*_pTask = &((pAd)->cmdQTask);	\
		{ \
			_pTask->kthread_running = TRUE; \
	        wake_up(&_pTask->kthread_q); \
		} \
	}while(0)

#else
#define RTUSBCMDUp(pAd)	                \
	do{									    \
		RTMP_OS_TASK	*_pTask = &((pAd)->cmdQTask);	\
		CHECK_PID_LEGALITY(_pTask->taskPID)	    \
		{\
			RTMP_SEM_EVENT_UP(&(_pTask->taskSema)); \
		}\
	}while(0)
#endif

#define DEVICE_VENDOR_REQUEST_OUT       0x40
#define DEVICE_VENDOR_REQUEST_IN        0xc0
//#define INTERFACE_VENDOR_REQUEST_OUT    0x41
//#define INTERFACE_VENDOR_REQUEST_IN     0xc1

#define BULKOUT_MGMT_RESET_FLAG		0x80

#define RTUSB_SET_BULK_FLAG(_M, _F)	((_M)->BulkFlags |= (_F))
#define RTUSB_CLEAR_BULK_FLAG(_M, _F)	((_M)->BulkFlags &= ~(_F))
#define RTUSB_TEST_BULK_FLAG(_M, _F)	(((_M)->BulkFlags & (_F)) != 0)

#define RTMP_IRQ_REQUEST(net_dev)		do{}while(0)
#define RTMP_IRQ_RELEASE(net_dev)		do{}while(0)

#endif // __RTMP_USB_H__ //
Commit	Line	Data
ca97b838 BZ	1	/*
	2	*************************************************************************
	3	* Ralink Tech Inc.
	4	* 5F., No.36, Taiyuan St., Jhubei City,
	5	* Hsinchu County 302,
	6	* Taiwan, R.O.C.
	7	*
	8	* (c) Copyright 2002-2007, Ralink Technology, Inc.
	9	*
	10	* This program is free software; you can redistribute it and/or modify *
	11	* it under the terms of the GNU General Public License as published by *
	12	* the Free Software Foundation; either version 2 of the License, or *
	13	* (at your option) any later version. *
	14	* *
	15	* This program is distributed in the hope that it will be useful, *
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	18	* GNU General Public License for more details. *
	19	* *
	20	* You should have received a copy of the GNU General Public License *
	21	* along with this program; if not, write to the *
	22	* Free Software Foundation, Inc., *
	23	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
	24	* *
	25	*************************************************************************
	26	*/
	27
	28	#ifndef __RTMP_USB_H__
	29	#define __RTMP_USB_H__
	30
ca97b838 BZ	31	#include "../rtusb_io.h"
ca97b838 BZ	32
ca97b838 BZ	33	#ifdef LINUX
	34	#include <linux/usb.h>
	35
52b81c89	36	typedef struct usb_device *PUSB_DEV;
ca97b838 BZ	37	typedef struct urb *purbb_t;
	38	typedef struct usb_ctrlrequest devctrlrequest;
	39	#endif // LINUX //
	40
	41	extern UCHAR EpToQueue[6];
	42
ca97b838 BZ	43	#define RXBULKAGGRE_ZISE 12
	44	#define MAX_TXBULK_LIMIT (LOCAL_TXBUF_SIZE*(BULKAGGRE_ZISE-1))
	45	#define MAX_TXBULK_SIZE (LOCAL_TXBUF_SIZE*BULKAGGRE_ZISE)
	46	#define MAX_RXBULK_SIZE (LOCAL_TXBUF_SIZE*RXBULKAGGRE_ZISE)
	47	#define MAX_MLME_HANDLER_MEMORY 20
	48
ca97b838 BZ	49	// Flags for Bulkflags control for bulk out data
	50	//
	51	#define fRTUSB_BULK_OUT_DATA_NULL 0x00000001
	52	#define fRTUSB_BULK_OUT_RTS 0x00000002
	53	#define fRTUSB_BULK_OUT_MLME 0x00000004
	54
	55	#define fRTUSB_BULK_OUT_PSPOLL 0x00000010
	56	#define fRTUSB_BULK_OUT_DATA_FRAG 0x00000020
	57	#define fRTUSB_BULK_OUT_DATA_FRAG_2 0x00000040
	58	#define fRTUSB_BULK_OUT_DATA_FRAG_3 0x00000080
	59	#define fRTUSB_BULK_OUT_DATA_FRAG_4 0x00000100
	60
	61	#define fRTUSB_BULK_OUT_DATA_NORMAL 0x00010000
	62	#define fRTUSB_BULK_OUT_DATA_NORMAL_2 0x00020000
	63	#define fRTUSB_BULK_OUT_DATA_NORMAL_3 0x00040000
	64	#define fRTUSB_BULK_OUT_DATA_NORMAL_4 0x00080000
	65
	66	// TODO:move to ./ate/include/iface/ate_usb.h
	67
ca97b838 BZ	68	#define FREE_HTTX_RING(_pCookie, _pipeId, _txContext) \
	69	{ \
	70	if ((_txContext)->ENextBulkOutPosition == (_txContext)->CurWritePosition) \
	71	{ \
	72	(_txContext)->bRingEmpty = TRUE; \
	73	} \
	74	/NdisInterlockedDecrement(&(_p)->TxCount); /\
	75	}
	76
ca97b838 BZ	77	/******************************************************************************
	78
	79	USB Bulk operation related definitions
	80
	81	******************************************************************************/
	82
	83	#ifdef LINUX
	84	#define BULKAGGRE_ZISE 100
	85	#define RT28XX_PUT_DEVICE usb_put_dev
	86	#define RTUSB_ALLOC_URB(iso) usb_alloc_urb(iso, GFP_ATOMIC)
	87	#define RTUSB_SUBMIT_URB(pUrb) usb_submit_urb(pUrb, GFP_ATOMIC)
	88	#define RTUSB_URB_ALLOC_BUFFER(pUsb_Dev, BufSize, pDma_addr) usb_buffer_alloc(pUsb_Dev, BufSize, GFP_ATOMIC, pDma_addr)
	89	#define RTUSB_URB_FREE_BUFFER(pUsb_Dev, BufSize, pTransferBuf, Dma_addr) usb_buffer_free(pUsb_Dev, BufSize, pTransferBuf, Dma_addr)
	90
	91	#define RTUSB_FREE_URB(pUrb) usb_free_urb(pUrb)
	92
	93	// unlink urb
	94	#define RTUSB_UNLINK_URB(pUrb) usb_kill_urb(pUrb)
	95
52b81c89	96	extern void dump_urb(struct urb *purb);
ca97b838 BZ	97
	98	#define InterlockedIncrement atomic_inc
	99	#define NdisInterlockedIncrement atomic_inc
	100	#define InterlockedDecrement atomic_dec
	101	#define NdisInterlockedDecrement atomic_dec
	102	#define InterlockedExchange atomic_set
	103
	104	#endif // LINUX //
	105
ca97b838 BZ	106	#define NT_SUCCESS(status) (((status) >=0) ? (TRUE):(FALSE))
ca97b838 BZ	107
ca97b838 BZ	108	#define USBD_TRANSFER_DIRECTION_OUT 0
	109	#define USBD_TRANSFER_DIRECTION_IN 0
	110	#define USBD_SHORT_TRANSFER_OK 0
	111	#define PURB purbb_t
	112
	113	#define PIRP PVOID
	114	#define NDIS_OID UINT
	115	#ifndef USB_ST_NOERROR
	116	#define USB_ST_NOERROR 0
	117	#endif
	118
	119	// vendor-specific control operations
	120	#define CONTROL_TIMEOUT_JIFFIES ( (100 * OS_HZ) / 1000)
	121	#define UNLINK_TIMEOUT_MS 3
	122
ca97b838 BZ	123	VOID RTUSBBulkOutDataPacketComplete(purbb_t purb, struct pt_regs *pt_regs);
	124	VOID RTUSBBulkOutMLMEPacketComplete(purbb_t pUrb, struct pt_regs *pt_regs);
	125	VOID RTUSBBulkOutNullFrameComplete(purbb_t pUrb, struct pt_regs *pt_regs);
	126	VOID RTUSBBulkOutRTSFrameComplete(purbb_t pUrb, struct pt_regs *pt_regs);
	127	VOID RTUSBBulkOutPsPollComplete(purbb_t pUrb, struct pt_regs *pt_regs);
	128	VOID RTUSBBulkRxComplete(purbb_t pUrb, struct pt_regs *pt_regs);
	129
ca97b838 BZ	130	#ifdef KTHREAD_SUPPORT
	131	#define RTUSBMlmeUp(pAd) \
	132	do{ \
	133	RTMP_OS_TASK *_pTask = &((pAd)->mlmeTask);\
	134	if (_pTask->kthread_task) \
	135	{ \
	136	_pTask->kthread_running = TRUE; \
	137	wake_up(&_pTask->kthread_q); \
	138	} \
	139	}while(0)
	140	#else
	141	#define RTUSBMlmeUp(pAd) \
	142	do{ \
	143	RTMP_OS_TASK *_pTask = &((pAd)->mlmeTask);\
	144	CHECK_PID_LEGALITY(_pTask->taskPID) \
	145	{ \
	146	RTMP_SEM_EVENT_UP(&(_pTask->taskSema)); \
	147	}\
	148	}while(0)
	149	#endif
	150
	151	#ifdef KTHREAD_SUPPORT
	152	#define RTUSBCMDUp(pAd) \
	153	do{ \
	154	RTMP_OS_TASK *_pTask = &((pAd)->cmdQTask); \
	155	{ \
	156	_pTask->kthread_running = TRUE; \
	157	wake_up(&_pTask->kthread_q); \
	158	} \
	159	}while(0)
	160
	161	#else
	162	#define RTUSBCMDUp(pAd) \
	163	do{ \
	164	RTMP_OS_TASK *_pTask = &((pAd)->cmdQTask); \
	165	CHECK_PID_LEGALITY(_pTask->taskPID) \
	166	{\
	167	RTMP_SEM_EVENT_UP(&(_pTask->taskSema)); \
	168	}\
	169	}while(0)
	170	#endif
	171
	172	#define DEVICE_VENDOR_REQUEST_OUT 0x40
	173	#define DEVICE_VENDOR_REQUEST_IN 0xc0
	174	//#define INTERFACE_VENDOR_REQUEST_OUT 0x41
	175	//#define INTERFACE_VENDOR_REQUEST_IN 0xc1
	176
	177	#define BULKOUT_MGMT_RESET_FLAG 0x80
	178
	179	#define RTUSB_SET_BULK_FLAG(_M, _F) ((_M)->BulkFlags \|= (_F))
	180	#define RTUSB_CLEAR_BULK_FLAG(_M, _F) ((_M)->BulkFlags &= ~(_F))
	181	#define RTUSB_TEST_BULK_FLAG(_M, _F) (((_M)->BulkFlags & (_F)) != 0)
	182
	183	#define RTMP_IRQ_REQUEST(net_dev) do{}while(0)
	184	#define RTMP_IRQ_RELEASE(net_dev) do{}while(0)
	185
ca97b838	186	#endif // __RTMP_USB_H__ //