udc.c

君正早期ucos系统(只有早期的才不没有打包成库),MPLAYER,文件系统,图片解码,浏览,电子书,录音,想学ucos,识货的人就下吧 russblock fmradio explore set

			OSQPost(udcsrc.CurEvent1 , (void *)&udcid);
			OSSemPost(udcsrc.CurEvent);
			OSSemPend(udcsrc.CurEvent2, 0 , &err);
			OSTimeDly(350);			
			if ( check_gpio(GPIO_UDC_DETE) )   //cable have not disconnect
			{
				printf("Reas power cable insert! \n");
				udcsrc.Src = SRC_UDC;
				udcsrc.Event = EVENT_POWER_IN;
				OSQPost(udcsrc.CurEvent1 , (void *)&udcid);
				OSSemPost(udcsrc.CurEvent);
				OSSemPend(udcsrc.CurEvent2, 0 , &err);
			}
		}
		else 
			jz_writeb(USB_REG_POWER,0x60);   //High speed	
#endif
	}
	if(val & 2)
	{
		printf("udc resume\n");
	}
	
	
}

void udc4740_proc (unsigned int handle)
{
	u8	IntrUSB = 0;
	u16	IntrIn = 0;
	u16	IntrOut = 0;
	u16 IntrDMA = 0;
	PEPSTATE pep;
	cli();
/* Read interrupt regiters */
	IntrUSB = jz_readb(USB_REG_INTRUSB);
/* Check for resume from suspend mode */
	if(IntrUSB != 8)
		udc_intrb_handler(handle,IntrUSB);
	/* Check for endpoint 0 interrupt */
	
	IntrIn  = jz_readw(USB_REG_INTRIN);
//	if(jz_readw(USB_REG_INTROUTE))
	IntrOut = jz_readw(USB_REG_INTROUT);
	//printf("IntrIn = %x IntrOut = %x\n",IntrIn,IntrOut);
	
	if (IntrIn & USB_INTR_EP0) 
	{
		//dprintf("\nUDC EP0 operations!\n");
		ep0_handler(handle);
	}	

	pep = GetEpState(1);
	if(pep->state == CPU_WRITE)
	{
		if (IntrIn & 2) 
		{
			dprintf("\nUDC EP1 IN operation!");
			ep_in_handler(handle,pep);
			//return;
		}
	}
	
	IntrDMA = jz_readb(USB_REG_INTR);
	//printf("IntrDMA = %x\n",IntrDMA);
	
	if(pep->state == DMA_WRITE)
	{
		dprintf("dma write intr = %x\n",IntrDMA);

				
		if(IntrDMA & 1)
		{
			
			dprintf("addr %x,count %x,cntl %x\r\n",
				   jz_readl(USB_REG_ADDR1),jz_readl(USB_REG_COUNT1),jz_readl(USB_REG_CNTL1));
			dma_send_data_Finish();
			
			if(pep->curlen != pep->totallen)
			{
				/*??????????????*/
				printf("cur_len %d,totallen %d\r\n",pep->curlen,pep->totallen);
				usb_setw(USB_REG_INTRINE,EP1_INTR_BIT);  // open ep1 in intr
				pep->state = CPU_WRITE;
				ep_in_handler(handle,pep);
				
			   
                 //jz_writeb(USB_REG_INDEX, 1);
				//usb_setb(USB_REG_INCSR, USB_INCSR_INPKTRDY);
			}else 
			{
				pep->state = WRITE_FINISH;
				usb_clearw(USB_REG_INTRINE,EP1_INTR_BIT);  // close ep1 in intr
				BusNotify(handle,UDC_PROTAL_SEND_FINISH,
						   (unsigned char *)(pep->data_addr),pep->curlen);
				
				
			}
			//return;
		}
		

	}
	
	pep = GetEpState(2);
	if(pep->state == CPU_READ)
	{
		
		if ((IntrOut /*& IntrOutMask*/ ) & 2) 
		{
			dprintf("UDC EP1 OUT operation!\n");
			ep_out_handler(handle,pep);
			//return;		
		}
	}
	if(pep->state == DMA_READ)
	{
		if(IntrDMA == 0)
			IntrDMA = jz_readb(USB_REG_INTR);

		dprintf("\nDMA_REA intrDMA = %x\n",IntrDMA);
		
		if (IntrDMA & 0x2)     //channel 2 :OUT
		{
			dprintf("\n INTR 2!");
			dma_receieve_data_finish();
			if((pep->totallen % pep->fifosize) != 0)
			{
				usb_setw(USB_REG_INTROUTE,EP1_INTR_BIT);	//Enable Ep Out
				pep->state = CPU_READ;
				ep_out_handler(handle,pep);
			}else
			{

				pep->state = READ_FINISH;
				BusNotify(handle,UDC_PROTAL_RECEIVE_FINISH,
						  (unsigned char *)(pep->data_addr),pep->curlen);
			}
			//return;
			

		}
	}
	sti();
	//dprintf("\n UDCProc finish!\n");
	
	//return;
}

void gpio_handler(unsigned int arg)
{
	//__gpio_ack_irq(GPIO_UDC_DETE);
	__gpio_mask_irq(GPIO_UDC_DETE);
	udc_irq_type |= 0x10;
	OSSemPost(udcEvent);
}

void enable_device(unsigned int handle);

static void gpio_ist(void * arg)
{
	PUDC_BUS pBus = (PUDC_BUS) arg;
	unsigned int stat = 0;
	unsigned int gpio_state = 0;
	unsigned int count = 0;
	static unsigned int judge = 0, i;
	u8 byte1 , byte2 ,err;
	u8 detect;
	OSTimeDly(100);
	detect = check_gpio(GPIO_UDC_DETE);
	if(detect)
		__gpio_as_irq_fall_edge(GPIO_UDC_DETE);
	else
		__gpio_as_irq_rise_edge(GPIO_UDC_DETE);
	printf("GPIO IRQ %d !!\n",detect);
	if ( cable_stat == CABLE_CONNECTED )    //connected!
	{
		OSTimeDly(100);
		if ( detect )  //false disconnect
			return ;
		
		if ( protocool_stat == CABLE_CONNECTED )  //info suspend
		{
			printf("cable USE uninstall ! \n");
			udcsrc.Src = SRC_UDC;
			udcsrc.Event = EVENT_UNINSTALL;
			protocool_stat = CABLE_DISCONNECT;
			OSQPost(udcsrc.CurEvent1 , (void *)&udcid);
			OSSemPost(udcsrc.CurEvent);
			OSSemPend(udcsrc.CurEvent2, 0 ,&err);
		}
		//Do disabledevice
		cable_stat = CABLE_DISCONNECT;

		udcsrc.Src = SRC_UDC;
		udcsrc.Event = EVENT_POWER_OUT;
		OSQPost(udcsrc.CurEvent1 , (void *)&udcid);
		OSSemPost(udcsrc.CurEvent);
		OSSemPend(udcsrc.CurEvent2, 0 ,&err);
		BusNotify((unsigned int)pBus,UDC_REMOVE,0,0);
		disable_device(0);
		//__gpio_as_irq_rise_edge(GPIO_UDC_DETE);
	}
	else                                    //disconnect!
	{
//		OSTimeDly(50);
		if ( !detect )  //false connect
			return ;

		//for test USB or POWER cable!!
		enable_device(0);
		for ( i = 0; i <= MAX_CABLE_DETE; i ++)
		{
			//sleep wait a while!
			OSTimeDly(CABLE_DETE_TIME/10);
 			byte1 = jz_readb(USB_REG_POWER);
			byte2 = jz_readb(USB_REG_INTRUSB);
			if ( ( byte1 & 0x08 )|| ( byte2 & 0x04 ) ) //reset occur!
				break;
			else 
				printf("Wait reset time out! \n");
		}
//		disable_device(0);
		cable_stat = CABLE_CONNECTED;
		//__gpio_as_irq_fall_edge(GPIO_UDC_DETE);

		if ( i > MAX_CABLE_DETE ) //power cable!
		{
			printf("Power cable insert! \n");
			udcsrc.Src = SRC_UDC;
			udcsrc.Event = EVENT_POWER_IN;
			OSQPost(udcsrc.CurEvent1 , (void *)&udcid);
			OSSemPost(udcsrc.CurEvent);
			OSSemPend(udcsrc.CurEvent2, 0 ,&err);
			return ;
		}
		else                      //usb cable!!
		{
			udcsrc.Src = SRC_UDC;
			udcsrc.Event = EVENT_USB_IN;
			OSQPost(udcsrc.CurEvent1 , (void *)&udcid);
			OSSemPost(udcsrc.CurEvent);
			printf("USB cable insert! \n");
			OSSemPend(udcsrc.CurEvent2 , 0, &err);
			printf("read val %d \n",res.Val);
			if ( res.Val == 1 )  //|| res.Val == 0xffff) //up layer said yes!
			{
//				protocool_stat = CABLE_CONNECTED;
				BusNotify((unsigned int)pBus,UDC_JUDGE,0,0);
			}
			else           //up layer said no!
			{
			    printf("dddddddddddddddd \n");
			    disable_device(0);   
				protocool_stat = CABLE_DISCONNECT;
				printf("As power cable insert! \n");
			}
		}

	}
	
}

void gpio_irq_init(PUDC_BUS pBus)
{
	int err = 0;
	
	request_irq(IRQ_GPIO_UDC_DETE, gpio_handler, pBus);
	__gpio_as_irq_rise_edge(GPIO_UDC_DETE);
	__gpio_disable_pull(GPIO_UDC_DETE);
	REG_CPM_SCR &= ~CPM_SCR_USBPHY_ENABLE;  //disable UDC_PHY
	jz_writeb(USB_REG_POWER,0x60);   //High speed	
}

static void udc_intr_handler(unsigned int arg)
{
	__intc_mask_irq(IRQ_UDC);
	udc_irq_type |= 0x1;
	//dprintf("UDC irq\r\n");
	OSSemPost(udcEvent);
}
void udc_disable_device_directly_global(void)
{
    udc_irq_type |= 0x20;
	OSSemPost(udcEvent);
}
static void udc_disable_device_directly(void *arg);
static void udc_task_entry(void *arg)
{
	u8 err;
	while (1) {
		OSSemPend(udcEvent, 0, &err);
		//printf("udc_irq_type = %x\r\n",udc_irq_type);
		if(udc_irq_type & 0x20){
		    udc_disable_device_directly(arg);
		}
		if(udc_irq_type & 0x10)
		{
			gpio_ist(arg);
			udc_irq_type &= ~0x10;
			__gpio_unmask_irq(GPIO_UDC_DETE);
		}
		if(udc_irq_type & 1)
		{
			udc4740_proc((unsigned int)arg);
			udc_irq_type &= ~0x1;
			__intc_unmask_irq(IRQ_UDC);
			
		}
	}
}

static void udc_disable_device_directly(void *arg)
{
    PUDC_BUS pBus = (PUDC_BUS) arg;
    if ( cable_stat == CABLE_CONNECTED )    //connected!
    {
    	if ( protocool_stat == CABLE_CONNECTED )  //info suspend
    	{
    		printf("cable USE uninstall ! \n");
    		udcsrc.Src = SRC_UDC;
    		udcsrc.Event = EVENT_UNINSTALL;
    		protocool_stat = CABLE_DISCONNECT;
    		OSQPost(udcsrc.CurEvent1 , (void *)&udcid);
    		OSSemPost(udcsrc.CurEvent);
    		// wait finish
    		OSSemPend(udcsrc.CurEvent2, 0 ,&err);
    	}
    	//Do disabledevice
    	cable_stat = CABLE_CONNECTED;
    
    	udcsrc.Src = SRC_UDC;
    	udcsrc.Event = EVENT_POWER_IN;
    	OSQPost(udcsrc.CurEvent1 , (void *)&udcid);
    	OSSemPost(udcsrc.CurEvent);
    	// wait finish
    	OSSemPend(udcsrc.CurEvent2, 0 ,&err);
    	BusNotify((unsigned int)pBus,UDC_REMOVE,0,0);
    	disable_device(0);
    	udc_irq_type &= ~0x20;
    }
}

/*   interface   */
static void set_address(unsigned int handle,unsigned short value)
{
	dprintf("Set address %d\r\n",value);
#if 1
	protocool_stat = CABLE_CONNECTED;
#endif
	jz_writeb(USB_REG_FADDR,value);
}

void enable_device(unsigned int handle)
{
	__cpm_start_udc();
	__intc_unmask_irq(IRQ_UDC);
	REG_CPM_SCR |= CPM_SCR_USBPHY_ENABLE;
	jz_writeb(USB_REG_POWER,0x60);     //enable sofeconnect
	
	printf("Enable USB Phy!\r\n");
	
}
void disable_device(unsigned int handle)
{
	u8 err;
  	
	jz_writeb(USB_REG_POWER,0x00);      //disable sofeconnet!
	jz_readb(USB_REG_INTRUSB);
	jz_readw(USB_REG_INTRIN);
	jz_readw(USB_REG_INTROUT);
	udc_irq_type = 0;
	OSSemSet(udcEvent,0,&err);
	__intc_ack_irq(IRQ_UDC);
	__cpm_stop_udc();
	__intc_mask_irq(IRQ_UDC);
	REG_CPM_SCR &= ~CPM_SCR_USBPHY_ENABLE;
	printf("Disable USB Phy!\r\n");
}
void reset_udcdevice()
{
	jz_writeb(USB_REG_POWER,0x00);      //disable sofeconnet!
	OSTimeDly(100);
	jz_writeb(USB_REG_POWER,0x60);     //enable sofeconnect
	
}
void start_transfer(unsigned int handle,unsigned char ep,unsigned char *buf,unsigned int len)
{
	PEPSTATE pep;
	dprintf("start_transfer ep = %x buf:%08x len = %d\r\n",ep,buf,len);
	unsigned char state;
	switch(ep)
	{
	case 0:
		pep = GetEpState(0);
		pep->totallen = len;
		pep->curlen = 0;
		pep->data_addr = (unsigned int)buf;		
		pep->state = CPU_WRITE;
		
		break;
	case 0x81:
		pep = GetEpState(1);
		pep->totallen = len;
		pep->curlen = 0;
		pep->data_addr = (unsigned int)buf;
		usb_setw(USB_REG_INTRINE,EP1_INTR_BIT); //open ep1 in intr

		if(len < pep->fifosize)
		{
			pep->state = CPU_WRITE;
			
			jz_writeb(USB_REG_INDEX,1);
			state =  jz_readw(USB_REG_INCSR);
			if(!(state & EP_FIFO_NOEMPTY))
			{
				len = len > pep->fifosize ? pep->fifosize :len;
				udc_write_fifo(pep,len);
				usb_setw(USB_REG_INCSR, USB_INCSR_INPKTRDY);		
				
			}
					
				
		}
		else
		{
			jz_writeb(USB_REG_INDEX,1);
			state =  jz_readw(USB_REG_INCSR);
			pep->state = DMA_WRITE;
			if(!(state & EP_FIFO_NOEMPTY))
				dma_send_data(pep);	
		}
		break;
		
	case 0x1:
		pep = GetEpState(2);
		pep->totallen = len;
		pep->curlen = 0;
		pep->data_addr = (unsigned int)buf;
		if(len < pep->fifosize)
		{
			
			pep->state = CPU_READ;
			usb_setw(USB_REG_INTROUTE,EP1_INTR_BIT);	//Enable Ep Out
			
		}
		else
		{
			pep->state = DMA_READ;
			dma_receieve_data(pep);
			
		}

		break;
	case 0xff:             //mean send stall!
//		printf("Send Stall! %x \n",jz_readw(USB_REG_INCSR));
		usb_setw( USB_REG_INCSR, 0x10);	//set stall
		while( ! (jz_readw(USB_REG_INCSR) & 0x20 ) );                //wait stall sent!
		usb_setw( USB_REG_INCSR, 0x60);	             //clear datatag!
		usb_clearw( USB_REG_INCSR, 0x10);	             //clear sendstall
		usb_clearw( USB_REG_INCSR, 0x20);	             //clear sentstall
//		printf("Clear stall! %x \n",jz_readw(USB_REG_INCSR));

		break;
	}
}
void init_endpoint_suppost(unsigned int handle,unsigned char *ep,USB_ENDPOINT_TYPE ep_type,unsigned short *ep_max_pkg)
{
	PEPSTATE pep;

	if(ep_type == ENDPOINT_TYPE_CONTROL)
	{
		*ep = 0;
		*ep_max_pkg = MAX_EP0_SIZE;
		
	}
	if(ep_type == ENDPOINT_TYPE_BULK)
	{
		if(*ep & 0x80)
			pep = GetEpState(1);
		else
			pep = GetEpState(2);
		
		*ep = pep->ep;
		*ep_max_pkg = pep->fifosize;
	}
//	printf("ep = %x ep_type = %x epmax = %x\r\n",*ep,ep_type,pep->fifosize);	
}

#ifdef USE_MIDWARE
static void GetRequest(MIDSRCDTA *dat)
{
	dat->Val = res.Val;
//	printf("Up layer get :%d \n",res.Val);
}

static void Response(MIDSRCDTA *dat)
{

	res.Val = dat->Val;
	printf("Up layer said :%d \n",res.Val);

}
#endif

void init_udc(PUDC_BUS pBus)
{
	pBus->EnableDevice = enable_device;
	pBus->SetAddress = set_address;
	pBus->StartTransfer = start_transfer;
	pBus->InitEndpointSuppost = init_endpoint_suppost;
	pBus->DisableDevice = disable_device;
	printf("Init UDC %s %s\n",__DATE__,__TIME__);

#ifdef USE_MIDWARE
	udcsrc.GetRequest = GetRequest;
	udcsrc.Response = Response;
	udcsrc.Name = "UDC";
	printf("Register Midware SRC udc! \n");
	RegisterMidSrc((PMIDSRC)&udcsrc);
	udcid = udcsrc.ID;
//	res.Val = 0xffff;
	cable_stat = CABLE_DISCONNECT;
	protocool_stat = CABLE_DISCONNECT;
#endif	
	dprintf("Init UDC\n");
	USB_Version=USB_HS;
	__intc_mask_irq(IRQ_UDC);
	__gpio_mask_irq(GPIO_UDC_DETE);
	
	udcEvent = OSSemCreate(0);
	dprintf("UDC with DMA reset!!\r\n");
	request_irq(IRQ_UDC, udc_intr_handler, 0);
	gpio_irq_init(pBus);
	udc_reset((unsigned int)pBus);
	dprintf("UDC with DMA reset finish!!\r\n");
	dprintf("Create UDC Task!!\r\n");
	OSTaskCreate(udc_task_entry, (void *)pBus,
		     (void *)&udcTaskStack[UDC_TASK_STK_SIZE - 1],
		     UDC_TASK_PRIO);
	
//	__gpio_unmask_irq(GPIO_UDC_DETE);
//	__intc_unmask_irq(IRQ_UDC);
#if 1
	if ( __gpio_get_pin(GPIO_UDC_DETE) == 1 )
	{
		__gpio_mask_irq(GPIO_UDC_DETE);
		udc_irq_type |= 0x10;
		OSSemPost(udcEvent);
	}
#endif
}

int udc_detect_status(void)
{
	printf("1:cable_stat == CABLE_CONNECTED: %d\n",(cable_stat == CABLE_CONNECTED));
    
	if ( protocool_stat == CABLE_CONNECTED )
		return 0;
	else return 1;
}

int udc_detect_cable_status(void)
{
	if(check_gpio(GPIO_UDC_DETE))
	{
		cable_stat = CABLE_CONNECTED;
		__gpio_as_irq_fall_edge(GPIO_UDC_DETE);
		
	}else
	{
		__gpio_as_irq_rise_edge(GPIO_UDC_DETE);
		cable_stat = CABLE_DISCONNECT;
	}
	//printf("dddddddddddddddddddd:%d = %d\n",GPIO_UDC_DETE,__gpio_get_pin(GPIO_UDC_DETE));
		
	printf("2:cable_stat == CABLE_CONNECTED: %d\n",(cable_stat == CABLE_CONNECTED));
    return (cable_stat == CABLE_CONNECTED);
}