read_reg.c

ubi9021的51驱动程序

	gInitState=IS_NO_INIT;

	if(mode&RST9021_FULL_RESET)
	{
		PW_RST_PORT_DIR_OUT;
		IO_BUS_RESET_HIGH;//PW_RST_PORT_LOW;
		RISC_sleep_cycles(UMO_RESET_IDLE_TICKS);
		IO_BUS_RESET_LOW;//PW_RST_PORT_HIGH;
		RISC_sleep_cycles(UMO_RESET_IDLE_TICKS);
		IO_BUS_RESET_HIGH;//PW_RST_PORT_LOW;
		RISC_sleep_cycles(UMO_RESET_IDLE_TICKS);
		IO_BUS_RESET_LOW;//PW_RST_PORT_HIGH;
		RISC_sleep_cycles(UMO_RESET_IDLE_TICKS);
	}

        IO_BUS_RESET_HIGH;
        MCU_SEL_OUT=0x01;
        RISC_sleep_cycles(UMO_RESET_IDLE_TICKS);
	DEV_WriteReg(RH_CHIP_CTR2,0x20);
	//RISC_sleep_cycles(UMO_RESET_IDLE_TICKS);
	UH_ENFORCE_HOST_MODE();
	UH_ENFORCE_HOST_MODE();

	DEV_WriteReg(RH_CHIP_CTR2,0x00);	//suspend 120msec before USB reset
//	EPRINTF(("DEV_ResetChip!!!\n"));
	return RES_OK;
}




/******************************************************************************
 *		Reset USB Device (for about 12msec)
 *		and wait for (?) msec for device init
 *
 *	RETURN:
 *		- RES_OK : reset + delay OK
 *		- RES_ERR: on SOF --> device plugged-off
 ******************************************************************************/
U8 DEV_ResetUsbDevice(U8 msIdle)
{
    U8 i;

	//050131 捞惑窍霸 咯扁辑 吧府绰淀窃!!!	if(!UH_DEV_IS_PLUGGEDIN()) return RES_ERR;
    if(!UH_DEV_IS_PLUGGEDIN()) return RES_ERR;

    DEV_WriteReg(RH_INT_EN,UH_IRQ_SOF);
    DEV_WriteReg(RH_CHIP_CTR2,0x10);	//SOF
    DEV_WriteReg(RH_CHIP_CTR1,0xC0);	//reset device
    for(i=0;i<msIdle;i++){
		RISC_sleep_nsec(1000000); //1msec
    }
    return RES_OK;
}

void DEV_StopTriggerIn(U8 fReset)
{
	U8  i=0;
	U32 j;

	DEV_WriteReg(RH_DEV_ADDR,0x0F);
	UH_SET_FIFO_SZ_EACH(0,1);
	UH_FIFO_ROLLBACK_OUT();
	DEV_WriteReg(RH_CHIP_CTR1,0x01);

	for(j=0;j<300;j++){
		RISC_sleep_nsec(10000); //3msec
	}

	if(fReset){
		U8 temp = DEV_ReadReg(RH_MASS_ADDR2);
		DEV_WriteReg(RH_CHIP_CTR2,0x20);
		UH_ENFORCE_HOST_MODE();
		UH_ENFORCE_HOST_MODE();
		DEV_WriteReg(RH_USB_HOST_BASE_LEN,gMxPkSz);
		if(temp==UMO_DEVICE_INIT_OK) DEV_WriteReg(RH_MASS_ADDR2,UMO_DEVICE_INIT_OK);
	}
	DEV_WriteReg(RH_CHIP_CTR1,0x00);
	UH_FIFO_ROLLBACK_OUT();
	DEV_WriteReg(RH_DEV_ADDR,gDevAddr);
	DEV_WriteReg(RH_INT_EN,0);
	DEV_ReadReg(RH_INT_STS);
}


U8	DEV_SafeTriggerAndWaitForInPacket(U8 ep, U16 bytCnt, U16 msec)
{
	U32 time;

	UH_FIFO_ROLLBACK_IN();
	DEV_WriteReg(RH_FIFO_SZ_LO,(U8)bytCnt);
	DEV_WriteReg(RH_FIFO_SZ_HI,(U8)(bytCnt>>8));
	DEV_WriteReg(RH_INT_EN,UH_IRQ_SOF);//UH_IRQ_READ_READY);//UH_IRQ_USB_PKT_DONE);
	DEV_ReadReg(RH_INT_STS); //??
	//printf("RH_INT_STS");
	time = 20000*1000;
	while(time--){ if(UBi9021_IRQ_PENDING()){ DEV_ReadReg(RH_INT_STS); break; } _nop_(); } //sync to SOF
	DEV_WriteReg(RH_EP_ADDR_N_PID,ep);

	for(time=0; time<msec; )//for(ticks=0; ticks<gWaitPktTicks; ticks++)
	{
		if(UBi9021_IRQ_PENDING())
		{
			RISC_sleep_nsec(100); //200usec
			GET_UBi9021_IRQ_STS(gUsbIrq);
			if(gUsbIrq&(UH_IRQ_READ_READY|UH_IRQ_USB_PKT_DONE)) break;
			else if(gUsbIrq&UH_IRQ_SOF) time++;
			gUsbIrq = 0;
		}
		if( (0xD0!=ep) && DEV_ReadReg(RH_LAST_PKT_STS)==UH_LST_PKT_STS_STALL){
			DEV_StopTriggerIn(1);
			USB_ResetPipe(gEPIN);
			USB_ResetPipe(gEPOUT);
			return UH_IRQ_FAKE_STALL; //STALL mark
		}
		if(gDevAddr!=DEV_ReadReg(RH_DEV_ADDR)||UMO_DEVICE_INIT_OK!=DEV_ReadReg(RH_MASS_ADDR2)) break;
	}

	if((0x80&ep)&&(0xD0!=ep)&&(gUsbIrq&UH_IRQ_READ_READY)==0) DEV_StopTriggerIn(0);//Short-Packet

	DEV_WriteReg(RH_INT_EN,0);
	return gUsbIrq;
}
/******************************************************************************
 *	wait until (small) packet tranfer done
 ******************************************************************************/

U8	WaitSmallPacket(U8 ep)
{
	U8	usbIrq,res=RES_ERR;
	//U32 ticks;

	if(!UH_DEV_IS_PLUGGEDIN()) return RES_ERR;
	DEV_TimerStart(100);
	while(gUsbTimeOver==0) //wait maximum 100msec
	{
		if(UBi9021_IRQ_PENDING())
		{
			GET_UBi9021_IRQ_STS(usbIrq);
			if( (!(0x80&ep)||(0xD0==ep)) &&
				(DEV_ReadReg(RH_LAST_PKT_STS)&UH_LST_PKT_STS_NAK) ){
				DEV_WriteReg(RH_EP_ADDR_N_PID,ep);
				continue;
			}
			if(usbIrq&UH_IRQ_USB_PKT_DONE){
				DEV_WriteReg(RH_INT_EN,0);
				return RES_OK;
			}
		}
		if((0xD0!=ep) && (DEV_ReadReg(RH_LAST_PKT_STS)==UH_LST_PKT_STS_STALL)){
			res = UH_IRQ_FAKE_STALL; //STALL mark
			break;
		}
	}

	DEV_StopTriggerIn(0);
	DEV_WriteReg(RH_INT_EN,0);
	return res;
}



/******************************************************************************
 *	clear feature
 ******************************************************************************/

U8 USB_ResetPipe(U8 bEpAddr)//reset pipe
{
	U8* buf = (U8*)(gCBW+18);

	MemFill(buf, 0, 8);
	buf[0]=0x02;//type:standard,recipient:endpoint
	buf[1]=0x01;//CLEAR_FEATURE
	buf[4]=(bEpAddr&~0x10);//endpoint address

	DEV_WriteReg(RH_USB_HOST_BASE_LEN,gMxPkSzCtr);
	UH_FIFO_ROLLBACK_OUT();
	UH_SET_FIFO_SZ_EACH(0,8);
	DEV_WriteReg(RH_INT_EN,UH_IRQ_USB_PKT_DONE);
	DEV_WriteRegMulti(RH_USB_HOST_BASE_ADDR,8,buf);
	DEV_WriteReg(RH_EP_ADDR_N_PID,gEP=0xD0);
	if(ISERR(WaitSmallPacket(0xD0))) return RES_ERR;
	MemFill(buf,0,31-18);
	DEV_WaitMS(1);//??

	DEV_WriteReg(RH_DEV_ADDR,gDevAddr);
	UH_FIFO_ROLLBACK_IN();
	DEV_WriteReg(RH_USB_HOST_BASE_LEN,0);//zero packet
	UH_SET_FIFO_SZ_EACH(0,0);
	UH_IRQ_EN(UH_IRQ_USB_PKT_DONE);
	UH_Trigger(0x90);	///PID=DATA1
	if(ISERR(WaitSmallPacket(0x90))) return RES_ERR;

	DEV_WriteReg(RH_INT_EN,0);
	DEV_WriteReg(RH_USB_HOST_BASE_LEN,gMxPkSz); //restore max packet size
	return RES_OK;
}



/******************************************************************************
 *
 *	OPERATION:
 *		parse configuration descriptor and get some parameters
 *
 *	INPUT:
 *		-bcnt: byte count of the configuration descriptors
 *
 *	OUTPUT:
 *		- gMxPkSz : maximum packet size of a bulk-pipe
 *		- gEPIN   : bulk-in pipe
 *		- gEPOUT  : bulk-out pipe
 *		- gUsbCfg : value to be used in set-configuration
 *
 *	RETURN:
 *		- RES_OK   : BulkOnly type mass storage
 *					 bInterfaceClass    = 8 : Mass Storage
 *					 bInterfaceProtocol = 0x50 : BulkOnly
 *		- RES_ERR  :
 *		- RES_ERR+1: Unknown Device
 *		- RES_ERR+2: CBI type mass storage
 *					 bInterfaceClass    = 8 : Mass Storage
 *					 bInterfaceProtocol = 1 : CBI
 *		- RES_ERR+3: PTP (Picture Tranfer Protocol) type
 *					 bInterfaceClass    = 6 : Imaging
 *					 bInterfaceSubClass = 1 : Still Image Capture
 *					 bInterfaceProtocol = 1 : Picture Transfer Protocol (PIMA 15470)
 *
 ******************************************************************************/
U8 ParseConfigDesc(IN U8 bcnt, IN U8* pDesc)
{
	while(bcnt>0)
	{
		switch(pDesc[1])
		{
		case DESC_CONFIG:
			if(pDesc[4]<1)return RES_ERR;	//number of interfaces
			gUsbCfg = pDesc[5];
			gIFSC = nOK08;
			gEPIN = gEPOUT = nOK08;
			break;
		case DESC_INTERFACE:
			gIFSC = nOK08;
			gEPIN = gEPOUT = nOK08;
			if(pDesc[5]==IFC_MASSSTORAGE){
				if(pDesc[7]==IFP_CBI) return RES_ERR+2;
				if(pDesc[7]==IFP_BULKONLY) gIFSC = pDesc[6]; //interface subclass
			}
			else if(pDesc[5]==IFC_IMAGING){
				return RES_ERR+3;
			}
			break;
		case DESC_ENDPOINT:
			if(gIFSC!=nOK08 && pDesc[3]==EPTYPE_BULK){
				if(pDesc[2]&0x80){ gEPIN = pDesc[2]; gMxPkSz = pDesc[4]; }
				else{ gEPOUT = pDesc[2]; gMxPkSz = pDesc[4]; }
			}
			break;
		}
		if((gEPIN!=nOK08)&&(gEPOUT!=nOK08)) break;
		if((pDesc[0]<3)||(pDesc[0]>9)) return RES_ERR;
		if(bcnt<=pDesc[0]) break;

		bcnt  -= pDesc[0];
		pDesc += pDesc[0];
	}

	if((gEPIN==nOK08)||(gEPOUT==nOK08)) return RES_ERR+1;

	gEPIN  |= 0x10;								//BULK-IN
	gEPOUT |= 0x10;								//BULK-OUT
	DEV_WriteReg(RH_USB_HOST_BASE_LEN,gMxPkSz);	//set MAX-PACKET-SIZE for BULK

	return RES_OK;
}





/******************************************************************************
 *	INPUT:
 *		- type: type of the usb setup transfer
 *		- arg : type==USB_SETUP_GET_DEV_DESC_INIT -> byte length
 *				type==USB_SETUP_GET_DEV_DESC -> byte length
 *				type==USB_SETUP_GET_CFG_DESC -> byte length
 *				type==USB_SETUP_SET_ADDR     -> new address
 *				type==USB_SETUP_SET_CFG      -> new configuration
 *				type==others                 -> no use
 *		- buf :
 *
 *	RETURN:
 *		RES_OK
 *		RES_ERR: timeout
 *
 *	NOTE: 老窜 ep0甫 烹秦辑 背券登绰 data绰 128俺 捞窍扼绊 啊沥.
 *
 ******************************************************************************/
  int disable_debug=0;

U8 USB_ControlTransfer(U8 type, U8 arg, U8* buf)
{
	U8 dataByteCnt,res;
//printf("control pipe start.\n");
if(type==USB_SETUP_GET_DEV_DESC_INIT)
{
	//printf("Type:%d\n",type);
	if(disable_debug==0)
	enable_debug=1;
}
//enable_debug=1;
	MemFill(buf,0,8);

	switch(type)
	{
		case USB_SETUP_GET_DEV_DESC_INIT:
		case USB_SETUP_GET_DEV_DESC:
		case USB_SETUP_GET_CFG_DESC:
			buf[0]=0x80,buf[1]=0x06,buf[6]=arg;
			buf[3]=(type==USB_SETUP_GET_CFG_DESC)?0x02:0x01;
			break;
		case USB_SETUP_SET_ADDR:
			buf[1]=0x05,buf[2]=arg;
			break;
		case USB_SETUP_SET_CFG:
			buf[1]=0x09,buf[2]=arg;
			break;
		case USB_SETUP_SET_PORT_PWR:
		case USB_SETUP_PORT_RST:
			buf[0]=0x23,buf[1]=0x03,buf[4]=0x01;
			buf[2]=(type==USB_SETUP_SET_PORT_PWR)?0x08:0x04;
			break;
		case USB_SETUP_CLR_PORT_RST:
			buf[0]=0x23,buf[1]=0x01,buf[2]=0x14,buf[4]=0x01;
			break;
		case USB_SETUP_GET_PORT_STS:
			buf[0]=0xA3,buf[4]=0x01,buf[6]=0x04;
			break;
		case USB_SETUP_GET_MAX_LUN:
			buf[0]=0xA1,buf[1]=0xFE,buf[6]=0x01;
			break;
		default: return RES_ERR;
	}


    UH_SET_FIFO_SZ_EACH(0,8);
	UH_FIFO_ROLLBACK_OUT();
	DEV_WriteRegMulti(RH_USB_HOST_BASE_ADDR,8,buf);
	UH_IRQ_EN(UH_IRQ_USB_PKT_DONE);
    UH_Trigger(0xd0); ///PID=SETUP(OUT)
	if(DEV_WaitForIrq(UH_IRQ_USB_PKT_DONE)==0) {return RES_ERR;}
	DEV_WaitMS(50);


	UH_FIFO_ROLLBACK_IN();
	dataByteCnt = (USB_SETUP_GET_DEV_DESC_INIT==type)?8:buf[6];
	if(dataByteCnt==0)
	{
		DEV_WriteReg(RH_USB_HOST_BASE_LEN,0);
		UH_SET_FIFO_SZ_EACH(0,0);
		UH_IRQ_EN(UH_IRQ_USB_PKT_DONE);
		UH_Trigger(0x90); ///PID=DATA1(IN)
		res = DEV_WaitForIrq(UH_IRQ_USB_PKT_DONE);
		if((0==res)||(UH_IRQ_FAKE_STALL==res)) {return RES_ERR;}
	}
	else//DATA-IN
	{
		U8 volatile subCnt = gMxPkSzCtr;
		DEV_WriteReg(RH_USB_HOST_BASE_LEN,gMxPkSzCtr);
		DEV_WriteReg(RH_FIFO_SZ_HI,0);

		while(dataByteCnt>0)
		{
			if(dataByteCnt<gMxPkSzCtr) subCnt = dataByteCnt;

			res = DEV_SafeTriggerAndWaitForInPacket(0x90,subCnt,2000);
			if(res==0) {return RES_ERR;}
			if(res==UH_IRQ_FAKE_STALL) {return RES_ERR;}
			DEV_ReadRegMulti(RH_USB_HOST_BASE_ADDR,subCnt,buf);
			if(0xEC==buf[8]&&0x0A==buf[9]&&USB_SETUP_GET_DEV_DESC==type) break;	//Active memory-stick reader
			dataByteCnt -= subCnt;
			buf += subCnt;
		}
		//UH_FIFO_ROLLBACK();

		//printf("hand shake###########################\n");
		// Hand Shake transaction
		DEV_WaitMS(1);

		UH_FIFO_ROLLBACK_OUT();
		UH_SET_FIFO_SZ_EACH(0,0);
		UH_IRQ_EN(UH_IRQ_USB_PKT_DONE);	//WALTZ俊辑 UH_IRQ_SOF尔 UH_IRQ_WRITE_READY绰 哆绰单
										//UH_IRQ_USB_PKT_DONE捞 救 哆绰 版快啊 乐菌澜.
		UH_Trigger(0x10);				///PID=OUT
		res = DEV_WaitForIrq(UH_IRQ_USB_PKT_DONE|UH_IRQ_WRITE_READY);
		if((0==res)||(UH_IRQ_FAKE_STALL==res)) {return RES_ERR;}
	}

	DEV_WriteReg(RH_USB_HOST_BASE_LEN,gMxPkSz);//not "gMxPkSzCtr"
	enable_debug=0;
	return RES_OK;

}




/******************************************************************************
 *	Chip reset + Mass Storage Device Enumeration + Identify LUNs
 *	Only Support "BulkOnly Mass Storage"
 *
 *	RETURN:
 *		RES_OK
 *		RES_ERR  : unknown error
 *		RES_ERR+1: Device Type Error: Unknown Device
 *		RES_ERR+2: Device Type Error: CBI type mass storage
 *		RES_ERR+3: Device Type Error: PTP
 ******************************************************************************/

U8	UM_InitMassStorDevice(OUT U8* buf)
{
	U8 res,i;
	gEPOUT   = 0x10;
	gDevAddr = 0;
	gEP      = 0xFF;

	//EPRINTF(("\nUM_InitMassStorDevice\n"));
    if(ISERR(DEV_ResetChip(RST9021_FULL_RESET))) return RES_ERR;
	for(i=0;i<2;i++) RISC_sleep_cycles(100000); //total 162msec

	if(ISERR(DEV_ResetUsbDevice(200))) return RES_ERR; //reset flash key (12msec) + idle(60msec:PC=30)
	UH_FIFO_DIR_OUT();
	DEV_WriteReg(RH_DEV_ADDR,gDevAddr=0);
	DEV_WriteReg(RH_MASS_ADDR2,0x5A); //mark for validity of the device address
	gMxPkSz=gMxPkSzCtr=64;
	DEV_WriteReg(RH_USB_HOST_BASE_LEN,gMxPkSzCtr);
	UH_SET_FIFO_SZ_EACH(0,8);
	if(ISERR(USB_ControlTransfer(USB_SETUP_GET_DEV_DESC_INIT,0x40,buf))) {return RES_ERR;}
		if(ISERR(DEV_ResetUsbDevice(100))) return RES_ERR;	//reset flash key (12msec) + idle(30msec:PC=20)

    gMxPkSzCtr = buf[7];	//maximum packet size for control pipe
	DEV_WriteReg(RH_USB_HOST_BASE_LEN,gMxPkSzCtr);


	if(buf[4]==0x09)//if HUB device exists..
	{
		////////////////////////////////////
		///HUB CONFIGURATION : Address=4
		////////////////////////////////////

		DEV_WriteReg(RH_DEV_ADDR,gDevAddr=0);
		if(ISERR(USB_ControlTransfer(USB_SETUP_SET_ADDR,UMO_DEFAULT_HUB_ADDRESS,buf))) return RES_ERR;
		DEV_WriteReg(RH_DEV_ADDR,gDevAddr=UMO_DEFAULT_HUB_ADDRESS);

		if(ISERR(USB_ControlTransfer(USB_SETUP_GET_DEV_DESC,0x12,buf))) return RES_ERR;

		//GET CONFIG-DESCRIPTOR:0xffbyte
		if(ISERR(USB_ControlTransfer(USB_SETUP_GET_CFG_DESC,0x09,buf))) return RES_ERR;
		if(buf[2]>0x09){
			if(ISERR(USB_ControlTransfer(USB_SETUP_GET_CFG_DESC,buf[2],buf))) return RES_ERR;
		}

		//GET HUB-DESCRIPTOR:9byte
		/*BUILD_USB_REQUEST(gCBW,0xA0,0x06,0x00,0x00,0x00,0x00,0x47,0x00);//0x47???
		if(ISERR(USB_ControlTransfer((U8*)gCBW,9,buf))) return RES_ERR;
		*/

		if(ISERR(USB_ControlTransfer(USB_SETUP_SET_CFG,buf[5],buf))) return RES_ERR;


		///////////////////////////
		///	PORT-1 CONFIGURATOIN
		///////////////////////////

		if(ISERR(USB_ControlTransfer(USB_SETUP_SET_PORT_PWR,0,buf))) return RES_ERR;

		//CLEAR-PORT1-CONNECTION:
		//BUILD_USB_REQUEST(gCBW,0x23,0x01,0x10,0x00,0x01,0x00,0x00,0x00);
		//if(ISERR(USB_ControlTransfer((U8*)gCBW,0,buf))) return RES_ERR;

		if(ISERR(USB_ControlTransfer(USB_SETUP_PORT_RST,0,buf))) return RES_ERR;
		DEV_WaitMS(5);//TODO:盔贰绰 牢磐反飘IN阑 扁促妨具...

		if(ISERR(USB_ControlTransfer(USB_SETUP_GET_PORT_STS,0,buf))) return RES_ERR;

		if(ISERR(USB_ControlTransfer(USB_SETUP_CLR_PORT_RST,0,buf))) return RES_ERR; //咯扁辑 粱 坷贰吧覆.
		DEV_WaitMS(55); //SOF 55俺 沥档..
	}

	/////////////////////////////////////////////////////
	//       M A N U A L    E N U M E R A T I O N
	/////////////////////////////////////////////////////

	DEV_WriteReg(RH_DEV_ADDR,gDevAddr=0);
	if(ISERR(USB_ControlTransfer(USB_SETUP_SET_ADDR,UMO_DEFAULT_DEV_ADDRESS,buf))) return RES_ERR;
	//printf("control5 control5 control5 control5 control5.\n");
	DEV_WriteReg(RH_DEV_ADDR,gDevAddr=UMO_DEFAULT_DEV_ADDRESS);
	
	if(ISERR(USB_ControlTransfer(USB_SETUP_GET_DEV_DESC,0x12,buf))) return RES_ERR;
	//printf("control4 control4 control4 control4 control4.\n");
	//{
	//	int i;
	//	printf("get12\n");
	//	for(i=0;i<buf[0];i++)
	//	{
	//		printf("%02x ",buf[i]);
	//	}
	//	printf(" \n");
	//}


	gUsbVer = (buf[3]==1)?USB_VER_1X:((buf[3]==2)?USB_VER_2X:USB_VER_UNKNOWN);
	gVID=(U16)buf[9],gVID=(gVID<<8)+(U16)buf[8];
	gPID=(U16)buf[11],gPID=(gPID<<8)+(U16)buf[10];
	if(buf[4]!=0) return RES_ERR;//check if CLASS is defined in Interface-Descriptor

	//GET CONFIG-DESCRIPTOR:0xffbyte
	if(ISERR(USB_ControlTransfer(USB_SETUP_GET_CFG_DESC,0x09,buf))) return RES_ERR;
	//printf("control3 control3 control3 control3 control3.\n");
	//{
	//	int i;
	//	printf("get9\n");
	//	for(i=0;i<buf[0];i++)
	//	{
	//		printf("%02x ",buf[i]);
	//	}
	//	printf(" \n");
	//}
	if(buf[2]>0x09){
		if(ISERR(USB_ControlTransfer(USB_SETUP_GET_CFG_DESC,buf[2],buf))) return RES_ERR;
		//printf("control2 control2 control2 control2 control2.\n");
		//{
		//int i;
		//printf("get buf[2]\n");
		//for(i=0;i<buf[0];i++)
		//{
		//	printf("%02x ",buf[i]);
		//}
		//printf(" \n");
	//}
	}
	res = ParseConfigDesc((U8)buf[2],buf);
	if(ISERR(res)) return res;

	DEV_WaitMS(5);
	if(ISERR(USB_ControlTransfer(USB_SETUP_SET_CFG,gUsbCfg,buf))) return RES_ERR;
	//printf("control1 control1 control1 control1 control1.\n");

	/// Enumeration OK!

	gLun    = 0;
	gMaxLun = 0;

	///initialize SCSI-CBW tag
	gCBW[0]=0x55,gCBW[1]=0x53,gCBW[2]=0x42,gCBW[3]=0x43;
	gCBW[4]=0x39,gCBW[5]=0x30,gCBW[6]=0x32,gCBW[7]=0x31;


	gInitState = IS_ENUM_OK;
	//printf("********************************************\n");
//	printf("********************************************\n");
    return RES_OK;
}



int USB_identify_device()
{
	//U8 devAddr,res;
	int i;
	int ret_code = -1;
    unsigned char buf[64];
    ubi9021_hardreset();
    DEV_WaitMS(6000);
    gWaitUsbPktMsec = 4000; //4sec
	gSecAddr=-1;
	gSecCnt=0;


    if(DEV_ReadReg(RH_DEV_ADDR)==UMO_INIT_FAIL_DEV_ADDRESS && DEV_ReadReg(RH_MASS_ADDR2)==UMO_DEVICE_INIT_OK) return 0;

    for(i=0;i<100;i++)
    {
	DEV_ResetChip(RST9021_FULL_RESET);
	ret_code =  UM_InitMassStorDevice((U8*)buf);
	if(ISERR(ret_code)){
		if(DEV_ReadReg(RH_LAST_PKT_STS)==0){ //no response from device
				DEV_WaitMS(1000); //100msec
		}
		continue;
	}

	ret_code =  UM_InitMultiLun((U8*)buf);
	if(ISERR(ret_code)) continue;
  	   break;
   }

   if (ISERR(ret_code))
   {
		DEV_WriteReg(RH_DEV_ADDR,UMO_INIT_FAIL_DEV_ADDRESS);
		DEV_WriteReg(RH_MASS_ADDR2,UMO_DEVICE_INIT_OK);
		DEV_WriteReg(RH_CHIP_CTR2,0); //kill SOF
		return 0 ;
   }


   gWaitUsbPktMsec = 1000; //1msec
   return 1;
}






void main()
{
       IO_IRQ_READY;
       IO_PLUGIN_READY;
       USB_identify_device();
	   USB_boot_setup();
       //USB_read_sector_lba();
       while(1);

}