etd.c

Usb Host/Periphel Control TD1120 codes

      if (etd->ed == ed)
         {
         return etd;
         }
      }

   return NULL;
   }

SctBool OTG242ETD_FillEtd(Otg242EtdBank *etdBank)
   {
   S32   length;
   OhciTd*  td;

   OS_DEBUG_MSG2(OS_ZONE_INTR, "Otg242Etd: +FillEtd index=%d\r\n", etdBank->index);
   
   /* Calculate the data length for this TD. Data may cross 4K boundary */
   td = etdBank->td;
   if (OhciTd_GetBufferPointer(td) == 0)
      {
      length = 0;
      }
   else
      {
      length = (OhciTd_GetBufferEnd(td) & 0xFFF) - (OhciTd_GetBufferPointer(td) & 0xFFF) + 1;
      if ((OhciTd_GetBufferEnd(td) & 0xFFFFF000) != (OhciTd_GetBufferPointer(td) & 0xFFFFF000))
         {
         length += 4096;
         }
      }

   if (length > 8192)
      {
      OS_DEBUG_MSG2(OS_ZONE_INTR, "FillEtd: length 0x%0x\r\n", length);
      return SCC_FALSE;
      }

   etdBank->memoryAddress = OhciTd_GetBufferPointer(td);
   etdBank->totalLength = length;
   etdBank->finishedLength = 0;
   etdBank->maxPacketSize = OhciEd_GetMaxPacketSizeValue(etdBank->ed);
   etdBank->finishedFrameCount = 0;
   if (OhciEd_IsDirectionIn(etdBank->ed, td))
      {
      etdBank->isDirectionIn = 1;
      }
   else
      {
      etdBank->isDirectionIn = 0;
      }

   OS_MemSet(&etdBank->etd, 0, sizeof(Otg242Etd));
   OTG242ETD_FillTd(etdBank);
   OTG242ETD_FillEd(etdBank);
   
   OTG242HC_WriteEtdToChip(etdBank->hc, &etdBank->etd, etdBank->index);
   OTG242ETD_EtdEnableSet(etdBank, (U8)etdBank->index);
   
   /* enable ETD done interrupt */
   OTG242ETD_ETDDoneEnableSet(etdBank, (U8)etdBank->index);
   
   OTG242ETD_XYInterruptEnablesSet(etdBank, (U8)etdBank->index);
    
   OS_DEBUG_MSG2(OS_ZONE_INTR, "Otg242Etd: -FillEtd desc=0x%0x\r\n", etdBank->etd.desc);

   return SCC_TRUE;
   }

SctBool OTG242ETD_FillTd(Otg242EtdBank *etdBank)
   {
   OhciTd*  td;
   SctBool  rc;
   S32   length;

   OS_DEBUG_MSG1(OS_ZONE_INTR, "Otg242Etd:+FillTd\r\n");
   
   td = etdBank->td;
   length = etdBank->totalLength;

#ifdef ETD_NEW_PACKET_PER_BUF
   /************************************
          Process X buffer. Need to increase 
          the buffer length     to twice of max 
          packet size. 3.13
          *************************************/   
   if (etdBank->type == EpTypeBulk)
      {
      if (length > ETD_PACKETPERBUF* etdBank->maxPacketSize)
         {
         etdBank->xBufferLength = ETD_PACKETPERBUF * etdBank->maxPacketSize;
         length -= etdBank->xBufferLength;
         }
         else if (length > etdBank->maxPacketSize)
            {
            etdBank->xBufferLength = etdBank->maxPacketSize;
            length -= etdBank->xBufferLength;
            }
         else
            {
            etdBank->xBufferLength = length;
            length = 0;
            }
      }
   else
      {
#endif       

   if (length > etdBank->maxPacketSize)
      {
      etdBank->xBufferLength = etdBank->maxPacketSize;
      length -= etdBank->xBufferLength;
      }
   else
      {
      etdBank->xBufferLength = length;
      length = 0;
      }

#ifdef ETD_NEW_PACKET_PER_BUF
      }
        /************************************
          Process Y buffer. Need to increase 
          the buffer length     to twice of max 
          packet size. 3.13
          *************************************/
 
      if (etdBank->type == EpTypeBulk)
         {
            
         if (length > ETD_PACKETPERBUF* etdBank->maxPacketSize)
            {
                                
            etdBank->yBufferLength = ETD_PACKETPERBUF * etdBank->maxPacketSize;
            length -= etdBank->yBufferLength;

            }
      
#endif      

#ifdef ETD_NEW_PACKET_PER_BUF
        else if (length > etdBank->maxPacketSize)

#else
   if (length > etdBank->maxPacketSize)
#endif
      {
      etdBank->yBufferLength = etdBank->maxPacketSize;
      length -= etdBank->yBufferLength;
      }
   else
      {
      etdBank->yBufferLength = length;
      length = 0;
      }

#ifdef ETD_NEW_PACKET_PER_BUF
      }
      else
         {
         if (length > etdBank->maxPacketSize)
            {
            etdBank->yBufferLength = etdBank->maxPacketSize;
            length -= etdBank->yBufferLength;
            }
         else
            {
            etdBank->yBufferLength = length;
            length = 0;
            }
         }

    /**************************************
                Fill in PacketCount
    ***************************************/
#endif


   etdBank->xPacketCount = (etdBank->xBufferLength - 1) / etdBank->maxPacketSize + 1;

   if (etdBank->yBufferLength > 0)
      {
      etdBank->yPacketCount = (etdBank->yBufferLength - 1) / etdBank->maxPacketSize + 1;
      }
   else
      {
      etdBank->yPacketCount = 0;
      }
   
   rc = SCC_TRUE;
   if (OhciTd_IsSetup(td))
      {
      rc = OTG242ETD_DoXBufferOut(etdBank);
      }
   else if(OhciEd_IsDirectionOut(etdBank->ed, td))
      {
      rc = OTG242ETD_DoXBufferOut(etdBank);
      if (SCC_FALSE == rc)
         {
         return rc;
         }

      if (etdBank->yBufferLength > 0)
         {
         rc = OTG242ETD_DoYBufferOut(etdBank);
         }
      }
   else /* IN transfer */
      {
      rc = OTG242ETD_DoXBufferIn(etdBank);
      if (SCC_FALSE == rc)
         {
         return rc;
         }

      if (etdBank->yBufferLength > 0)
         {
         rc = OTG242ETD_DoYBufferIn(etdBank);
         }
      }

   OS_DEBUG_MSG1(OS_ZONE_INTR, "Otg242Etd:-FillTd\r\n");

   return rc;
   }

SctBool OTG242ETD_DoXBufferOut(Otg242EtdBank *etdBank)
   {
   U32   xBuffer;
   S32      length;
   OhciTd*  td;

   td = etdBank->td;
   length = etdBank->xBufferLength;

   if (length) 
      {     
      if (etdBank->xBuffer < 0)
         {
         xBuffer = OTG242HC_AllocateMemory(etdBank->hc, length);
         if(xBuffer < 0)
            {
            OS_DEBUG_MSG1(OS_ZONE_INTR, "Otg242Etd: No space left..\r\n");
            return SCC_FALSE;
            }

         etdBank->xBuffer = xBuffer;
         }
      else
         {
         xBuffer = etdBank->xBuffer;
         }

      OTG242ETD_SetXBuffer(etdBank->etd, xBuffer);
      }

   OTG242ETD_NextPacket(etdBank);

   return SCC_TRUE;
   }

SctBool OTG242ETD_DoYBufferOut(Otg242EtdBank *etdBank)
   {
   U32 yBuffer;
   OhciTd* td;
   S32 length;

   td = etdBank->td;
   length = etdBank->yBufferLength;

   if (length) 
      {
      if(etdBank->yBuffer < 0)
         {
         yBuffer = OTG242HC_AllocateMemory(etdBank->hc, length);
         if(yBuffer < 0)
            {
            OS_DEBUG_MSG1(OS_ZONE_INTR, "Otg242Etd: No space left..\r\n");
            return SCC_FALSE;
            }

         etdBank->yBuffer = yBuffer;
         }
      else
         {
         yBuffer = etdBank->yBuffer;
         }
         
      OTG242ETD_SetYBuffer(etdBank->etd, yBuffer);
   
      OTG242ETD_NextPacket(etdBank);
      }

   return SCC_TRUE;
   }

SctBool OTG242ETD_DoXBufferIn(Otg242EtdBank *etdBank)
   {
   U32   xBuffer;
   S32      length;

   length = etdBank->xBufferLength;

   if (length) 
      {
      if (etdBank->xBuffer < 0)
         {
         xBuffer = OTG242HC_AllocateMemory(etdBank->hc, length);
         if(xBuffer < 0)
            {
            OS_DEBUG_MSG1(OS_ZONE_INTR, "Otg242Etd: No space left..\r\n");
            return SCC_FALSE;
            }

         
         etdBank->xBuffer = xBuffer;
         }
      else
         {
         xBuffer = etdBank->xBuffer;
         }

      OTG242ETD_SetXBuffer(etdBank->etd, xBuffer);
      
      OTG242ETD_XBufFilledStatusClear( etdBank, (U8)etdBank->index);
      }
   else
      {
      OTG242ETD_XBufFilledStatusClear( etdBank, (U8)etdBank->index);
      }

   return SCC_TRUE;
   }

SctBool OTG242ETD_DoYBufferIn(Otg242EtdBank *etdBank)
   {
   U32   yBuffer;
   S32      length;

   length = etdBank->yBufferLength;

   if (length) 
      {
      if (etdBank->yBuffer < 0)
         {
         yBuffer = OTG242HC_AllocateMemory(etdBank->hc, length);
         if(yBuffer < 0)
            {
            OS_DEBUG_MSG1(OS_ZONE_INTR, "Otg242Etd: No space left..\r\n");
            return SCC_TRUE;
            }
         
         etdBank->yBuffer = yBuffer;
         }
      else
         {
         yBuffer = etdBank->yBuffer;
         }

      OTG242ETD_SetYBuffer(etdBank->etd, yBuffer);
      OTG242ETD_YBufFilledStatusClear( etdBank, (U8)etdBank->index);
      }

   return SCC_TRUE;
   }

SctBool OTG242ETD_FillEd(Otg242EtdBank* etdBank)
   {
   Otg242Etd *etd;
   /*S32 packets;*/
   U32 i;
   S32 size;
   S32 lastSize;
   OhciTd* td;
   OhciEd* ed;
   U32 frame;

   td = etdBank->td;
   ed = etdBank->ed;

   OS_DEBUG_MSG3(OS_ZONE_INTR, "Otg242Etd:+FillEd td->desc=0x%0x ed->desc=0x%0x\r\n",
      td->desc, ed->desc);

   /********************************************************
      Let's download Etd first if this is control and bulk
   *********************************************************/


   etd = &etdBank->etd;
   if (OhciEd_IsIsoc(ed))
      {  
      /**************************************************************
         This is an isochronous transfer descriptor
         Retrieve the endpoint interval information
      ***************************************************************/

      
      frame = OhciTd_GetStartingFrame(td);

      OTG242ETD_SetStartingFrame(etd, frame);
      OTG242ETD_SetDelayIntrIsoc(etd, OhciTd_GetDelayInterrupt(td));
      OTG242ETD_SetFrameCountValue(etd,  (etdBank->totalFrameCount - 1));
      OTG242ETD_SetAutoISO(etd, 0);
      OTG242ETD_SetCompletionCode(etd, OhciTd_GetCompletionCode(td));

      /* dword 3, framecount should be <= 2 */
      lastSize = OhciTd_GetOffsetPsw(td, 0) & 0x1FFF;
      i = 1;
      while (i < etdBank->totalFrameCount)
         {
         /* Convert offset to length */
         size = OhciTd_GetOffsetPsw(td, i) & 0x1FFF;

         OTG242ETD_SetStatusLength(etd, i - 1, (size - lastSize) | 0xF000);

         lastSize = size;
         i++;
         }

      lastSize -= OhciTd_GetOffsetPsw(td, 0) & 0x1FFF;
      OTG242ETD_SetStatusLength(etd, i - 1, (etdBank->totalLength - lastSize) | 0xF000);


      }
   else
      {
      OTG242ETD_SetDirectionPid(etd, OhciTd_GetDirectionPid(td));