hostctrl.c

Usb Host/Periphel Control TD1120 codes

#ifdef OTG_BIG_ENDIAN
                  w |= *dp++;
#else
                  w |= (*dp++) << 24;
#endif
                  OTG242HC_WriteReg(hc, bufaddr, w);
                  bufaddr += 4;
               }
            }
         }

      if (len & 3)
         {
         /* Last partial dword */
         OTG242HC_WriteReg(hc, bufaddr, w);
         bufaddr += 4;
         }
      }
   else
      {
      /* Buffer is DWord aligned */
      U32 *wp;

      wp = (U32 *)buffer;
      for(i = 0; i < length; i += 4)
         {
#ifdef OTG_BIG_ENDIAN
         w = *wp++;
         OTG242HC_WriteReg(hc, bufaddr, OS_CpuToLe32(w));
         bufaddr += 4;
#else
         OTG242HC_WriteReg(hc, bufaddr, *wp++);
         bufaddr += 4;
#endif
         }

      if (length < len)
         {
         wp = (U32 *)buffer2;
         length = len - length;
         for(i = 0; i < length; i += 4)
            {
#ifdef OTG_BIG_ENDIAN
            w = *wp++;
            OTG242HC_WriteReg(hc, bufaddr, OS_CpuToLe32(w));
            bufaddr += 4;
#else
            OTG242HC_WriteReg(hc, bufaddr, *wp++);
            bufaddr += 4;
#endif
            }
         }
      }
#endif
   }

void OTG242HC_ReadFromChip(Otg242Hc *hc, U32 dest, U32 hc_mem, U32 size, U32 endPage)
   {
   U32      i;
   U32      addr;
   U8 *dp;
   U32      w = 0;
#ifdef OTG_16_BIT_DATA_BUS
   U16   *wp;
#else
   U32      *wp;
#endif
   U32      len;
   U32      length;
   void* buffer;
   void* buffer2;
   U32 bufaddr;

#ifdef DEBUG_OTG_SUBMIT
info("BulkRead: hc_mem=0x%0x buffer=%p size=0x%0x",hc_mem,buffer,size);
#endif

   /* Copy data from host controller to memory */
   bufaddr = hc_mem | OTG242HC_START_ADDRESS_DATA ;

#if HC_MASS_STORAGE_NEW
   buffer = (void*)OS_PhysicalToVirtual((void*)dest);
#else
   buffer = (void*)OS_PhysicalToVirtual(dest);
#endif
   addr = dest + size;
   if ((dest & 0xFFFFF000) == (addr & 0xFFFFF000))
      {
      buffer2 = NULL;
      length = size;
      }
   else
      {
#if HC_MASS_STORAGE_NEW
      buffer2 = (void*)OS_PhysicalToVirtual((void*)endPage);
#else
      buffer2 = (void*)OS_PhysicalToVirtual(endPage);
#endif
      length = 0x1000 - (dest & 0xFFF);
      }

#ifdef OTG_16_BIT_DATA_BUS
   if ((S32)buffer & 0x1)
      {
      /* Buffer is not Word aligned */
      dp = (U8 *)buffer;

      i = 0;
      if (length < size)
         {
         while(i < length)
            {
            switch (i & 1)
               {
               case 0:
#ifdef OTG_BIG_ENDIAN
                  w = OTG242HC_ReadReg16(hc, bufaddr);
                  bufaddr += 2;
                  *dp++ = (w >> 8) & 0xFF;
#else
                  w = OTG242HC_ReadReg16(hc, bufaddr);
                  bufaddr += 2;
                  *dp++ = w & 0xFF;
#endif
               break;
               case 1:
#ifdef OTG_BIG_ENDIAN
                  *dp++ = w & 0xFF;
#else
                  w >>= 8;
                  *dp++ = w & 0xFF;
#endif
               break;
               }
            i++;
            }

         dp = (U8 *)buffer2;
         length = size - length;
         }

      len = length;
      }
   else
      {
      wp = (U16 *)buffer;
      /* Buffer is Word aligned */
      for(i = 1; i < length; i += 2)
         {
#ifdef OTG_BIG_ENDIAN
         w = OTG242HC_ReadReg16(hc, bufaddr);
         bufaddr += 2;
         *wp++ = OS_Le16ToCpu(w);
#else
         *wp++ = OTG242HC_ReadReg16(hc, bufaddr);
         bufaddr += 2;
#endif
         }

      if (length < size)
         {
         wp = (U16 *)buffer2;
         length = size - length;

         for(i = 1; i < length; i += 2)
            {
#ifdef OTG_BIG_ENDIAN
            w = OTG242HC_ReadReg16(hc, bufaddr);
            bufaddr += 2;
            *wp++ = OS_Le16ToCpu(w);
#else
            *wp++ = OTG242HC_ReadReg16(hc, bufaddr);
            bufaddr += 2;
#endif
            }
         }

      len = length & 0x1;
      dp = (U8 *)wp;
      i = 0;
      }


   for(i=0; i<len; i++)
      {
      switch (i & 1)
         {
         case 0:
#ifdef OTG_BIG_ENDIAN
            w = OTG242HC_ReadReg16(hc, bufaddr);
            bufaddr += 2;
            *dp++ = (w >> 8) & 0xFF;
#else
            w = OTG242HC_ReadReg16(hc, bufaddr);
            bufaddr += 2;
            *dp++ = w & 0xFF;
#endif
         break;
         case 1:
#ifdef OTG_BIG_ENDIAN
            *dp++ = w & 0xFF;
#else
            w >>= 8;
            *dp++ = w & 0xFF;
#endif
         break;
         }
      }

   len = size & 3;
   if (len == 2 || len == 1)
      {
      OTG242HC_ReadReg16(hc, bufaddr);
      bufaddr += 2;
      }
#else /* 32-bit data bus */
   if ((S32)buffer & 0x3)
      {
      /* Buffer is not DWord aligned */
      dp = (U8 *)buffer;
      i = 0;
      if (length < size)
         {
         while(i < length)
            {
#ifdef HC_NEW_HCD_MEM            
            switch (i & 3)
               {
#endif

#ifdef OTG_BIG_ENDIAN

#ifdef HC_NEW_HCD_MEM

#else
            switch (i & 3)
               {
#endif
               case 0:
                  w = OTG242HC_ReadReg(hc, bufaddr);
                  bufaddr += 4;
                  *dp++ = (w >> 24) & 0xFF;
               break;
               case 1:
                  *dp++ = (w >> 16) & 0xFF;
               break;
               case 2:
                  *dp++ = (w >> 8) & 0xFF;
               break;
               case 3:
                  *dp++ = w & 0xFF;
               break;
#ifdef HC_NEW_HCD_MEM

#else
               }
#endif

#else
#ifdef HC_NEW_HCD_MEM

#else
            if (i)
               {
               w >>= 8;
               *dp++ = w & 0xFF;
               }
            else
               {

#endif
#ifdef HC_NEW_HCD_MEM
               case 0:
#endif


               w = OTG242HC_ReadReg(hc, bufaddr);
               bufaddr += 4;
               *dp++ = w & 0xFF;
#ifdef HC_NEW_HCD_MEM

#else               
               }
#endif

#ifdef HC_NEW_HCD_MEM
               break;
               case 1:
                  *dp++ = (w >> 8) & 0xFF;
               break;
               case 2:
                  *dp++ = (w >> 16) & 0xFF;
               break;
               case 3:
                  *dp++ = (w >> 24) & 0xFF;
               break;
#endif
               
#endif
#ifdef HC_NEW_HCD_MEM
               {
#endif               
            i++;
            }

         length = size - length;
         dp = (U8 *)buffer2;
         }

      len = length;
      }
   else
      {
      wp = (U32 *)buffer;
      /* Buffer is DWord aligned */
      for(i = 3; i < length; i += 4)
         {
#ifdef OTG_BIG_ENDIAN
         w = OTG242HC_ReadReg(hc, bufaddr);
         bufaddr += 4;
         *wp++ = OS_Le32ToCpu(w);
#else
         *wp++ = OTG242HC_ReadReg(hc, bufaddr);
         bufaddr += 4;
#endif
         }

      if (length < size)
         {
         wp =(U32 *)buffer2;
         length = size - length;

         for(i = 3; i < length; i += 4)
            {
#ifdef OTG_BIG_ENDIAN
            w = OTG242HC_ReadReg(hc, bufaddr);
            bufaddr += 4;
            *wp++ = OS_Le32ToCpu(w);
#else
            *wp++ = OTG242HC_ReadReg(hc, bufaddr);
            bufaddr += 4;
#endif
            }
         }

      len = length & 0x3;
      dp = (U8 *)wp;
      i = 0;
      }


   for(; i<len; i++)
      {
      switch (i & 3)
         {
#ifdef OTG_BIG_ENDIAN
         case 0:
            w = OTG242HC_ReadReg(hc, bufaddr);
            bufaddr += 4;
            *dp++ = (w >> 24) & 0xFF;
         break;
         case 1:
            *dp++ = (w >> 16) & 0xFF;
         break;
         case 2:
            *dp++ = (w >> 8) & 0xFF;
         break;
         case 3:
            *dp++ = w & 0xFF;
         break;
#ifdef HC_NEW_HCD_MEM

#else
         }
#endif         
#else

#ifdef HC_NEW_HCD_MEM

#else
      if (i)
         {
         w >>= 8;
         *dp++ = w & 0xFF;
         }
      else
         {
#endif         
#ifdef HC_NEW_HCD_MEM
               case 0:
#endif


         w = OTG242HC_ReadReg(hc, bufaddr);
         bufaddr += 4;
         *dp++ = w & 0xFF;
#ifdef HC_NEW_HCD_MEM

#else
         }
      }
#endif

#ifdef HC_NEW_HCD_MEM
         break;
         case 1:
            *dp++ = (w >> 8) & 0xFF;
         break;
         case 2:
            *dp++ = (w >> 16) & 0xFF;
         break;
         case 3:
            *dp++ = (w >> 24) & 0xFF;
         break;
#endif
      
#endif /* BIG_ENDIAN */

#ifdef HC_NEW_HCD_MEM
         }
      }
#endif

#endif /* 32-bit bus */
   }

void OTG242HC_ReadEtdFromChip(Otg242Hc *hc, Otg242Etd *etd, S32 index)
   {
   U32 addr;
   S32 i;
   U32 *dp;

   addr = (index << 4) | OTG242HC_START_ADDRESS_ETD;

   for (i = 0, dp = (U32 *)etd; i < sizeof(Otg242Etd) / sizeof(U32); i++, dp++)
      {
      *dp = OTG242HC_ReadReg(hc, addr + (i << 2));
      }
   }

void OTG242HC_WriteEtdToChip(Otg242Hc *hc, Otg242Etd *etd, S32 index)
   {
   U32 addr;
   S32 i;
   U32 *dp;

   addr = (index << 4) | OTG242HC_START_ADDRESS_ETD ;
  
   for (i = 0, dp = (U32 *)etd; i < sizeof(Otg242Etd) / sizeof(U32); i++, dp++)
      {
      OTG242HC_WriteReg(hc, addr + (i << 2), *dp);
      }
   }