/*----------------------------------------------------------------------------
 *  Copyright (c) 2001 by National Semiconductor Corporation
 *  National Semiconductor Corporation
 *  2900 Semiconductor Drive
 *  Santa Clara, California 95051
 *
 *  All rights reserved
 *
 *<<<-------------------------------------------------------------------------
 * File Contents:
 *	usb.c - USB related definitions
 *
 *  Project: USB Demo firmware
 *  Author : Yan Nosovitsky
 *  Date   : Jan 2001
 *----------------------------------------------------------------------->>>*/
#ifndef __usbdrv_h__
#define __usbdrv_h__


/*--------------------------------------------------------------------------*/
/*-------------------------------   Macros   -------------------------------*/
/*--------------------------------------------------------------------------*/

/* Flush and disable the USB TX 0/1/2 **************************************/
#define FLUSHTX0 {write_usb(TXC0,FLUSH);}
#define FLUSHTX1 {write_usb(TXC1,FLUSH);}
#define FLUSHTX2 {write_usb(TXC2,FLUSH);}
#define FLUSHTX3 {write_usb(TXC3,FLUSH);}


/* Flush and disable the USB RX 0/1/2 **************************************/
#define FLUSHRX0 {write_usb(RXC0,FLUSH);}
#define FLUSHRX1 {write_usb(RXC1,FLUSH);}
#define FLUSHRX2 {write_usb(RXC2,FLUSH);}

#define ENABLE_RX0 write_usb(RXC0,RX_EN);
#define ENABLE_RX1 write_usb(RXC1,RX_EN);
#define ENABLE_RX2 write_usb(RXC2,RX_EN);

#define ENABLE_TX0 write_usb(TXC0,TX_EN);
#define ENABLE_TX1 write_usb(TXC1,TX_EN);
#define ENABLE_TX2 write_usb(TXC2,TX_EN);

#define FLUSH_TXEP(ep_num)		write_usb(EP_TXC(ep_num), FLUSH)
#define FLUSH_RXEP(ep_num)		write_usb(EP_RXC(ep_num), FLUSH)

#define ENABLE_RX(ep_num)		write_usb(EP_RXC(ep_num), RX_EN)
#define DISABLE_RX(ep_num)		write_usb(EP_RXC(ep_num), read_usb(EP_RXC(ep_num)) & ~RX_EN)
#define ENABLE_TX(ep_num)		write_usb(EP_TXC(ep_num), TX_EN)
#define DISABLE_TX(ep_num)		write_usb(EP_TXC(ep_num), read_usb(EP_TXC(ep_num)) & ~TX_EN)


#define GOTO_STATE(state)		write_usb(NFSR, (state));

#define ATTACH_NODE	 			write_usb(MCNTRL, read_usb(MCNTRL) | NAT);
#define DETACH_NODE 			write_usb(MCNTRL, read_usb(MCNTRL) & ~NAT);

#define ENABLE_NODE_INTS(intr)	write_usb(MAMSK, (intr));
#define DISABLE_NODE_INTS		write_usb(MAMSK, 0);

#define ENABLE_ALT_INTS(intr)	write_usb(ALTMSK, (intr));
#define DISABLE_ALT_INTS(intr)	write_usb(ALTMSK, read_usb(ALTMSK)&~(intr));

#define ENABLE_NAK_INTS(intr)	write_usb(NAKMSK, (intr));
#define DISABLE_NAK_INTS(intr)	write_usb(NAKMSK, read_usb(NAKMSK)&~(intr));

#define ENABLE_TX_INTS(intr)		write_usb(TXMSK, read_usb(TXMSK)|(intr));
#define DISABLE_TX_INTS(intr)		write_usb(TXMSK, read_usb(TXMSK)&~(intr));

#define ENABLE_RX_INTS(intr)		write_usb(RXMSK, read_usb(RXMSK)|(intr));
#define DISABLE_RX_INTS(intr)		write_usb(RXMSK, read_usb(RXMSK)&~(intr));


#define ENABLE_VGE	 		write_usb(MCNTRL, read_usb(MCNTRL) | VGE);

#define SET_EP_ADDRESS(ep, addr)		write_usb((ep), (addr));

#define USB_DEVICE_ADDRESS_ENABLE		write_usb(FAR, read_usb(FAR) | AD_EN);
#define USB_DEVICE_ADDRESS_DISABLE		write_usb(FAR, read_usb(FAR) & ~AD_EN);
#define SET_USB_DEVICE_ADDRESS(addr)	write_usb(FAR, read_usb(FAR) | addr);//((addr) & ~AD_EN));

#define ENABLE_DEFAULT_ADDRESS	write_usb(EPC0, read_usb(EPC0) | DEF);
#define CLEAR_DEFAULT_ADDRESS	write_usb(EPC0, read_usb(EPC0) & ~DEF);

#define SET_DEVICE_STATE(dev, st)	(dev.state = st)
#define DEVICE_STATE(dev)		dev.state
#define SET_DEVICE_ADDRESS(dev, addr)	(dev.address = addr)
#define DEVICE_ADDRESS(dev)		dev.address

#define EP_FIFO_WRITE(ep_num, data)	write_usb(EP_TXD(ep_num), (data))
#define EP_FIFO_READ(ep_num)		read_usb(EP_RXD(ep_num))


#define CLEAR_STALL_EP0			write_usb(EPC0, read_usb(EPC0) & ~STALL)
#define IS_EP0_STALLED  		((read_usb(EPC0) & STALL) == STALL)

/* The macro may be used only for ENDPOINT_1 .. ENDPOINT_6 endpoints,
 * It's assumpted that diff between two EPC# and EPC#+1 is 4 bytes */
#define EPC_ADDR(ep_num)		EPC1 + (((ep_num) - ENDPOINT_1) << 2)
#define STALL_EP(ep_num) 		write_usb(EPC_ADDR(ep_num), read_usb(EPC_ADDR(ep_num)) | STALL)
#define CLEAR_STALL_EP(ep_num)  	write_usb(EPC_ADDR(ep_num), read_usb(EPC_ADDR(ep_num)) & ~STALL)
#define IS_EP_STALLED(ep_num)   	((read_usb(EPC_ADDR(ep_num)) & STALL) == STALL)

#define IS_EP_ISO(ep_num)			((read_usb(EPC_ADDR(ep_num)) & ISO) == ISO)
#define IS_EP_IN(ep_num)			(ep_num%2)
#define ENABLE_EP(ep_num)   		write_usb(EPC_ADDR(ep_num), read_usb(EPC_ADDR(ep_num)) | EP_EN)
#define DISABLE_EP(ep_num)   		write_usb(EPC_ADDR(ep_num), read_usb(EPC_ADDR(ep_num)) & ~EP_EN)

#define EP_TXSTATUS(ep_num)		read_usb(EP_TXS(ep_num))
#define EP_RXSTATUS(ep_num)		read_usb(EP_RXS(ep_num))

#define ALT_EVENTS			read_usb(ALTEV)
#define DMA_EVENTS			read_usb(DMAEV)
#define NAK_EVENTS			read_usb(NAKEV)
#define TX_EVENTS			read_usb(TXEV)
#define RX_EVENTS			read_usb(RXEV)

#define IS_REQ_INDEX_NOT_ZERO(req)  (REQ_INDEX(req).as_bytes.msb != 0x0 &&  REQ_INDEX(req).as_bytes.lsb != 0x0)   
#define IS_REQ_VALUE_NOT_ZERO(req)  (REQ_VALUE(req).as_bytes.msb != 0x0 &&  REQ_VALUE(req).as_bytes.lsb != 0x0)   

#define IS_TX_ENABLE(ep_num)	(read_usb(EP_TXC(ep_num) & TX_EN))
#define IS_RX_ENABLE(ep_num)	(read_usb(EP_RXC(ep_num) & RX_EN))

#define REFILL_FIFO(ep_num)	write_usb(EP_TXC(ep_num), read_usb(EP_TXC(ep_num) | RFF))	
#define	SET_LAST(ep_num) write_usb(EP_TXC(ep_num), read_usb(EP_TXC(ep_num) | LAST))
/*=======================================================================*/

#define TXEP_ADDR(ep_num)		usbn9604_tx_endpoint_addr[(ep_num)]
#define RXEP_ADDR(ep_num)		usbn9604_rx_endpoint_addr[(ep_num)]

#define EP_TXD(ep_num)			TXEP_ADDR(ep_num)
/* It's assumpted that TXS# is TXD#+1 */
#define EP_TXS(ep_num)			TXEP_ADDR(ep_num) + 1
/* It's assumpted that TXC# is TXD#+2 */
#define EP_TXC(ep_num)			TXEP_ADDR(ep_num) + 2

#define EP_RXD(ep_num)			RXEP_ADDR(ep_num)
/* It's assumpted that RXS# is RXD#+1 */
#define EP_RXS(ep_num)			RXEP_ADDR(ep_num) + 1
/* It's assumpted that RXC# is RXD#+2 */
#define EP_RXC(ep_num)			RXEP_ADDR(ep_num) + 2

								//20 MHz
								//4 cycles takes single for loop 
								//10s waiting threshold
#define WAITING_THRESHOLD		50000000

#define TX_EP_COUNTER(ep_num)	(read_usb(EP_TXS(ep_num)) & 0x1F)//20)
#define RX_EP_COUNTER(ep_num)	(read_usb(EP_RXS(ep_num)) & 0xF) //10)

#define NUM_OF_ENDPOINTS	7

#define EP0_FIFO_SIZE		8
#define RX_BULK_EP_FIFO_SIZE		64
#define TX_BULK_EP_FIFO_SIZE		64

#define RX_ISO_EP_FIFO_SIZE			64
#define TX_ISO_EP_FIFO_SIZE			64

#define RX_INTR_EP_FIFO_SIZE		1
#define TX_INTR_EP_FIFO_SIZE		1

#define BZERO(buf) memset(&(buf), 0, sizeof(buf))



/*============================================================================
 *					Definitons
 *============================================================================*/
typedef enum {
    ENDPOINT_0,
    ENDPOINT_1,
    ENDPOINT_2,
    ENDPOINT_3,
    ENDPOINT_4,
    ENDPOINT_5,
    ENDPOINT_6,
    ENDPOINT_LAST
} endpoint_t;

typedef struct {
	byte *data;
	unsigned int bytes_counter;//counter of data bytes currently stored in the buffer
}control_buffer_t;

typedef enum {
		EMPTY, 
		FULL, 
		WAIT_FOR_ACK
}FIFO_status_t;

typedef struct {
	FIFO_status_t FIFO_status;
	byte toggle_bit;
}endpoint_status_t;

/*--------------------------------------------------------------------------*/
/*------------------------------- External Interface -----------------------*/
/*--------------------------------------------------------------------------*/
byte USB_Receive_Data (byte* data_ptr,endpoint_t ep_num);
byte USB_Transmit_Data (int data_size, BYTE* data_ptr, endpoint_t ep_num); 
void USB_init_dma(endpoint_t endPoint);
void USB_start_dma(int DCOUNT);


/*====================================================================
 *							Prototypes
 *====================================================================*/
void usb_node_handler(void);
void usb_drq_handler(void);
void reset_usb(void);
void usb_device_reset(void);	

void clear_control_buffer(control_buffer_t* control_buff);
void fill_control_fifo();
__inline__ void USBN9604_tx_event_handler(void);
void USBN9604_alt_event_handler(void);
__inline__ void USBN9604_rx_event_handler(void);
void USB_device_req_handler(void);

void usbn9604_tx_enable(int ep_num);
void usbn9604_tx_retransmit_enable(int ep_num);
void endpoint_status_init();
void send_control_data(byte *data_ptr, int data_size);
void zero_length_data_response(endpoint_t ep_num);
__inline__ void STALL_EP0();




#endif __usbdrv_h__