#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++;