#include <AT91SAM7S256.H> /* AT91SAMT7S64 definitions */
#include <lib_AT91SAM7S256.h>
/*
* Main Program
*/
int i;
__irq void isrUDP(void)
{
unsigned int status = AT91C_BASE_UDP->UDP_ISR;
AT91PS_UDP pUDP = AT91C_BASE_UDP;
AT91_REG isr = pUDP->UDP_ISR;
AT91_REG csr = pUDP->UDP_CSR[0]; //rejestr csr endpointu 0
if (isr&AT91C_UDP_EPINT0)
{
if (i)
{
AT91C_BASE_PIOA->PIO_SODR = 1;
i = 0;
}
else
{
AT91C_BASE_PIOA->PIO_CODR = 1;
i = 1;
}
}
AT91C_BASE_UDP->UDP_CSR[0] = (0<<AT91C_UDP_RXSETUP);
AT91C_BASE_AIC->AIC_EOICR = status;
}

int main (void) {
AT91C_BASE_PIOA->PIO_PER = (1 << AT91C_PIO_PA0);
AT91C_BASE_PIOA->PIO_OER = 0x00000001;
AT91C_BASE_PMC->PMC_PCER = (1UL << AT91C_ID_PIOA);

// Set the PLL USB Divider
AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1;
AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_UDP; //Разрешили частоту на UDP
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP);

AT91C_BASE_UDP->UDP_RSTEP = (1 << 0);
AT91C_BASE_UDP->UDP_RSTEP = 0;
AT91C_BASE_UDP->UDP_CSR[0] = AT91C_UDP_EPTYPE_CTRL;
AT91C_BASE_UDP->UDP_CSR[0] = AT91C_UDP_EPEDS;

// Enable UDP PullUp (USB_DP_PUP) : enable & Clear of the corresponding PIO
// Set in PIO mode and Configure in Output
AT91F_PIO_CfgOutput(AT91C_BASE_PIOA,AT91C_PIO_PA16);
// Clear for set the Pul up resistor
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA,AT91C_PIO_PA16);

AT91C_BASE_UDP->UDP_IMR = AT91C_UDP_ENDBUSRES|AT91C_UDP_EPINT0;
AT91C_BASE_AIC->AIC_SVR[AT91C_ID_UDP] = (unsigned int)isrUDP;
AT91C_BASE_AIC->AIC_SMR[AT91C_ID_UDP] = 6;
AT91C_BASE_AIC->AIC_IECR = (1UL << AT91C_ID_UDP);

// Loop forever
for (;;)
{
}
}

    AIC_ConfigureIT(AT91C_ID_UDP, 0, USBD_InterruptHandler);
    AIC_EnableIT(AT91C_ID_UDP);

void AIC_ConfigureIT(
    unsigned int source,
    unsigned int mode,
    void (*handler)(void))
{
    // Disable the interrupt first
    AT91C_BASE_AIC->AIC_IDCR = 1 << source;

    // Configure mode and handler
    AT91C_BASE_AIC->AIC_SMR[source] = mode;
    AT91C_BASE_AIC->AIC_SVR[source] = (unsigned int) handler;

    // Clear interrupt
    AT91C_BASE_AIC->AIC_ICCR = 1 << source;
}

if (length > USBGenericDescriptor_GetLength((USBGenericDescriptor *) pDevice)) {

                length = USBGenericDescriptor_GetLength((USBGenericDescriptor *) pDevice);
            }

/// Bitmap for all status bits in CSR.
#define REG_NO_EFFECT_1_ALL AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1 \
|AT91C_UDP_STALLSENT | AT91C_UDP_RXSETUP \
|AT91C_UDP_TXCOMP

/// Clears the specified bit(s) in the UDP_CSR register.
/// \param endpoint The endpoint number of the CSR to process.
/// \param flags The bitmap to set to 1.
#define SET_CSR(endpoint, flags) \
{ \
volatile unsigned int reg; \
reg = AT91C_BASE_UDP->UDP_CSR[endpoint]; \
reg |= REG_NO_EFFECT_1_ALL; \
reg |= (flags); \
AT91C_BASE_UDP->UDP_CSR[endpoint] = reg; \
while ( (AT91C_BASE_UDP->UDP_CSR[endpoint] & (flags)) != (flags)); \
}

/// Sets the specified bit(s) in the UDP_CSR register.
/// \param endpoint The endpoint number of the CSR to process.
/// \param flags The bitmap to clear to 0.
#define CLEAR_CSR(endpoint, flags) \
{ \
volatile unsigned int reg; \
reg = AT91C_BASE_UDP->UDP_CSR[endpoint]; \
reg |= REG_NO_EFFECT_1_ALL; \
reg &= ~(flags); \
AT91C_BASE_UDP->UDP_CSR[endpoint] = reg; \
while ( (AT91C_BASE_UDP->UDP_CSR[endpoint] & (flags)) == (flags)); \
}

//------------------------------------------------------------------------------
/// Структура конечных точек
//------------------------------------------------------------------------------
typedef struct {
unsigned short size;
char *pData;
unsigned int remaining;
unsigned char state;
}sEndpoint;
sEndpoint Endpoint[4];


//------------------------------------------------------------------------------
/// Заполнение FIFO буфера конечной точки
//------------------------------------------------------------------------------
static void USB_WriteFIFO(unsigned char EndpointNum)
{
signed int size = Endpoint[EndpointNum].size;
if (Endpoint[EndpointNum].remaining < size)
{
size = Endpoint[EndpointNum].remaining;
}
Endpoint[EndpointNum].remaining -= size;
while (size > 0) {
AT91C_BASE_UDP->UDP_FDR[EndpointNum] = *(Endpoint[EndpointNum].pData);
Endpoint[EndpointNum].pData++;
size--;
}
}

//------------------------------------------------------------------------------
/// Подготовка данных
//------------------------------------------------------------------------------
static char USB_PrepareTransfer(unsigned char EndpointNum, const void *pData,unsigned int Length)
{ if (Endpoint[EndpointNum].state != UDP_ENDPOINT_IDLE) {
return 0;
}
Endpoint[EndpointNum].remaining = Length;
Endpoint[EndpointNum].pData = (void *)pData;
while((AT91C_BASE_UDP->UDP_CSR[EndpointNum]&AT91C_UDP_TXPKTRDY)==AT91C_UDP_TXPKTRDY);
Endpoint[EndpointNum].state = UDP_ENDPOINT_SENDING;
USB_WriteFIFO(EndpointNum);
SET_CSR(EndpointNum, AT91C_UDP_TXPKTRDY); // Enable interrupt on endpoint
AT91C_BASE_UDP->UDP_IER = 1 << EndpointNum;
return 1;
}
//------------------------------------------------------------------------------
/// Если прерывание isrUDP возникло от конечной точки
//------------------------------------------------------------------------------
static void UDP_EndpointHandler(unsigned char EndpointNum)
{ unsigned int status = AT91C_BASE_UDP->UDP_CSR[EndpointNum];
if ((status & AT91C_UDP_TXCOMP) != 0)
{ cnt++; //Так я понял, что TXCOMP возникает только один раз
if (cnt == 2)
{
LED_Toggle(2);
}
if (Endpoint[EndpointNum].state == UDP_ENDPOINT_SENDING)
{
if (Endpoint[EndpointNum].remaining != 0) //Не все данные переданы
{
USB_WriteFIFO(EndpointNum);
SET_CSR(EndpointNum, AT91C_UDP_TXPKTRDY); //После этой строки больше TXCOMP не приходит
CLEAR_CSR(EndpointNum, AT91C_UDP_TXCOMP);
}
else
{
Endpoint[EndpointNum].state = UDP_ENDPOINT_IDLE;
CLEAR_CSR(EndpointNum, AT91C_UDP_TXCOMP);
}
}
else
{
CLEAR_CSR(EndpointNum, AT91C_UDP_TXCOMP);
}
}
if ((status & AT91C_UDP_RXSETUP) != 0)
{
if (count!=0){return;}
count++;
UDP_ReadRequest(&request);
if ((request.bmRequestType & 0x80) != 0)
{
SET_CSR(EndpointNum, AT91C_UDP_DIR); //меняем направление передачи данных
}
CLEAR_CSR(EndpointNum, AT91C_UDP_RXSETUP);
UDP_RequestReceived(&request);
}
}

//------------------------------------------------------------------------------
/// Обработчик прерывания AT91C_BASE_UDP
//------------------------------------------------------------------------------
__irq void isrUDP(void)
{
unsigned int status;
status = AT91C_BASE_UDP->UDP_ISR;
status &= AT91C_BASE_UDP->UDP_IMR;
//Если прерывание по концу сброса шины:
if ((status & AT91C_UDP_ENDBUSRES) != 0)
{
// Enables the UDP transceiver.
AT91C_BASE_UDP->UDP_TXVC = (1 << AT91C_UDP_TXVDIS);
// Configure Endpoint 0 for CONTROL Transaction
ConfigureEndpoint(0);
//Reset ENDBUSRES interrupt
AT91C_BASE_UDP->UDP_ICR |= (unsigned int) 0x1 << 12;
}
//Если прерывание по восстановлению активности на шине:
else if ((status & (AT91C_UDP_WAKEUP | AT91C_UDP_RXRSM)) != 0)
{
AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_WAKEUP | AT91C_UDP_RXRSM;
AT91C_BASE_UDP->UDP_IDR = AT91C_UDP_WAKEUP | AT91C_UDP_RXRSM;
}
//Если прерывание от конечной точки:
else if ((status & AT91C_UDP_EPINT0) != 0)
{
UDP_EndpointHandler(0);
}
//Прерывание выполнено
AT91C_BASE_AIC->AIC_EOICR = status;
}

/// Bitmap for all status bits in CSR.
#define REG_NO_EFFECT_1_ALL AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1 \
|AT91C_UDP_STALLSENT | AT91C_UDP_RXSETUP \
|AT91C_UDP_TXCOMP

/// Clears the specified bit(s) in the UDP_CSR register.
/// \param endpoint The endpoint number of the CSR to process.
/// \param flags The bitmap to set to 1.
#define SET_CSR(endpoint, flags) \
{ \
volatile unsigned int reg; \
reg = AT91C_BASE_UDP->UDP_CSR[endpoint]; \
reg |= REG_NO_EFFECT_1_ALL; \
reg |= (flags); \
AT91C_BASE_UDP->UDP_CSR[endpoint] = reg; \
while ( (AT91C_BASE_UDP->UDP_CSR[endpoint] & (flags)) != (flags)); \
}

/// Sets the specified bit(s) in the UDP_CSR register.
/// \param endpoint The endpoint number of the CSR to process.
/// \param flags The bitmap to clear to 0.
#define CLEAR_CSR(endpoint, flags) \
{ \
volatile unsigned int reg; \
reg = AT91C_BASE_UDP->UDP_CSR[endpoint]; \
reg |= REG_NO_EFFECT_1_ALL; \
reg &= ~(flags); \
AT91C_BASE_UDP->UDP_CSR[endpoint] = reg; \
while ( (AT91C_BASE_UDP->UDP_CSR[endpoint] & (flags)) == (flags)); \
}

//------------------------------------------------------------------------------
/// Структура конечных точек
//------------------------------------------------------------------------------
typedef struct {
unsigned short size;
char *pData;
unsigned int remaining;
unsigned char state;
}sEndpoint;
sEndpoint Endpoint[4];

                        if (count!=0){return;}        
                        count++;

//------------------------------------------------------------------------------
/// Конфигурирование конечной точки
//------------------------------------------------------------------------------
static void ConfigureEndpoint(const int EndpointNum)
{
unsigned char Type;
unsigned char EndpointDir;
if (EndpointNum == 0)
{
Endpoint[EndpointNum].size=8;
Type= 0;
EndpointDir = 0;
}
else
{
//Other Endpoints
}

//Настройка регистра UDP_ CSRx [x = EndpointNumber]
SET_CSR(EndpointNum, (unsigned int)AT91C_UDP_EPEDS | (Type << 8) | (EndpointDir << 10));
Endpoint[EndpointNum].state = UDP_ENDPOINT_IDLE;
if (Type == 0) //Если точка контрольная, то разрешить прерывание EPxINT [x = EndpointNumber]
{
AT91C_BASE_UDP->UDP_IER = (1 << EndpointNum);
}
}

if (count!=0){return;}        
                        count++;

sizeof(USBConfigurationDescriptor)+sizeof(USBInterfaceDescriptor)

const DriverConfigurationDescriptors driverConfigurationDescriptor =
{
{
sizeof(USBConfigurationDescriptor),
USBGenericDescriptor_CONFIGURATION,
sizeof(DriverConfigurationDescriptors),
0, // No interface in this configuration
1, // This is configuration #1
0, // No string descriptor for this configuration
0,
USBConfigurationDescriptor_POWER(100)
},
{
sizeof(USBInterfaceDescriptor),
USBGenericDescriptor_INTERFACE,
0, // This is interface #0
0, // This is setting #0 for interface
2, // Interface has 2 endpoint
0, // No interface class code
0, // No interface subclass code
0, // No interface protocol code
0, // No string descriptor
},
{
sizeof(USBEndpointDescriptor),
USBGenericDescriptor_ENDPOINT,
(((0 & 0x01) << 7) | (1 & 0xF)),
2,
0x01,
0x00 // Does not apply to Bulk endpoints
},
// Bulk-IN endpoint descriptor
{
sizeof(USBEndpointDescriptor),
USBGenericDescriptor_ENDPOINT,
(((1 & 0x01) << 7) | (2 & 0xF)),
2,
0x01,
0x00 // Does not apply to Bulk endpoints
}

} ;

//------------------------------------------------------------------------------
/// Конфигурирование конечной точки
//------------------------------------------------------------------------------
static void ConfigureEndpoint0(void)
{
const int EndpointNum = 0;
AT91C_BASE_UDP->UDP_RSTEP = AT91C_UDP_EP0;
AT91C_BASE_UDP->UDP_RSTEP = 0;
Endpoint[EndpointNum].size=8;
SET_CSR(0,(unsigned int)AT91C_UDP_EPEDS | (0 << 8) | (0 << 7));
AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
AT91C_BASE_UDP->UDP_IER = (1 << EndpointNum);
}

//------------------------------------------------------------------------------
/// Конфигурирование конечной точки
//------------------------------------------------------------------------------
static void ConfigureEndpoint1(void)
{
const int EndpointNum = 1;
AT91C_BASE_UDP->UDP_RSTEP = AT91C_UDP_EP1;
AT91C_BASE_UDP->UDP_RSTEP = 0;
Endpoint[EndpointNum].size=64;
SET_CSR(1,(unsigned int)AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_OUT | (1<<7));
AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
}

//------------------------------------------------------------------------------
/// Конфигурирование конечной точки
//------------------------------------------------------------------------------
static void ConfigureEndpoint2(void)
{
const int EndpointNum = 2;
AT91C_BASE_UDP->UDP_RSTEP = AT91C_UDP_EP2;
AT91C_BASE_UDP->UDP_RSTEP = 0;
Endpoint[EndpointNum].size=64;
SET_CSR(1,(unsigned int)AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_IN | (0<<7));
AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
}

unsigned char Send64BytePacket(unsigned char EndpointNum, const void *pData)
{
unsigned int Length;
//Подготовка данных
if((AT91C_BASE_UDP->UDP_CSR[EndpointNum] & AT91C_UDP_TXPKTRDY)==0)
{
Length = sizeof(pData);
if (Length%Endpoint[EndpointNum].size == 0)
            {
            Endpoint[EndpointNum].options = SEND_ZERO_LENGTH_PKT;
            }
Endpoint[EndpointNum].remaining = Length;
Endpoint[EndpointNum].pData = (void *)pData;
//Процесс передачи
while(Endpoint[EndpointNum].remaining!=0)
{
unsigned int status = AT91C_BASE_UDP->UDP_CSR[EndpointNum];    

        if ((status & AT91C_UDP_TXPKTRDY) == 0)
        {
                            if (Endpoint[EndpointNum].remaining != 0) //Не все данные переданы
                                {
                                USB_WriteFIFO(EndpointNum);
                                CLEAR_CSR(EndpointNum,AT91C_UDP_TXCOMP);
                                }
                            else
                                {
                                if (Endpoint[EndpointNum].options == SEND_ZERO_LENGTH_PKT)
                                                    {
                                                    LED_Toggle(0);
                                                    USB_PrepareTransfer(EndpointNum,0,0);
                                                    Endpoint[EndpointNum].options =0;
                                                    }
                                CLEAR_CSR(EndpointNum,AT91C_UDP_TXCOMP);
                                }
        }

}
}
return 1;
}

                      {
        sizeof(USBEndpointDescriptor),
        USBGenericDescriptor_ENDPOINT,
        (((0 & 0x01) << 7) | (2 & 0xF)),
        2,
        0x40,
        0x00                               // Does not apply to Bulk endpoints
                       }

static void ConfigureEndpoint1(void)
{
const int EndpointNum = 1;
AT91C_BASE_UDP->UDP_RSTEP = AT91C_UDP_EP1;
AT91C_BASE_UDP->UDP_RSTEP = 0;
Endpoint[EndpointNum].size=64;
SET_CSR(1,(unsigned int)AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_OUT);
AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
}

Length = sizeof(pData);

unsigned char Send64BytePacket(unsigned char EndpointNum, const void *pData)
{
char code,*data;
signed int d;
signed int size;
d = 0x1f044a;
size = sizeof(d);
data = (void *)&d;
while(AT91C_BASE_UDP->UDP_CSR[EndpointNum]&AT91C_UDP_TXPKTRDY);
while (size--)
{
AT91C_BASE_UDP->UDP_FDR[EndpointNum] = *data;
data++;    
}
SET_CSR(EndpointNum,AT91C_UDP_TXPKTRDY);

return 1;