SAM7x256 & USB Опции

[Timofey]

Код на прием такой

Код

uint AT91F_UDP_Read(AT91PS_CDC pCdc, char *pData, uint length)
{
AT91PS_UDP pUdp = pCdc->pUdp;
uint packetSize, nbBytesRcv = 0, currentReceiveBank = pCdc->currentRcvBank;
if ((pUdp->UDP_CSR[AT91C_EP_OUT] & AT91C_UDP_RX_DATA_BK0)||(pUdp->UDP_CSR[AT91C_EP_OUT] & AT91C_UDP_RX_DATA_BK1))
{
  return 0;//то есть, если не было ни одного пакета принято, то просто выходим
}
while (length) {
  if ( !AT91F_UDP_IsConfigured(pCdc) )
   break;
  if ( pUdp->UDP_CSR[AT91C_EP_OUT] & currentReceiveBank ) {
   packetSize = MIN(pUdp->UDP_CSR[AT91C_EP_OUT] >> 16, length);
   length -= packetSize;
   if (packetSize < AT91C_EP_OUT_SIZE)
    length = 0;
   while(packetSize--)
    pData[nbBytesRcv++] = pUdp->UDP_FDR[AT91C_EP_OUT];
   pUdp->UDP_CSR[AT91C_EP_OUT] &= ~(currentReceiveBank);
   if (currentReceiveBank == AT91C_UDP_RX_DATA_BK0)
    currentReceiveBank = AT91C_UDP_RX_DATA_BK1;
   else
    currentReceiveBank = AT91C_UDP_RX_DATA_BK0;</P> <P>  }
}
        pUdp->UDP_CSR[AT91C_EP_OUT] &= ~(AT91C_UDP_TXCOMP);
pCdc->currentRcvBank = currentReceiveBank;
return nbBytesRcv;</P> <P>}

код на передачу

Код

uint AT91F_UDP_Write(AT91PS_CDC pCdc, const char *pData, uint length)
{
AT91PS_UDP pUdp = pCdc->pUdp;
uint cpt = 0;</P> <P>        if ((pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXPKTRDY))
{
  return 0;//если усб готово к передаче, то начинаем её
}
pUdp->UDP_CSR[AT91C_EP_IN] &= ~(AT91C_UDP_TXCOMP);
cpt = MIN(length, AT91C_EP_IN_SIZE);
length -= cpt;
while (cpt--) pUdp->UDP_FDR[AT91C_EP_IN] = *pData++;
pUdp->UDP_CSR[AT91C_EP_IN] |= AT91C_UDP_TXPKTRDY;</P> <P> while (length) {
  cpt = MIN(length, AT91C_EP_IN_SIZE);
  length -= cpt;
  while (cpt--) pUdp->UDP_FDR[AT91C_EP_IN] = *pData++;
  while ( !(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP) )
   if ( !AT91F_UDP_IsConfigured(pCdc) ) return length;
  pUdp->UDP_CSR[AT91C_EP_IN] &= ~(AT91C_UDP_TXCOMP);
  while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP);
  pUdp->UDP_CSR[AT91C_EP_IN] |= AT91C_UDP_TXPKTRDY;
}
return length;
}

в основном цикле я поочередно вызываю сначала чтение, потом запись. И получается, что посылка отправляется только тогда, когда произойдет прием посылки. Если убрать чтение в основном цикле, то передача идет всегда. Почему так? Мне нужно принимать контроллером всего 2 байта, а передавать 256, друг за другом. Причем 2 байта могут быть посланы контроллеру не всегда.
получается следующее

Код

pCDC.Read(&pCDC, ((char *) &data_comp), 2);
if ((length>256))
      {
pCDC.Write(&pCDC, data, length);
}

обнаружилось, что данные все таки доходят до микроконтроллера, а вот он на комп ничего не отправляет. убирая строчку чтения, получаем, что данные на комп все таки идут

[prottoss]

Всем доброго времени суток. Не стал открывать новую тему, потому как название как раз для моей С USB работал, поднимал на PDIUSBD12 по прерываниям, да и на ARM тоже по примерам от атмела (Без прерываний). Но вот с прерываниями затык полный, не получается.
После подключения девайса:
1. Два раза AT91C_UDP_ENDBUSRES;
2. Прерывание от ЕР0. Хост делает запрос GET DEVICE DESCRIPTOR, отсылаю в прерывании первые 8 байт дескриптора устройства;
3. Прерывание AT91C_UDP_TXCOMP; Отсылаю вторые 8 байт;
4. Прерывание AT91C_UDP_RX_DATA_BK0; Пока что ничего с ним не делаю, просто очищаю флаг.
5. Прерывание от ЕР0. Хост делает запрос SET ADDRESS c полем wValue = 0! ; Отсылаю нулевой пакет.
6. Прерывание AT91C_UDP_TXCOMP; Очищаю.

Далее три раза то же самое, и "Устройство USB работает не правильно... бла-бла-бла". Дескриптор устройства верный, опробованный, объявлен между #pragma pack(align 8) (компилятор IAR 5.4). Перелопатил все темы форума, связанные с SAM7 и USB по прерываниям. Все вроде правильно делаю, но, похоже что то не доделываю. Ниже код прерывания и записи в конечную точку.

Код

/*****************************************************************************
Main UDP interrupt handler.
******************************************************************************/
static void ISR_Handler(void)
{    
      UINT32 isr;
    
      /* Read interrupt status register and check events */
      isr = AT91C_BASE_UDP->UDP_ISR;
    
    /* USB bus reset event */
    if(AT91C_UDP_ENDBUSRES & isr)    
    {    
          DBG_OUT("USB bus reset!\r\n");
        
        /* Disable and clear all interruptions, reverting to the base state */
          AT91C_BASE_UDP->UDP_IDR = MAXUINT32;
        AT91C_BASE_UDP->UDP_ICR = MAXUINT32;
          
        /* Reset all endpoints FIFOs */
          AT91C_BASE_UDP->UDP_RSTEP = MAXUINT32;    
        AT91C_BASE_UDP->UDP_RSTEP = 0;
        
        /* Reset EP0 to a basic control endpoint */
        AT91C_UDP_CSR[0] = AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL;
        while (AT91C_UDP_CSR[0] != (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL));
        
        /* Enable interrupt for control enpoint (0) events.
        Other interrupts get enabled as the enumeration process complete */
        AT91C_BASE_UDP->UDP_IER = AT91C_UDP_EPINT0;
        
        /* Enable the function endpoints, setting address 0, and return
         immediately. Given that we've just reset everything, there's no
         point in continuing. */
        AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
        AT91C_BASE_UDP->UDP_TXVC = 0;    /* Enable tranceiver */
        USB_State.curr_cfg = 0;    /* Clear current configuration */
    }

    /* Check endpoints events */
    if(AT91C_UDP_EPINT0 & isr)
          EV_EP0Int();
    
    AT91C_BASE_AIC->AIC_ICCR  = 1 << AT91C_ID_UDP;
}

/*******************************************************************************
Control endpoint interrupt event
*******************************************************************************/
static void EV_EP0Int(void)
{    
      UINT32 csr;
        
    csr = AT91C_BASE_UDP->UDP_CSR[0];    /* Get endpoint status and check events */
    
    /* A setup data packet has been sent by the host and is available in the FIFO */
    if(AT91C_UDP_RXSETUP & csr)
        Enumerate();    /* Call USB routine (notify that setup paket received)*/
    
    /* Receive Data from Bank's */
    if(AT91C_UDP_RX_DATA_BK0 & csr)
    {    
          DBG_OUT("ISR EP0 RX0\r\n");    
          UDP_EP_CLR_FLAG(0, AT91C_UDP_RX_DATA_BK0);    /* Notify USB peripheral device that data have been read */    
        USB_State.tx_len[0] = 0;    /* Stop Tx transfer */
    }
    if(AT91C_UDP_RX_DATA_BK1 & csr)
    {    
          DBG_OUT("ISR EP0 RX1\r\n");    
          UDP_EP_CLR_FLAG(0, AT91C_UDP_RX_DATA_BK1);    /* Notify USB peripheral device that data have been read */
        USB_State.tx_len[0] = 0;    /* Stop Tx transfer */
    }
        
    /* Host get data from device complete */
    if(AT91C_UDP_TXCOMP & csr)
    {    
          DBG_OUT("ISR Tx Comp\r\n");
          
          /* The previous message received was SET_ADDR now that the computer ACK our send_null(),
        we can set this address for real */
        if(USB_State.dev_addr > 0)
        {    
              DBG_OUT("ISR: Set new address!\r\n");
              
              AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN | USB_State.dev_addr;    /* Set specified usb address in the controller */
            AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;    /* Tell the controller that we are in addressed mode now */
            USB_State.dev_addr = 0;
        }
        
        /* Send the following data */
         if(USB_State.tx_len[0] > 0 && USB_State.tx_data[0] != NULL)
            UDP_EP_Write(0, USB_State.tx_data[0], USB_State.tx_len[0]);    /* Send data */
        UDP_EP_CLR_FLAG(0, AT91C_UDP_TXCOMP);    /* Reset Tx complete */
    }
    
    if(AT91C_UDP_ISOERROR & csr)
    {    
          DBG_OUT("ISR EP0 ISO Err\r\n");
        UDP_EP_CLR_FLAG(0, AT91C_UDP_FORCESTALL | AT91C_UDP_ISOERROR);
    }
}

/*******************************************************************************
Write data to endpoint
*******************************************************************************/
void UDP_EP_Write(UINT8 ep, void *data, INT len)
{    
      P_UINT8 ptr;
      
      /* Get actual endpoint transfer size */
    UINT32 p_size = USB_State.ep_size[ep];

      /* If there is more data than can fit in a single packet, queue the rest up. */
      if(len > p_size)
    {
        len -= p_size;
        USB_State.tx_data[ep] = (P_UINT8)data + p_size;
        USB_State.tx_len[ep] = len;
      }
    else
    {
        p_size = len;
        USB_State.tx_data[ep] = NULL;
        USB_State.tx_len[ep] = 0;
      }
    
    DBG_OUT("UDP_EP_Write: Send %d bytes: ", p_size);
    
    UDP_EP_SET_FLAG(ep, AT91C_UDP_DIR);
    
    while(AT91C_BASE_UDP->UDP_CSR[ep] & AT91C_UDP_TXPKTRDY);
    
    /* Push a packet into the USB FIFO, and tell the controller to send. */
    ptr = (P_UINT8)data;
      while(p_size--)
        AT91C_UDP_FDR[ep] = *ptr++;
    
    UDP_EP_SET_FLAG(ep, AT91C_UDP_TXPKTRDY);
    
    if(AT91C_BASE_UDP->UDP_CSR[ep] & AT91C_UDP_TXCOMP)
        UDP_EP_CLR_FLAG(ep, AT91C_UDP_TXCOMP);
}

/*******************************************************************************
Stall endpoint
*******************************************************************************/
void UDP_EP_Stall(UINT8 ep)
{
      AT91C_BASE_UDP->UDP_CSR[ep] |= AT91C_UDP_FORCESTALL;
}

При приеме SETUP-пакета проверяю поле bmRequestType:

Код

if(req_type & USB_BMREQUEST_DIR_DEV_TO_HOST)
          UDP_EP_SET_FLAG(0, AT91C_UDP_DIR);    /* Set IN direction for endpoint */

/* Notify USB peripheral device that data have been read */
    UDP_EP_CLR_FLAG(0, AT91C_UDP_RXSETUP);