udc_ahb.c.orig

Spearhead2000的bootloader

                           /* return STALL */
                           // *VUINTP (Endp_Cntl + Out_Endp0) |= Endp_Cntl_STALL;
                           USBCtrlTransftateMachine   = USB_CTRLOUT_DATA_OUT_STAGE;
                           return; // STALL (??) -- TODO
                   }


                   break;

           }
  
 
        }
        else if (protocol == USB_TYPE_CLASS)
        {
        
           /*
            * CLASS requests
            */
            
           // Parse SETUP Packet Type
           switch(UsbSetupBuf.bReq)
           {
           /*
            * The following USB commands are handled directly by HW (UDC 2.0).
            */
           case USB_GET_DEVICE_ID:
           {
                //char *pub_did_str;
                //unsigned short i;
                unsigned short uw_str_len;
                //unsigned char  ub_char1, ub_char2;
                //unsigned char aubDidStr[100];

                // Print("\r\n (AV) : GetDeviceID");
                //PrintMessInLastKB("GetDeviceID");
  
                //pub_did_str = P1284DidGetString();
                //uw_str_len = (unsigned short)strlen(pub_did_str) + 2;
                //pub_did_str = gaubDeviceID;
                uw_str_len = sizeof(gaubDeviceID);

                //ub_char1 = (unsigned char)((uw_str_len >> 8) & 0x00ff);
                //ub_char2 = (unsigned char)(uw_str_len & 0x00ff); 


                //aubDidStr[0] = ub_char1;
                //aubDidStr[1] = ub_char2;
                //strcpy(&aubDidStr[2], pub_did_str);
                //for(i=0; i<uw_str_len; i++)
                        //aubDidStr[i+2]=gaubDeviceID[i];

#if defined (_USB_DMA)
                BulkDescrPtr = (DmaUsbBulkDescr *)USB_GetDescrFromFreeList(1);
                if (BulkDescrPtr)
                {
                        char *destp = BulkDescrPtr->DmaUsb_Addr;
                        unsigned short dlen = min(length, uw_str_len );
 
                        BulkDescrPtr->DmaUsb_Status = DmaUsb_LastDescr | (dlen & DmaUsb_Len_Mask);
 
                        /* Copy Device Descriptor . */
                        if (destp) memcpy(destp, (char *)&gaubDeviceID[0], dlen);

                        USB_PutDescrIntoEpt(IN_EP0, BulkDescrPtr);
                }
                else
                {
                      /* return STALL */
                      *VUINTP (Endp_Cntl + Out_Endp0) |= Endp_Cntl_STALL;
                }
 
#else
                // Packet size is 8 bytes.
                // UsbPutPckToFIFO(0, (char *)&DevDescr, sizeof(DevDescr));
#endif

                USBCtrlTransftateMachine   = USB_CTRLIN_STATUS_OUT_STAGE;
                break;
           }
           
           case USB_GET_PORT_STATUS:
           {
                unsigned char ubStr[2];
                unsigned short uw_str_len;

                //PrintMessInLastKB("GetPortStatus");
                ubStr[0] = (unsigned char)(bUSBPortStatus  & 0x00ff);
                ubStr[1] = (unsigned char)((bUSBPortStatus >> 8) & 0x00ff);

                //uw_str_len = (unsigned short)(strlen(ubStr)); 
                uw_str_len = 1;
                
#if defined (_USB_DMA)
                BulkDescrPtr = (DmaUsbBulkDescr *)USB_GetDescrFromFreeList(1);
                if (BulkDescrPtr)
                {
                        char *destp = BulkDescrPtr->DmaUsb_Addr;
                        unsigned short dlen = min(length, uw_str_len );
 
                        BulkDescrPtr->DmaUsb_Status = DmaUsb_LastDescr | (dlen & DmaUsb_Len_Mask);
                
                        /* Copy Device Descriptor . */
                        if (destp) memcpy(destp, (char *)&ubStr[0], dlen);
 
                        // Print("\r\n(AV) -- GetPortStatus len %d  status %x (%x)", dlen, ubStr[0], bUSBPortStatus);
                        USB_PutDescrIntoEpt(IN_EP0, BulkDescrPtr);
                }
                else
                {
                     /* return STALL */
                     *VUINTP (Endp_Cntl + Out_Endp0) |= Endp_Cntl_STALL;
                }
 
#else
                // Packet size is 8 bytes.
                // UsbPutPckToFIFO(0, (char *)&DevDescr, sizeof(DevDescr));
#endif

                USBCtrlTransftateMachine   = USB_CTRLIN_STATUS_OUT_STAGE;
                break;
           }
           
           case USB_SOFT_RESET:
                   USBCtrlTransftateMachine   = USB_CTRL_IDLE;
                   *VUINTP (Endp_Cntl + Out_Endp0) |= Endp_Cntl_STALL;
                   break; // STALL 

           default:
                   USBCtrlTransftateMachine   = USB_CTRL_IDLE;
                   *VUINTP (Endp_Cntl + Out_Endp0) |= Endp_Cntl_STALL;
                   break; // STALL 
           }
        }
        else if (protocol == USB_TYPE_VENDOR)
        {
        
           /*
            * VENDOR requests
            */
            
           // Parse SETUP Packet Type
           switch(UsbSetupBuf.bReq)
           {
           case 0:
              USBCtrlTransftateMachine   = USB_CTRLOUT_STATUS_IN_STAGE;
	      break;
	   }
	}
        
        /* clear NAK */
        *VUINTP (Endp_Cntl + In_Endp0)  |= Endp_Cntl_CNAK;
        *VUINTP (Endp_Cntl + Out_Endp0) |= Endp_Cntl_CNAK;
}

static void
USBSetDescriptor()
{
   if (USBCtrlTransftateMachine == USB_CTRLOUT_STATUS_IN_STAGE)
   {
       DmaUsbBulkDescr *BulkDescrPtr; 
         
       USBCtrlTransftateMachine   = USB_CTRL_IDLE;
       
       BulkDescrPtr = (DmaUsbBulkDescr *)USB_GetDescrFromEpt(SETUP_EP0, SIZE_OF_DESCRIPTOR_CHAIN);
       if (BulkDescrPtr)
       {
          switch(DmaUsbDescrType)
          {
          case USB_DEVICE:
             {
                 char *destp = BulkDescrPtr->DmaUsb_Addr;
 
                 /* Copy Device Descriptor . */
                 if (destp) memcpy((char *)&DevDescr, destp, sizeof(DevDescr));
             }
             break;
             
          case USB_CONFIGURATION:
             {
                 char *destp = BulkDescrPtr->DmaUsb_Addr;
 
                 /*
                  * SetDescriptor --> CONFIGURATION 1
                  *      Returns: Configuration Descriptor 1 +
                  *               Interface 0 +
                  *               Endpt 1 (Bulk-OUT) +
                  *               Endpt 2 (Bulk-IN)
                  */
                  if (destp) memcpy((char *)&CfgDescr, destp, sizeof(CfgDescr));
                  destp += sizeof(CfgDescr);
 
                  /* Copy Interface Descriptor 0. */
                  if (destp) memcpy((char *)&IfDescr, destp, sizeof(IfDescr));
                  destp += sizeof(IfDescr);
 
                  /* Copy Bulk-IN Descriptor 1. */
                  if (destp) memcpy((char *)&BulkInDescrFS, destp, sizeof(BulkInDescrFS));
                  destp += sizeof(BulkInDescrFS);
 
                  /* Copy Bulk-OUT Descriptor . */
                  if (destp) memcpy((char *)&BulkOutDescrFS, destp, sizeof(BulkOutDescrFS));
                  destp += sizeof(BulkOutDescrFS);
             }
             break;
             
          default:
             break;
          }
       }
   }
}


static unsigned int usb_herr_num  = 0;
               
/*
 * This routine is the USB Interrupt Handler.
 */
void DrvUsbInterruptHandler(void)
{
     unsigned int descp;

      volatile DmaUsbBulkDescr   *DmaUsbBulkDescr_tmp;
      volatile DmaUsbBulkDescr   *DmaUsbBulkDescr_end;

      // Print("\r\n(AV) -----  USB IRQ RECEIVED [Dev_Int: %08x]  [Endp_Int: %08x]", *VUINTP Dev_Int, *VUINTP Endp_Int);
      //PrintMessInLastKB("isr begin");

        /************************************
         *
         * Plug detect interrupt (high priority)
         *
         ************************************/
         if (*VUINTP Plug_pending & Plug_intpend)
         {
            if (*VUINTP Plug_state & Plug_Status_attached)
            {
               /* USB cable attached
	        * Turn off PHY reset bit (PLUG detect).
	        * Switch PHY opmode to normal operation (PLUG detect).
		*/
                *VUINTP Plug_state &= ~(Plug_Status_phy_reset | Plug_Status_phy_mode) ;  
           }
            else
            {
               /* USB cable detached
	        * Reset the PHY and switch the mode.
	        */          
               *VUINTP Plug_state |= (Plug_Status_phy_reset | Plug_Status_phy_mode);   
            }
         }
      
        /************************************
         *
         * Device interrupts (high priority)
         *
         ************************************/

         // USB Reset detected on cable
         if (*VUINTP Dev_Int & Dev_Int_USBRESET)
         {
            // Print("\r\n(AV) -- USB RESET ");
            //PrintMessInLastKB("int rst");
            
           *VUINTP Endp_Int_Mask      = ~0x0;             // ALL IRQ disabled.
           *VUINTP Dev_Cntl    &= ~Dev_Cntl_RxDMAEn;
      
               /* 
	        * Turn off PHY reset bit (PLUG detect).
	        * Switch PHY opmode to normal operation (PLUG detect).
		*/
                *VUINTP Plug_state &= ~(Plug_Status_phy_reset | Plug_Status_phy_mode) ;  

            *VUINTP (Endp_Cntl + In_Endp0) |= Endp_Cntl_FLUSH;
            *VUINTP Dev_Int = Dev_Int_USBRESET;
         }

         // Device Enumeration completed
         if (*VUINTP Dev_Int & Dev_Int_ENUM)
         {
            /* Check Device speed */
            if ((*VUINTP Dev_Stat & Dev_Stat_ENUM) == Dev_Stat_ENUM_SPEED_HS)
            {
               // Print("\r\n(AV) -- USB 2.0 Speed HS ");
               //PrintMessInLastKB("int enum HS");
               DmaUsbMaxPacketSize = USB_PCK_SIZE_HS;
               DmaUsbCtrlMaxPacketSize = CONTROL_ENDPT_MAX_SIZE_HS;
               
               *VUINTP Endp_NE0 = 0x02000000;    // Control Endpoint  (0)
               *VUINTP Endp_NE1 = 0x100000c1;    // Bulk-OUT Endpoint (1)
               *VUINTP Endp_NE2 = 0x100000c2;    // Bulk-OUT Endpoint (2)
               *VUINTP Endp_NE3 = 0x100000d1;    // Bulk-IN Endpoint  (1)
               *VUINTP Endp_NE4 = 0x100000d2;    // Bulk-IN Endpoint  (2)
               
	       *VUINTP (Endp_Max_Pack_Size + In_Endp0) = CONTROL_ENDPT_MAX_SIZE_HS;
	       *VUINTP (Endp_Max_Pack_Size + In_Endp1) = BULK_ENDPT_SLAVE_MAX_SIZE_HS;
	       *VUINTP (Endp_Max_Pack_Size + In_Endp2) = BULK_ENDPT_DMA_MAX_SIZE_HS;
	       *VUINTP (Endp_Max_Pack_Size + Out_Endp0) = CONTROL_ENDPT_MAX_SIZE_HS |
	        					  ((USB_EP0_OUT_BUSIZE / sizeof(int))
	        					  * Endp_BufSize_OUT_Base) & Endp_BufSize_OUT_Msk;
	       *VUINTP (Endp_Max_Pack_Size + Out_Endp1) = BULK_ENDPT_DMA_MAX_SIZE_HS |
	        					  ((USB_EP1_OUT_BUSIZE / sizeof(int))
	        					  * Endp_BufSize_OUT_Base) & Endp_BufSize_OUT_Msk;
	       *VUINTP (Endp_Max_Pack_Size + Out_Endp2) = BULK_ENDPT_SLAVE_MAX_SIZE_HS |
	        					  ((USB_EP2_OUT_BUSIZE / sizeof(int))
	        					  * Endp_BufSize_OUT_Base) & Endp_BufSize_OUT_Msk;
            }
            else
            {
               // Print("\r\n(AV) -- USB 1.1 Speed FS ");
               //PrintMessInLastKB("int enum FS");
               DmaUsbMaxPacketSize = USB_PCK_SIZE_FS;
               DmaUsbCtrlMaxPacketSize = CONTROL_ENDPT_MAX_SIZE_FS;
               *VUINTP Endp_NE0 = 0x02000000;    // Control Endpoint  (0)
               *VUINTP Endp_NE1 = 0x020000c1;    // Bulk-OUT Endpoint (1)
               *VUINTP Endp_NE2 = 0x020000c2;    // Bulk-OUT Endpoint (2)
               *VUINTP Endp_NE3 = 0x020000d1;    // Bulk-IN Endpoint  (1)
               *VUINTP Endp_NE4 = 0x020000d2;    // Bulk-IN Endpoint  (2)
               
	       *VUINTP (Endp_Max_Pack_Size + In_Endp0) = CONTROL_ENDPT_MAX_SIZE_FS;
	       *VUINTP (Endp_Max_Pack_Size + In_Endp1) = BULK_ENDPT_SLAVE_MAX_SIZE_FS;
	       *VUINTP (Endp_Max_Pack_Size + In_Endp2) = BULK_ENDPT_DMA_MAX_SIZE_FS;
	       *VUINTP (Endp_Max_Pack_Size + Out_Endp0) = CONTROL_ENDPT_MAX_SIZE_FS |
	        					  ((USB_EP0_OUT_BUSIZE / sizeof(int))
	        					  * Endp_BufSize_OUT_Base) & Endp_BufSize_OUT_Msk;
	       *VUINTP (Endp_Max_Pack_Size + Out_Endp1) = BULK_ENDPT_DMA_MAX_SIZE_FS |
	        					  ((USB_EP1_OUT_BUSIZE / sizeof(int))
	        					  * Endp_BufSize_OUT_Base) & Endp_BufSize_OUT_Msk;
	       *VUINTP (Endp_Max_Pack_Size + Out_Endp2) = BULK_ENDPT_SLAVE_MAX_SIZE_FS |
	        					  ((USB_EP2_OUT_BUSIZE / size