gfd_usb_hl.c

最近在國外網站抓到的作業系統 以Arm為基礎去開發的

				blktmp = 8;
				desc_len = 8*512;
			}
			else
			{
				longblk = SHORTBLK;
				blktmp = temblklen;
				desc_len = temblklen*512;
			}
			/*read from flush*/
			/*
			if(lblkaddr==0x8)
			{
				while(1);
			}
			*/
#ifdef USBNORFLASH
			dev_io_proc(1, (UINT32)lblkaddr, bulkindatebuf, (UINT16)blktmp, 1);
#endif
#ifdef USBRAMDISK
			usbpc_rd_io(0,(UINT32)lblkaddr, bulkindatebuf,(UINT32)blktmp,1);
#endif
			/*invert order*/
			//usbswap_data(bulkindatebuf,blktmp);
			head_temp = bulkindatebuf;
		
			descactu_len = translen*512;//sizeof (URead20);
			requlen = translen*512;//sizeof (URead20);
			break;
		case 	READ_CAPACITY:
			blktrasstate = BULKIN;
			desc_len = 0x8;//sizeof (URead_capacity);
			head_temp = URead_capacity;
			descactu_len = 0x8;//sizeof (URead_capacity);
			requlen = cbw_dtl;
			break;
		case 	READ_FORMAT_CAPACITY:
			blktrasstate = BULKIN;
			desc_len = 0x14;//sizeof (URead_format_capacity);
			head_temp = URead_format_capacity;
			descactu_len = 0x14;//sizeof (URead_format_capacity);
			requlen = cbw_dtl;
			break;
		case 	REQUEST_SENSE:
			blktrasstate = BULKIN;
			desc_len = 0x12;//sizeof (URequest_sense);
			head_temp = URequest_sense;
			descactu_len = 0x12;//sizeof (URequest_sense);
 			requlen = cbw_dtl;
			break;
		case 	CODE_1A:
			blktrasstate = BULKIN;
			desc_len = sizeof (Ucode_1A);
  			head_temp = (U32 *)Ucode_1A;
  			descactu_len = sizeof (Ucode_1A);
			requlen = cbw_dtl;
			break;
		case 	CODE_15:
			blktrasstate = BULKIN;
			desc_len = sizeof (Ucode_15);
			head_temp = (U32 *)Ucode_15;
			descactu_len = sizeof (Ucode_15);
			requlen = cbw_dtl;
			break;
		case 	WRITE2:
			blktrasstate = BULKOUT;
			temblklen = translen;                      
			if(temblklen > 8)                          
			{                                          
				longblk = LONGBLK;                     
				blktmp = 8;                            
				desc_len = 8*512;                      
			}                                          
			else                                       
			{  
				longblk = SHORTBLK;                                        
				blktmp = temblklen;                    
				desc_len = temblklen*512;              
			}                                          
			head_temp = bulkindatebuf;
			descactu_len = translen*512;//sizeof (URead20);
			requlen = translen*512;//sizeof (URead20);
			break;
		case 	TESTUNITREADY :
			unsinglepocket = SINGLE;
			break;
		case	PREVENT :
			unsinglepocket = SINGLE;	
			sing = SI;
			break;
	}	    
}           
            
void usb_bulk_csw(void)
{
	U32 residue;

	csw[0] = 0x53425355;
	csw[1] = usb_bulk_cbw();
	residue = requlen - descactu_len;
    csw[2] = residue;
      if(sing == UNSI)
    {
    	csw[4] = 0x00;
   	}
   	else
   	{
   		timen++;
   		sing = UNSI;
   		csw[4] = 0x01;
   	}
	tlengh = 13;
	head_temp = csw;
}

/*DATA TRANSFER*/
U32 transbulk(unsigned char *head)
{
	unsigned char *urb;
	int j, ti,j1;
	U32 P2;
	volatile U32 i;
	U32 stat,temp = 0;
	U32 t;
	
	if(blktrasstate == BULKIN)
	{
		/*in transfer*/
		ti = desc_len;
		urb = head;
		if(ti < 64)
		{
			*(RP)(USB_TXLENGTH) = ti;//the pocket, less than 8 bytes
		}
		else
		{
			*(RP)(USB_TXLENGTH) = 64;
		}
		j = ti/64;
		usbmod = ti%64;
		if(desc_len < 64)
		{
			USB_DMA_TRANS_TX((U32)urb,(U32)USB_TXFIFO,0x32,0x32,0x16,0x0,0x10);
		}
		else
		{
			longpk = LONGPKSTATE;
			//usbdmapp = APP;
			lstate=1;
			USB_DMA_TRANS_TX((U32)urb,(U32)USB_TXFIFO,0x32,0x32,0x16,0x0,j*0x10);
			longurb = head + j*64;
		}
		i = *(volatile U32 *)DMACC0Configuration;
		while((i & 0x1) != 0)
		{
			i = *(volatile U32 *)DMACC0Configuration;
		}
	}
	else
	{
		/*out transfer*/
		ti = desc_len;
		urb = head;
		j=ti/64;
		usbmod = ti%64;
		if(desc_len <= 64)
		{
			USB_DMA_TRANS_RX((U32)USB_RXFIFO,(U32)urb,0x32,0x32,0x16,0x0,0x10);
		}
		else
		{
			longpk = LONGPKSTATE;
			USB_DMA_TRANS_RX((U32)USB_RXFIFO,(U32)urb,0x32,0x32,0x16,0x0,j*0x10);
			longurb = head + j*64;
		}
		//for(i=0;i<10000;i++);

		i = *(volatile U32 *)DMACC0Configuration;
		while((i & 0x1) != 0)
		{
			i = *(volatile U32 *)DMACC0Configuration;
		}
#ifdef USBNORFLASH
		dev_io_proc(1,(UINT32)lblkaddr, bulkindatebuf,(UINT16)blktmp,0);
#endif 
#ifdef USBRAMDISK
		usbpc_rd_io(0,(UINT32)lblkaddr, bulkindatebuf,(UINT32)blktmp,0);
#endif
	}
}

/*
 * H A _ I N T _ H A N D L E R _ U S B       S E R V I C E
 */       	         
U8  *get_irq_request_cmd(void)
{
	static U8 command[8];
	
	command[0] = usb_chang_reg32_to_reg8(USB_EP0OUTBMREQTYPE);
	command[1] = usb_chang_reg32_to_reg8(USB_EP0OUTBREQUEST);
	command[2] = usb_chang_reg32_to_reg8(USB_EP0OUTWVALUE);
	command[3] = usb_get_regbit15_to_8(USB_EP0OUTWVALUE);
	command[4] = usb_chang_reg32_to_reg8(USB_EP0OUTWINDEX);
	command[5] = usb_get_regbit15_to_8(USB_EP0OUTWINDEX);
	command[6] = usb_chang_reg32_to_reg8(USB_EP0OUTWLENGTH);
	command[7] = usb_get_regbit15_to_8(USB_EP0OUTWLENGTH);
	return command;
}

void usb_irq_setup(void)
{
	U8* command_request;
	 
	command_request = get_irq_request_cmd();
	pdc_bus_ctrl_pipe_notificaion(PDC_SETUP_COMMAND, command_request);
	if(setconstate == SETCONFIG)
	{
		setconstate = NSETCONFIG;
	}
	else
	{
		transcl((unsigned char *)head_temp);
	}
	return;
}
	
	
U32 pdc_bus_ctrl_pipe_notificaion(unsigned long notif_type, unsigned char *cmd)
{
	U8	RequestType;
	U8	bmRequest ;

	if(notif_type == PDC_SETUP_COMMAND)
	{
		/* SETUP Command from the control pipe */
		RequestType = cmd[0] & 0x60;
		switch(RequestType)
		{
			case STANDARD_REQUEST:
				/* Process USB Standrad request */
   				bmRequest = cmd[1];
				switch (bmRequest)
				{
					case GET_DESCRIPTOR:
						usb_RMW_reg(USB_EP0OUTSTAT,0x0a);
						stat_des = 1;
						pdc_bus_get_descriptor(cmd);
						break;
										
					case SET_CONFIGURATION:
						usb_RMW_reg(USB_EP0OUTSTAT,0x0a);
						stat_conf = 1;
						pdc_bus_SET_CONFIGURATION();
						setconstate = SETCONFIG;
						break;
					default:
						usb_RMW_reg(USB_EP0OUTSTAT,0x0a);
						stat_defa = 1;
						break;
				}
			case CLASS_REQUEST:
	        case VENDOR_REQUEST:
	        		usb_RMW_reg(USB_EP0OUTSTAT,0x0a);
	              	bmRequest = cmd[1];
	              	if(bmRequest == 0xFE)
	              	{
	              		head_temp = (unsigned char *)empty;
	              		desc_len = 1;
				    }
				    break;
			default:
				 usb_RMW_reg(USB_EP0OUTSTAT,0x0a);
				 stat_defa1 = 1;
				 break;
		}
	}			
	return 0;
}


void pdc_bus_get_descriptor(U8 *command)
{
	U16	 req_len;
	U8 	des_tmp;

	switch( command[3])
	{
		case PDC_DEV_DESC_TYPE:
			 head_temp = device_desc;
			 root = (unsigned char *)device_desc;
			 desc_len = 0x12;//sizeof(device_desc);
			 break;
			
		case PDC_CONFIG_DESC_TYPE:
			 head_temp = conf_desc;
			 root = (unsigned char *)conf_desc;
			 des_tmp = command[6]|(command[7]<<8);
			 desc_len = (des_tmp > 0x20)? 0x20 : des_tmp;
			 if(des_tmp > 0x20)
				statempty = EMPTY;		
			 break;
		case PDC_STRING_DESC_TYPE:
			 switch(command[2])
			 {
				case 0:
					head_temp = (unsigned char *)unicode_string;
					root = unicode_string;
					desc_len = sizeof(unicode_string);
					break;
				case 1:
					head_temp = (unsigned char *)mfg_string;
					root = mfg_string;
					desc_len = sizeof(mfg_string);
					break;
				case 2:
					head_temp = (unsigned char *)product_string;
					root = product_string;
					desc_len = sizeof(product_string);					
					break;
				case 3:
					head_temp = (unsigned char *)serial_string;
					root = serial_string;
					desc_len = sizeof(serial_string);
					break;
				default:
					break;
			 }
			 break;
		default:
		    break;
	}
	//urb
	if(head_temp)
	{
		/* Get max length that remote end wants */
		req_len =command[6]|(command[7]<<8);
		if (desc_len > req_len )
		{
			desc_len = req_len ;    
		}
	}
}

void pdc_bus_SET_CONFIGURATION(void)
{
	return;
}
 
U32 transcl(unsigned char *head)
{
	unsigned char *urb;
	int j, ti;
	U32 t;
		
	ti = desc_len;
	urb = head;
	if(ti < 8)
	{
		*(RP)(USB_TXLENGTH) = ti;//the pocket, less than 8 bytes
	}
	else
	{
		*(RP)(USB_TXLENGTH) = 8;
	}
	j=ti/8;
	usbmod = ti%8;
	if(usbstate == USBCG)
	{
		if(desc_len <= 8)
		{
			USB_DMA_TRANS_TX((U32)urb,(U32)USB_TXFIFO,0x32,0x32,0x16,0x0,0x10);
		}
		else
		{
			longpk = LONGPKSTATE;
			longurb = head + j*64;
			if(usbmod ||(statempty == EMPTY))
			{
				usbdmapp = APP;
			}
			else if (!usbmod)
			{
				longpk = SHORTPK;
			}
			USB_DMA_TRANS_TX((U32)urb,(U32)USB_TXFIFO,0x32,0x32,0x16,0x0,j*0x10);
		}
	}
	else
	{
		/*the first pocket*/
		usbstate = USBCG;//modified
		USB_DMA_TRANS_TX((U32)urb,(U32)USB_TXFIFO,0x32,0x32,0x16,0x0,0x10); 
	}
}
		
ER  HA_GFDUSB_INTHANDLE(void)  //;when there is usb interrupt,the process starts 
{   
    ER Epstat;
    U32 evnt,intr,imask;
    int i;
          
    intr  =  usb_lock_readreg(USB_INTR);
    imask =  usb_read_reg(USB_INTRMASK);
    Epstat = usb_lock_readreg(USB_EPINFO);
    if(((Epstat &= 0x1f)== 0) || ((Epstat &= 0x1f)== 1))
    {
 		epstate = EPCL;  
		while(1)
		{	
			/* Read IRQ status*/
			evnt = intr & (SETUP|IN|OUT|PING|TRAERR|ACK|STCOV|CTRAERR|RESET) & (~imask);
			/* No irq? */
			if (evnt==0)
			{
				return 0;
			}
			if(evnt & RESET)
			{
				//for(i;i<21;i++);
		  		head_temp = NULL;
				desc_len = 1;
				state1 = 1;
				urb_num = 0;
				stat_des = 0; 
				stat_add = 0;
				stat_conf = 0;
				stat_defa = 0;
				stat_out1 = 0;
				stat_defa1 =0;
				stat_ack = 0;
				stat_in = 0;
				statep1 = 0;
				state_in = 0;
				state3 = 0;
				stateep1 = 0;
				descactu_len = 0;
				requlen = 0;
				//usbstate = USBDEF;     
				bulkstat = BULKOUTSTAT;
				transstat = TRANSBG; 
				bulkinepstat = BULKINDO;
				longpk = SHORTPK;
				statempty = NEMPTY;
				setconstate = NSETCONFIG;
				blkstate = BLKCMD;
				usbmod = 0;   
				unsinglepocket = UNSINGLE;
				sing = UNSI;
				timen = 0;
                		timres=0;
				longblk = SHORTBLK;
				usbdmapp = NAPP;