etd.c

Usb Host/Periphel Control TD1120 codes

   else if (OTG242ETD_OverMaxErrorCount(etd))
      {
      }
   else
      {
      if (OhciTd_IsSetup(td))
         {
         OhciTd_SetBufferPointer(td, 0);
         }
      else
         {
         /* IN transfer */
         if (actualLength < etdBank->totalLength)
            {
            OhciTd_MoveBufferPointer(td, actualLength);
            }
         else
            {
            OhciTd_SetBufferPointer(td, 0);
            }
         }
      }

   OTG242ETD_Free(etdBank);

   ed->headP = (td->nextTd & OHCIED_POINTER) | (ed->headP & ~OHCIED_POINTER);
   td->nextTd = OTG242HC_GetHcDoneHead(etdBank->hc);
   OTG242HC_SetHcDoneHead(etdBank->hc, OS_VirtualToPhysical(td));
   }


void OTG242ETD_IsocDone(Otg242EtdBank *etdBank)
   {
   OhciTd*  td;
   OhciEd*  ed;
   Otg242Etd*  etd;
   Otg242EtdBank* etdBank1;
   U32 i;
   U32   psw;

   td = etdBank->td;
   ed = etdBank->ed;
   etd = &etdBank->etd;

   /* Workaround frame number flip over bug */
   i = OTG242ETD_GetStartingFrame(etd);
   if (i < 16)
      {
      i = (etdBank->hc->frameNo) & OTG242ETD_STARTING_FRAME;
      if (i > 0xFFF0)
         {
         /* Starting frame is in range of 0 - 15 while current frame is 0xFFFx
          * This done ETD is flip over problem. Reenable this ETD */
         OTG242ETD_EtdEnableSet( etdBank, (U8)etdBank->index);
         /* enable ETD done interrupt */
         OTG242ETD_ETDDoneEnableSet(etdBank, (U8)etdBank->index);

         OTG242ETD_XYInterruptEnablesSet( etdBank, (U8)etdBank->index);
         return;
         }
      }

   psw = 0;
   for (i = 0; i < etdBank->totalFrameCount; i++)
      {
      psw = OTG242ETD_GetStatusLength(etd, i);
      if ((psw & 0xE000) == 0xE000)
         {
         OhciTd_SetOffset(td, i, 0xE000);
         }
      else
         {
         OhciTd_SetOffset(td, i, psw);
         }
      }

   if ((psw & 0xF000) == (OTG242ETD_COMPLETION_CODE_NOT_ACCESSED >> 16))
      {
      OhciTd_SetConditionCode(td, OTG242ETD_COMPLETION_CODE_DATA_OVERRUN);
      }
   else
      {
      OhciTd_SetConditionCode(td, OTG242ETD_COMPLETION_CODE_NO_ERROR);
      }

   ed->headP = (td->nextTd & OHCIED_POINTER) | (ed->headP & ~OHCIED_POINTER);
   td->nextTd = OTG242HC_GetHcDoneHead(etdBank->hc);
   OTG242HC_SetHcDoneHead(etdBank->hc, OS_VirtualToPhysical(td));

   if ((ed->headP & OHCIED_POINTER) != (ed->tailP & OHCIED_POINTER))
      {
#if ETD_MASS_STORAGE_NEW      
      td = (OhciTd*)OS_PhysicalToVirtual((void*)((U32)ed->headP & OHCIED_POINTER));
#else
      td = (OhciTd*)OS_PhysicalToVirtual((U32)ed->headP & OHCIED_POINTER);
#endif
      if (!td)
         {
         PRINTI1("IsocDone td is null\n");
         OTG242ETD_Free(etdBank);
         }

      if (etdBank->nextEtd == NULL)
         {
         etdBank->td = td;
         OTG242ETD_FillEtdIsoc(etdBank);

         etdBank->hc->etdIntrEnable |= OTG242ETD_XYIntrEnable(etdBank->index);
         if (td->nextTd != (ed->tailP & OHCIED_POINTER))
            {
#if ETD_MASS_STORAGE_NEW      
            td = (OhciTd*)OS_PhysicalToVirtual((void*)((U32)td->nextTd));
#else 
            td = (OhciTd*)OS_PhysicalToVirtual((U32)td->nextTd);
#endif
            if (!td)
               {
               PRINTI1("IsocDone td is null\n");
               OTG242ETD_Free(etdBank);
               }

            etdBank1 = OTG242ETD_Allocate(etdBank->hc->etdBank);
            if (NULL == etdBank1)
               {
               return;
               }

            etdBank->nextEtd = etdBank1;
            etdBank1->nextEtd = etdBank;
            etdBank1->ed = etdBank->ed;
            etdBank1->td = td;
            etdBank1->type = EpTypeIsoc;

            OTG242ETD_FillEtdIsoc(etdBank1);
            etdBank->hc->etdIntrEnable |= OTG242ETD_XYIntrEnable(etdBank1->index) ;
            }

         return;
         }

      if (td->nextTd != (ed->tailP & OHCIED_POINTER))
         {
#if ETD_MASS_STORAGE_NEW      
         td = (OhciTd*)OS_PhysicalToVirtual((void*)((U32)td->nextTd));
#else 
         td = (OhciTd*)OS_PhysicalToVirtual((U32)td->nextTd);
#endif
         if (td)
            {
            etdBank->td = td;
            OTG242ETD_FillEtdIsoc(etdBank);
            etdBank->hc->etdIntrEnable |= OTG242ETD_XYIntrEnable(etdBank->index) ;

            return;
            }

         PRINTI1("IsocDone td is null\n");
         }
      }

   OTG242ETD_Free(etdBank);
   }


SctBool OTG242ETD_UseTwoEtds(Otg242EtdBank* etdBank)
   {
   if (etdBank->maxPacketSize > 512)
      {
      return etdBank->totalFrameCount > 1;
      }
   else
      {
      return etdBank->totalFrameCount > 2;
      }
   }

void OTG242ETD_SetStatusLength(Otg242Etd* etd, S32 index, U32 val)
   {
   S32 i;

   if( index > 1 )
      {
      PRINTI1("(OTG242ETD_SetStatusLength) ERROR: index > 1 \n");
      return;
      }
   i = index >> 1;
   if (index & 1)
      {
      etd->td.packetStatus[i] &= 0x0000FFFF;
      etd->td.packetStatus[i] |= val << 16;
      }
   else
      {
      etd->td.packetStatus[i] &= 0xFFFF0000;
      etd->td.packetStatus[i] |= val;
      }
   }

void OTG242ETD_ReadData(Otg242EtdBank* etdBank, S32 length, SctBool yBuffer)
   {
   OhciTd*  td;

   td = etdBank->td;

   if (yBuffer)
      {
      OTG242HC_ReadFromChip
         (
         etdBank->hc,
         etdBank->memoryAddress,
         etdBank->yBuffer,
         length,
         OhciTd_GetBufferEnd(td) & 0xFFFFF000
         );
      }
   else
      {
      OTG242HC_ReadFromChip
         (
         etdBank->hc,
         etdBank->memoryAddress,
         etdBank->xBuffer,
         length,
         OhciTd_GetBufferEnd(td) & 0xFFFFF000
         );
      }

   etdBank->memoryAddress += length;
   if ((etdBank->memoryAddress & 0xFFFFF000) != (td->currentBufferPointer & 0xFFFFF000))
      {
      etdBank->memoryAddress = (etdBank->memoryAddress & 0xFFF) | (OhciTd_GetBufferEnd(td) & 0xFFFFF000);
      }
   }


void OTG242ETD_WriteData(Otg242EtdBank* etdBank, S32 length, SctBool yBuffer)
   {
   OhciTd*  td;

   td = etdBank->td;

   if (yBuffer)
      {
      OTG242HC_WriteToChip
         (
         etdBank->hc,
         etdBank->memoryAddress,
         etdBank->yBuffer,
         length,
         OhciTd_GetBufferEnd(td) & 0xFFFFF000
         );
      }
   else
      {
      OTG242HC_WriteToChip
         (
         etdBank->hc,
         etdBank->memoryAddress,
         etdBank->xBuffer,
         length,
         OhciTd_GetBufferEnd(td) & 0xFFFFF000
         );
      }

   etdBank->memoryAddress += length;
   if ((etdBank->memoryAddress & 0xFFFFF000) != (td->currentBufferPointer & 0xFFFFF000))
      {
      etdBank->memoryAddress = (etdBank->memoryAddress & 0xFFF) | (OhciTd_GetBufferEnd(td) & 0xFFFFF000);
      }
   }


void OTG242ETD_NextPacket(Otg242EtdBank* etdBank)
   {
   U8 yBuffer = 0;
   S32   length;

   yBuffer = (etdBank->finishedFrameCount / etdBank->xPacketCount) & 1;

   length = etdBank->totalLength - etdBank->finishedLength;

#if ETD_MASS_STORAGE_NEW   
   if ( length <= 0 )
#else
   if (length <= 0 ||   etdBank->cancelled)
#endif   
      {
      if (etdBank->isDirectionIn)
         {
         if( yBuffer )
            {
            OTG242ETD_YBufFilledStatusClear(etdBank, (U8)etdBank->index);
            }
         else 
            {
            OTG242ETD_XBufFilledStatusClear(etdBank, (U8)etdBank->index);
            }
         }
      else
         {
         if( yBuffer )
            {
            OTG242ETD_YBufFilledStatusSet(etdBank, (U8)etdBank->index);

            }
         else 
            {
            OTG242ETD_XBufFilledStatusSet(etdBank, (U8)etdBank->index);
            }
         }

      return;
      }

   if (etdBank->type == EpTypeIsoc)
      {
      if ((etdBank->finishedFrameCount + 1) < etdBank->totalFrameCount)
         {
         length = OhciTd_GetOffsetPsw(etdBank->td, etdBank->finishedFrameCount + 1) & 0x1FFF;
         length -= OhciTd_GetOffsetPsw(etdBank->td, etdBank->finishedFrameCount) & 0x1FFF;
         }
      else
         {
         length = etdBank->totalLength - etdBank->finishedLength;
         }
      }

#ifdef ETD_NEW_PACKET_PER_BUF
   else if (etdBank->type == EpTypeBulk)
      {
            
           /***********************************************
                        When one buffer contains 2 or more packets
                        length should be calculated according to
                        the real number of packets returned. For
                        example, pattern "1 packet + STALL", we 
                        should only read and update 1 packets,
                        instead of xBufferLength.
           ************************************************/
      if (yBuffer)
         {
         
         if (length > etdBank->yBufferLength)
            {
            length = etdBank->yBufferLength;
            }
         }
      else
         {
         
         if (length > etdBank->xBufferLength)
            {
            length = etdBank->xBufferLength;
            }
         }
      }
#endif      
      
      
   else
      {
      if (yBuffer)
         {
         if (length > etdBank->yBufferLength)
            {
            length = etdBank->yBufferLength;
            }
         }
      else
         {
         if (length > etdBank->xBufferLength)
            {
            length = etdBank->xBufferLength;
            }
         }
      }


   if (etdBank->isDirectionIn)
      {
      OTG242ETD_ReadData(etdBank, length, yBuffer);
      if( yBuffer )
         {
         OTG242ETD_YBufFilledStatusClear(etdBank, (U8)etdBank->index);
         }
      else 
         {
         OTG242ETD_XBufFilledStatusClear(etdBank, (U8)etdBank->index);
         }
      }
   else
      {
      OTG242ETD_WriteData(etdBank, length, yBuffer);
      if( yBuffer )
         {
         OTG242ETD_YBufFilledStatusSet(etdBank, (U8)etdBank->index);
         }
      else 
         {
         OTG242ETD_XBufFilledStatusSet(etdBank, (U8)etdBank->index);
         }
      }
      
#ifdef ETD_NEW_PACKET_PER_BUF
   /***********************************
                Update finishedFrameCount
   ************************************/
   if (etdBank->type == EpTypeBulk)
      {
      etdBank->finishedFrameCount  += length/etdBank->maxPacketSize;
      }
   else
      {
      
#endif      
      

      etdBank->finishedFrameCount++;
#ifdef ETD_NEW_PACKET_PER_BUF
      }
#endif   
   
   etdBank->finishedLength += length;
   }