msfunction.c

MSTAR03的数码相框的代码

#else
				        usbStillImageSts=STILL_STSTUS_OK|0x04000000;
#endif
                        usbEP[0].transfer_buffer_length=4;
                        usbEP[0].transfer_buffer=(__u32)&usbStillImageSts;
                        retstatus = USB_PID_IN;
            	        break;
                case    CANCEL_OP_REQUEST:
                        sp = usbMalloc(usbEP0Setup.wLength);
                        usbEP[0].transfer_buffer_length=usbEP0Setup.wLength;
                        usbEP[0].transfer_buffer=(__u32)sp;
                        //usbFree(sp);
                        retstatus = USB_PID_OUT;
                        break;

             }
            }
	     if(OtgDeviceType==Device_MassStorage)
	     {
	      switch (usbEP0Setup.bRequest)
             {
                case    MSDFN_BOT_RESET:
                            retstatus = USB_PID_ACK;
                           break;
                case    MSDFN_BOT_GET_MAXLUN:
#ifdef Enable_Device_MassStorage
			      otgInitMassBuffer();
#endif
                           usbEP[0].transfer_buffer_length=1;
                           //usbEP[0].transfer_buffer=(__u32)&otgPerMassmax_Lun|0xA0000000;
                           usbEP[0].transfer_buffer=(__u32)&DviceMassmax_Lun;
                           if ((usbEP0Setup.bmRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
                            retstatus = USB_PID_IN;
                           break;
	      }
	     }
        }
        return(retstatus);
    }
#ifdef USB_DEBUG
//            printf("\r\nusbSpeed = %x ",usbSpeed);
//            printf("\r\nbRequest = %x ",usbEP0Setup.bRequest);
#endif
    switch (usbEP0Setup.bRequest)
    {
        case    USB_REQ_GET_STATUS:
                usbGetStatusResponse = 0;
                usbEP[0].transfer_buffer_length=usbEP0Setup.wLength;
                usbEP[0].transfer_buffer=(__u32)&usbGetStatusResponse;
                if  ((usbEP0Setup.bmRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE)
                {
#ifdef BIG_ENDIAN
                    if  (usbRemoteWakeup)
                        usbGetStatusResponse = 0x0200;
                    if  (usbSelfPower)
                        usbGetStatusResponse |= 0x0100;
#else
                    if  (usbRemoteWakeup)
                        usbGetStatusResponse = 0x02;
                    if  (usbSelfPower)
                        usbGetStatusResponse |= 0x01;
#endif
                    retstatus = USB_PID_IN;
                    break;
                }
                if  ((usbEP0Setup.bmRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
                {
                    retstatus = USB_PID_IN;
                    break;
                }
                if  ((usbEP0Setup.bmRequestType & USB_RECIP_MASK) == USB_RECIP_ENDPOINT)
                {
                    pipe = GETLSB(usbEP0Setup.wIndex) & 0xff;
                 		endpoint = usb_pipeendpoint(pipe);
	                	direction = usb_pipein(pipe) ? 0 : 1;
		                if(endpoint == 0)
		                   break;
#ifdef BIG_ENDIAN
                    if  (usbEP[endpoint].Halted)
                       usbGetStatusResponse = 0x0100;
#else
                    if  (usbEP[endpoint].Halted)
                       usbGetStatusResponse = 0x01;
#endif
                    retstatus = USB_PID_IN;
                    break;
                }
                break;

        case    USB_REQ_CLEAR_FEATURE:
                if  (usbUSBState < USB_ADDRESS)
                    break;                          /* STALL */
                if  ((usbEP0Setup.bmRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE)
                {
                      if  (GETLSB(usbEP0Setup.wValue) == DEVICE_REMOTE_WAKEUP)
                      {
                           usbRemoteWakeup = 0;
                           retstatus = USB_PID_ACK;
                      }
                }
                else if ((usbEP0Setup.bmRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
                {
                      if  (usbUSBState != USB_CONFIGURED )
                          break;                  /* STALL */
                      retstatus = USB_PID_ACK;
                }
                else if ((usbEP0Setup.bmRequestType & USB_RECIP_MASK) == USB_RECIP_ENDPOINT)
                {
                     if  ((usbUSBState == USB_ADDRESS) && (GETLSB(usbEP0Setup.wIndex) != 0))
                         break;                              /* STALL */
                     if  (GETLSB(usbEP0Setup.wValue) == ENDPOINT_HALT)
                     {
		                     pipe = GETLSB(usbEP0Setup.wIndex) & 0xff;
		                     endpoint = usb_pipeendpoint(pipe);
		                     direction = usb_pipein(pipe) ? 0 : 1;
		                     if (endpoint)
                         {
                             usbEP[endpoint].Halted = 0;
                             usbDRC_Index_Select_INT(usbEP[endpoint].BltEP);
                             if (usbEP[endpoint].DRCDir)
							 {
                                 usbREG_WRITE8(USB_REG_RXCSR1, M_RXCSR_CLRDATATOG);
                                 usbREG_WRITE8(USB_REG_RXCSR1, 0);
							 }
                             else
							 {
                                 usbREG_WRITE8(USB_REG_TXCSR1, M_TXCSR_CLRDATATOG);
                                 usbREG_WRITE8(USB_REG_TXCSR1, 0);
							 }
                             usbDRC_Index_Select_INT(0);   /* Back to EP0. */
                             usbClearedEP=1;
                         }
                         retstatus = USB_PID_ACK;
                     }
                }
                break;

        case    USB_REQ_SET_FEATURE:
                if  (usbUSBState < USB_DEFAULT)
                     break;
                if  ((usbEP0Setup.bmRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE)
                {
                     if  (GETLSB(usbEP0Setup.wValue) == DEVICE_REMOTE_WAKEUP)
                     {
                         usbRemoteWakeup = 1;
                         retstatus = USB_PID_ACK;
                     }
                     if  (GETLSB(usbEP0Setup.wValue) == USB_TEST_MODE)
                     {
                         usbTestMode = usbEP0Setup.wIndex;
                     }
                     if  (GETLSB(usbEP0Setup.wValue) == b_hnp_enable)
                     {
                         if (usbMyDeviceHNPSupport)
                             usbHNPEnabled = 1;  /* we can become host now */
                         else
                             break;
                      }
                      if  (GETLSB(usbEP0Setup.wValue) == a_hnp_support)
                      {
                           if  (usbMyDeviceHNPSupport)
                                usbHNPSupport = 1;
                           else
                                break;
                      }
                      retstatus = USB_PID_ACK;
                      break;
                }
                if  ((usbEP0Setup.bmRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
                {
                    if  (usbUSBState != USB_CONFIGURED )
                        break;
                    if ((GETLSB(usbEP0Setup.wValue) == b_hnp_enable) || (GETLSB(usbEP0Setup.wValue) == a_hnp_support) ||
                            (GETLSB(usbEP0Setup.wValue) == a_alt_hnp_support))
                        retstatus = USB_PID_ACK;
                    break;
                }
                if  ((usbEP0Setup.bmRequestType & USB_RECIP_MASK) == USB_RECIP_ENDPOINT)
                {
                     if  ((usbUSBState == USB_ADDRESS) && (GETLSB(usbEP0Setup.wIndex) != 0))
                          break;
                     if  (GETLSB(usbEP0Setup.wValue) == ENDPOINT_HALT)
                     {
		                 pipe = GETLSB(usbEP0Setup.wIndex) & 0xff;
		                 endpoint = usb_pipeendpoint(pipe);
		                 direction = usb_pipein(pipe) ? 0 : 1;
		                 if (endpoint)
                         {
                             usbEP[endpoint].Halted = 1;
                             usbDRC_Index_Select_INT(usbEP[endpoint].BltEP);
                             if (usbEP[endpoint].DRCDir)
                                 usbREG_WRITE8(USB_REG_RXCSR1, M_RXCSR1_P_SENDSTALL);
                             else
                                 usbREG_WRITE8(USB_REG_TXCSR1, M_TXCSR1_P_SENDSTALL);
                             usbDRC_Index_Select_INT(0);
                         }
                         retstatus = USB_PID_ACK;
                         break;
                     }
                }
                break;

        case    USB_REQ_SET_ADDRESS:
#ifdef USB_DEBUG
//                    printf("\r\nwValue = %x ",GETLSB(usbEP0Setup.wValue));
#endif
                if(GETLSB(usbEP0Setup.wValue) <= 127)
                {
                    usbFaddr = GETLSB(usbEP0Setup.wValue);
                    if ((usbUSBState == USB_DEFAULT) && (usbFaddr != 0))
                        usbSetFaddr = 0;
                    retstatus = USB_PID_ACK;
#ifdef USB_DEBUG
//                    printf("\r\nusbSetFaddr = %x ",usbSetFaddr);
//                    printf("\r\nusbFaddr = %x ",usbFaddr);
//                    printf("\r\nretstatus = %x ",retstatus);
#endif
                }
                break;

        case    USB_REQ_GET_DESCRIPTOR:
                //usbConnectFlag=1;
		  //NotifyusbConnect=1;
                usbFunction_Initial();
                desctype = GETMSB(usbEP0Setup.wValue);
                if  (!((desctype == USB_DT_DEVICE) || (desctype == USB_DT_CONFIG)||
                    (desctype == USB_DT_STRING)||(desctype == USB_DT_DEVICE_QUALIFIER) ||
                    (desctype == USB_DT_OTHER_SPEED)))
                    return(retstatus);  /* STALL if not valid request */
                scanP = (__u8 *)usbMsdfn_Dscr;
                bytesrem = (__u32)sizeof(usbMsdfn_Dscr);
                if  ((!scanP) || (bytesrem <=0))
                    return(retstatus);
                descindex = GETLSB(usbEP0Setup.wValue);/* !=0 for string,config*/
                i = descindex;
                while   (bytesrem > 0)/*While Looping_Free:<Exit counter added>*/
                {
                     if (*(scanP+1) == desctype)
                     {
                         if  (i == 0)
                             break;
                         i--;
                     }
                     bytesrem -= *scanP;
                     scanP += *scanP;
                }
                if  (bytesrem <= 0)
                    return(retstatus);
                if  ((desctype == USB_DT_CONFIG)||(desctype == USB_DT_OTHER_SPEED))
                {
                     length = (*(scanP+3) << 8) + *(scanP+2);
                }
                else
                     length = *scanP;
                usbEP[0].transfer_buffer_length=MIN(usbEP0Setup.wLength,length);
                usbEP[0].transfer_buffer=(__u32)scanP;
#ifdef USB_DEBUG
                //printf("\r\nlength = %x ",usbUSB_EP[0].transfer_buffer_length);
                //printf("\r\nbuffer = %x ",usbUSB_EP[0].transfer_buffer);
#endif
                retstatus = USB_PID_IN;
                break;

        case    USB_REQ_SET_DESCRIPTOR:
        	      sp = usbMalloc(usbEP0Setup.wLength);
                usbEP[0].transfer_buffer_length=usbEP0Setup.wLength;
                usbEP[0].transfer_buffer=(__u32)sp;
                usbFree(sp);
                retstatus = USB_PID_OUT;
                break;

        case    USB_REQ_GET_CONFIGURATION:
                usbEP[0].transfer_buffer_length=usbEP0Setup.wLength;
                usbEP[0].transfer_buffer=(__u32)&usbConfig;
                retstatus = USB_PID_IN;
                break;

        case    USB_REQ_SET_CONFIGURATION:
                if  (usbUSBState < USB_ADDRESS)
                    break;
                if  (!GETLSB(usbEP0Setup.wValue))
                {
                     usbChange_USB_State(USB_ADDRESS);
                     retstatus = USB_PID_ACK;
                     break;
                }
                if  (GETLSB(usbEP0Setup.wValue))
                {
                     usbConfig = GETLSB(usbEP0Setup.wValue);
                     usbChange_USB_State(USB_CONFIGURED);
					 //usbConnectFlag=1;
		             //NotifyusbConnect=1;
					 //printf("\r\n UsbCntFlg=%x", usbConnectFlag);
                     retstatus = USB_PID_ACK;
                     break;
                }
                break;

        case    USB_REQ_GET_INTERFACE:
                if  (usbUSBState != USB_CONFIGURED)
                    break;
                usbEP[0].transfer_buffer_length=usbEP0Setup.wLength;
                usbEP[0].transfer_buffer=(__u32)&usbInterface;
                retstatus = USB_PID_IN;
                break;

        case    USB_REQ_SET_INTERFACE:
                if  (usbUSBState != USB_CONFIGURED)
                     break;
                retstatus = USB_PID_ACK;
                break;

        case    USB_REQ_SYNCH_FRAME:
                break;
        default:
                break;
    }
    return(retstatus);
}

#if 0
void otgFIFO_Test(void)
{
    __u8 volatile Flash_Buffer[0x40];
    __u8 tmpa;
    __u8 tmpb;
	__u32 testcnt=0;

    while(1)
    {
        usbEP[0].MaxEPSize=0x40;
		usbEP[0].BytesProcessed = 0;
		usbEP[0].BytesRequested = 0x40;
		usbEP[0].FifoRemain=0x40;
		usbEP[0].BltEP=0;
        tmpb=0;
        for (tmpa=0;tmpa<0x40;tmpa++)
        {
    	      Flash_Buffer[tmpa]=tmpb;
    	      tmpb++;
        }
//        for (tmpa=0;tmpa<0x40;tmpa++)
// 			  printf("\r\nFlash_Buffer[tmpa] = %x ",Flash_Buffer[tmpa]);
        usbDRC_Fifo_Write(Flash_Buffer, 0);
        usbREG_WRITE8(USB_REG_TXCSR1, M_CSR0_TXPKTRDY);
//        printf("\r\nTXCSR1 = %x ",usbREG_READ8(USB_REG_TXCSR1));
        usbREG_WRITE8(USB_REG_TESTMODE,M_TEST_FIFOACCESS);
//        printf("\r\nTESTMODE = %x ",usbREG_READ8(USB_REG_TESTMODE));
//        for (tmpa=0;tmpa<0x40;tmpa++)
//     	      Flash_Buffer[tmpa]=0;
        usbEP[0].MaxEPSize=0x40;
		usbEP[0].BytesProcessed = 0;
		usbEP[0].BytesRequested = 0x40;
		usbEP[0].FifoRemain=0x40;
		usbEP[0].BltEP=0;
        usbDRC_Fifo_Read(Flash_Buffer, 0);
        tmpb=0;
        usbREG_WRITE8(USB_REG_TXCSR1, M_CSR0_P_SVDRXPKTRDY);
//        printf("\r\nTXCSR1 = %x ",usbREG_READ8(USB_REG_TXCSR1));
        for (tmpa=0;tmpa<0x40;tmpa++)
        {
    	      if (Flash_Buffer[tmpa]!=tmpb)
			  {
#ifdef USB_DEBUG
                  printf("\r\ntmpa = %x ",tmpa);
                  printf("\r\nFlash_Buffer[tmpa] = %x ",Flash_Buffer[tmpa]);
#endif
    	          while(1);
			  }
    	      tmpb++;
        }
		testcnt++;
#ifdef USB_DEBUG
        printf("\r\ntestcnt = %x ",testcnt);
#endif
    }
}
#endif