usb_protocol.h

基于dsp2407a的探测系统程序（兼容usb和串口通讯）

/*******************************************/
void stall_ep0(void)			/*端点0 的stall信号*/
{
	D12_SetEndpointStatus(0, 1);
	D12_SetEndpointStatus(1, 1);
}

void disconnect_USB(void)		/*断开usb(softlink=0)*/
{
	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK, D12_SETTOONE | D12_CLOCK_12M);
}

void connect_USB(void)			/*连接usb(softlink=1)*/
{
	// reset event flags
	DISABLE;
	bEPPflags.value = 0;
	ENABLE;

	// V2.1 enable normal+sof interrupt
	D12_SetDMA(D12_ENDP4INTENABLE | D12_ENDP5INTENABLE);

	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK|D12_SOFTCONNECT, D12_SETTOONE | D12_CLOCK_12M);
}


void reconnect_USB(void)
{
	unsigned long clk_cnt;

//	MCU_LED0 = 0;
//	MCU_LED1 = 0;

	// Pull-down D12's SUSPEND pin
	// Disable 74HCT123 pulse generation before disconnect
	// Release D12's SUSPEND pin after receiving bus reset from host
	//D12SUSPD = 0;
	clrsuspend;
	disconnect_USB();

//	printf("Wait for 1 second ...\n");

	clk_cnt = ClockTicks;
	/*while(ClockTicks < clk_cnt + 20)
		;  
		*/ 
	for(clk_cnt=0;clk_cnt<1000;clk_cnt++)
	{
	delay();
	delay();
	delay();
	delay();
	delay();
	delay();
	}

	connect_USB();

//	MCU_LED0 = 1;
//	MCU_LED1 = 1;
}

void init_unconfig(void)
{
	unsigned char i;

	D12_SetEndpointEnable(0);	/* Disable all endpoints but EPP0. */
}

void init_config(void)
{
	D12_SetEndpointEnable(1);	/* Enable  generic/iso endpoints. */
}

void single_transmit(unsigned char * buf, unsigned char len)
/*单次发送数据,长度为len<端点最大长度*/
{
	if( len <= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, len, buf);
	}
}

void code_transmit(unsigned char const * pRomData, unsigned short len)
/*发送数据长度len>端点最大长度(多次发送)*/
{
	//ushort templength=(ControlData.wLengthh<<8)+ControlData.wLengthl;
	ControlData.wCountl=ControlData.wCounth = 0;
	if(ControlData.wLengthh > len)/*if(ControlData.wLength > len)*/
		ControlData.wLengthh = len;/*ControlData.wLength = len;*/
	ControlData.pData = pRomData;
	if( ControlData.wLengthh >= EP0_PACKET_SIZE)
	 {
		D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData);
		ControlData.wCounth += EP0_PACKET_SIZE;

		DISABLE;
		bEPPflags.bits.control_state = USB_TRANSMIT;
		ENABLE;
	}
	else 
	{
		D12_WriteEndpoint(1, ControlData.wLengthh, pRomData);
		ControlData.wCounth += ControlData.wLengthh;
		DISABLE;
		bEPPflags.bits.control_state = USB_IDLE;
		ENABLE;
	}
}
/*
void check_key_LED(void)
{
	static unsigned char c, last_key = 0xf;

	c = MCU_SWM0 & MCU_SWM1;
	c &= 0x0f;
	if (c != last_key) {
		D12_WriteEndpoint(3, 1, &c);
	}

	last_key = c;

	if(bEPPflags.bits.ep1_rxdone) {
		DISABLE;
		bEPPflags.bits.ep1_rxdone = 0;
		ENABLE;
		MCU_LED0 = !(GenEpBuf[3] & 0x1);
		MCU_LED1 = !(GenEpBuf[3] & 0x2);
	}
}
*/
void setup_dma()
{
	ioSize = ioRequest.uSize;
	ioCount = 0;

	DISABLE;
	bEPPflags.bits.dma_state = DMA_RUNNING;
	ENABLE;

	single_transmit(0, 0);

	if(ioRequest.bCommand & 0x1) {
		if(ioSize > 64 || ioSize == 0) {
			if(bNoRAM)
				D12_WriteEndpoint(5, 64, EpBuf);
			else
				D12_WriteEndpoint(5, 64, MainEpBuf);
			ioCount += 64;
		}
		else {
			if(bNoRAM)
				D12_WriteEndpoint(5, ioSize, EpBuf);
			else
				D12_WriteEndpoint(5, ioSize, MainEpBuf);
			ioCount += ioSize;
		}
	}
}
/*******************************************/



/*
   //*************************************************************************
   // USB Protocol Layer
   //*************************************************************************
*/

void reserved(void)
{
	stall_ep0();
}

/*
   //*************************************************************************
   // USB standard device requests
   //*************************************************************************
*/

void get_status(void)
{
	unsigned char endp, txdat[2];
	unsigned char bRecipient = ControlData.DeviceRequest.bmRequestType & USB_RECIPIENT;
	unsigned char c;

	if (bRecipient == USB_RECIPIENT_DEVICE) {
		if(bEPPflags.bits.remote_wakeup == 1)
			txdat[0] = 3;
		else
			txdat[0] = 1;
		txdat[1]=0;
		single_transmit(txdat, 2);
	} else if (bRecipient == USB_RECIPIENT_INTERFACE) {
		txdat[0]=0;
		txdat[1]=0;
		single_transmit(txdat, 2);
	} else if (bRecipient == USB_RECIPIENT_ENDPOINT) {
		endp = (unsigned char)(ControlData.DeviceRequest.wIndexh & MAX_ENDPOINTS);
		if (ControlData.DeviceRequest.wIndexh & (unsigned char)USB_ENDPOINT_DIRECTION_MASK)
			c = D12_SelectEndpoint(endp*2 + 1);	/* Control-in */
		else
			c = D12_SelectEndpoint(endp*2);	/* Control-out */
		if(c & D12_STALL)
			txdat[0] = 1;
		else
			txdat[0] = 0;
		txdat[1] = 0;
		single_transmit(txdat, 2);
	} else
		stall_ep0();
}

void clear_feature(void)
{
	unsigned char endp;
	unsigned char bRecipient = ControlData.DeviceRequest.bmRequestType & USB_RECIPIENT;

	if (bRecipient == USB_RECIPIENT_DEVICE
		&& ControlData.DeviceRequest.wValueh == USB_FEATURE_REMOTE_WAKEUP) {
		DISABLE;
		bEPPflags.bits.remote_wakeup = 0;
		ENABLE;
		single_transmit(0, 0);
	}
	else if (bRecipient == USB_RECIPIENT_ENDPOINT
		&& ControlData.DeviceRequest.wValueh == USB_FEATURE_ENDPOINT_STALL) {
		endp = (unsigned char)(ControlData.DeviceRequest.wIndexh& MAX_ENDPOINTS);
		if (ControlData.DeviceRequest.wIndexh & (unsigned char)USB_ENDPOINT_DIRECTION_MASK)
			/* clear TX stall for IN on EPn. */
			D12_SetEndpointStatus(endp*2 + 1, 0);
		else
			/* clear RX stall for OUT on EPn. */
			D12_SetEndpointStatus(endp*2, 0);
		single_transmit(0, 0);
	} else
		stall_ep0();
}

void set_feature(void)
{
	unsigned char endp;
	unsigned char bRecipient = ControlData.DeviceRequest.bmRequestType & USB_RECIPIENT;

	if (bRecipient == USB_RECIPIENT_DEVICE
		&& ControlData.DeviceRequest.wValueh == USB_FEATURE_REMOTE_WAKEUP) {
		DISABLE;
		bEPPflags.bits.remote_wakeup = 1;
		ENABLE;
		single_transmit(0, 0);
	}
	else if (bRecipient == USB_RECIPIENT_ENDPOINT
		&& ControlData.DeviceRequest.wValueh == USB_FEATURE_ENDPOINT_STALL) {
		endp = (unsigned char)(ControlData.DeviceRequest.wIndexh & MAX_ENDPOINTS);
		if (ControlData.DeviceRequest.wIndexh & (unsigned char)USB_ENDPOINT_DIRECTION_MASK)
			/* clear TX stall for IN on EPn. */
			D12_SetEndpointStatus(endp*2 + 1, 1);
		else
			/* clear RX stall for OUT on EPn. */
			D12_SetEndpointStatus(endp*2, 1);
		single_transmit(0, 0);
	} else
		stall_ep0();
}

void set_address(void)
{
	D12_SetAddressEnable((unsigned char)(ControlData.DeviceRequest.wValueh &
		DEVICE_ADDRESS_MASK), 1);
	single_transmit(0, 0);
//	senddis(" set address:",buf,(long)(sizeof(ControlData.DeviceRequest.wValueh &
//		DEVICE_ADDRESS_MASK)));
}

void get_descriptor(void)
{
	unsigned char bDescriptor = MSB(ControlData.DeviceRequest.wValueh);

	if (bDescriptor == USB_DEVICE_DESCRIPTOR_TYPE) 
	 {
		code_transmit((unsigned char const *)&DeviceDescr, sizeof(USB_DEVICE_DESCRIPTOR));
//	    senddis(" get device descriptor:",buf,(long)(sizeof(USB_DEVICE_DESCRIPTOR)));
	 } 
	else if (bDescriptor == USB_CONFIGURATION_DESCRIPTOR_TYPE)
	 {
		code_transmit((unsigned char const *)&ConfigDescr, CONFIG_DESCRIPTOR_LENGTH);
//		senddis(" get configuration descriptor:",buf,(long)(sizeof(USB_CONFIGURATION_DESCRIPTOR_TYPE)));
	 } 
	else 
	{
		stall_ep0(); 
//		sendstring("Stall_ep0\n\r");
		}
}

void get_configuration(void)
{
	unsigned char c = bEPPflags.bits.configuration;

	single_transmit(&c, 1); 
//	sendstring("get_configuration(void)\n\r");
}

void set_configuration(void)
{
	if (ControlData.DeviceRequest.wValueh == 0) {
		/* put device in unconfigured state */
		single_transmit(0, 0);
		DISABLE;
		bEPPflags.bits.configuration = 0;
		ENABLE;
		init_unconfig();
	} 
	else if (ControlData.DeviceRequest.wValueh == 1) {
		/* Configure device */
		single_transmit(0, 0);

		init_unconfig();
		init_config();
		
		DISABLE;
		bEPPflags.bits.configuration = 1;
		ENABLE;
	} 
	else
		stall_ep0();
}

void get_interface(void)
{
	unsigned char txdat = 0;        /* Only/Current interface = 0 */
	single_transmit(&txdat, 1);
}

void set_interface(void)
{
	if (ControlData.DeviceRequest.wValueh == 0 && ControlData.DeviceRequest.wIndexh == 0)
		single_transmit(0, 0);
	else
		stall_ep0();
}



/*********************************/

void get_firmware_version()
{
	unsigned char i;

	i = 0x30; // firmware version number
	single_transmit((unsigned char *)&i, 1);
}

void get_buffer_size()
{
	unsigned char i[4];

	if(bNoRAM == TRUE) {
		i[0] = EP2_PACKET_SIZE;
		i[1] = 0;
		i[2] = 0;
		i[3] = 0;
	} else {
		i[0] = 0;
		i[1] = 1;
		i[2] = 0;
		i[3] = 0;
	}
	single_transmit((unsigned char *)&i, 4);
}

void setup_dma_request()
{
	memcpy((unsigned char *)&ioRequest + ControlData.DeviceRequest.wValueh,
		ControlData.dataBuffer,
		ControlData.DeviceRequest.wLengthh);

	ioRequest.uSize = SWAP(ioRequest.uSize);
	ioRequest.uAddressL = SWAP(ioRequest.uAddressL);

	if(ioRequest.uSize > DMA_BUFFER_SIZE) 
	{ // Unaccepted request
		stall_ep0();
	}
	else if(bNoRAM == TRUE && ioRequest.uSize > EP2_PACKET_SIZE) 
	{
		stall_ep0();
	}
	else {
		if(bEPPflags.bits.dma_state == DMA_IDLE) 
		{
			DISABLE;
			bEPPflags.bits.setup_dma ++;
			ENABLE;
		}
		else 
		{
			DISABLE;
			bEPPflags.bits.dma_state = DMA_PENDING;
			ENABLE;
		}

	} // else if accepted request  
	
}	


/*******************************/

void read_write_register(void)
{
	unsigned char i;

	if(ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK) {

		if(bEPPflags.bits.verbose)
	/*		printf("Read Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.\n",
				ControlData.DeviceRequest.wValue,
				ControlData.DeviceRequest.wLength,
				ControlData.DeviceRequest.wIndex);
     */
		if(ControlData.DeviceRequest.wIndexh == GET_FIRMWARE_VERSION &&
			ControlData.DeviceRequest.wValueh == 0 &&
			ControlData.DeviceRequest.wLengthh == 1)
			get_firmware_version();
		else
		if(ControlData.DeviceRequest.wIndexh == GET_BUFFER_SIZE &&
			ControlData.DeviceRequest.wValueh == 0 &&
			ControlData.DeviceRequest.wLengthh == 4)
			get_buffer_size();
		else
			stall_ep0();

	}	// if read register
	else{
		if(bEPPflags.bits.verbose) {

	/*		printf("Write Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.\n",
				ControlData.DeviceRequest.wValue,
				ControlData.DeviceRequest.wLength,
				ControlData.DeviceRequest.wIndex);

			printf("Data: ");  
	*/
	/*		for(i = 0; i < ControlData.DeviceRequest.wLengthh; i ++)
				printf("0x%bx, ", *((ControlData.dataBuffer)+i));
			printf("\n");    
	*/		
		}

		if(ControlData.DeviceRequest.wIndexh == SETUP_DMA_REQUEST &&
			ControlData.DeviceRequest.wValueh == 0 &&
			ControlData.DeviceRequest.wLengthh == 6)
			setup_dma_request();
		else
			stall_ep0();
	}	// if write register
}



/*******************************/
/*
//*************************************************************************
// USB protocol function pointer arrays
//*************************************************************************
*/
//usb 标准请求结构
const void (*StandardDeviceRequest[])(void) =
{
	get_status,
	clear_feature,
	reserved,
	set_feature,
	reserved,
	set_address,
	get_descriptor,
	reserved,
	get_configuration,
	set_configuration,
	get_interface,
	set_interface,
	reserved,
	reserved,
	reserved,
	reserved
};//标准设备请求结构
// 用户厂商请求结构
const void (*VendorDeviceRequest[])(void) =
{
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	read_write_register,/*read_write_register,  */
	reserved,
	reserved,
	reserved
}; 

void control_handler()
{
	unsigned char type, req;

	type = ControlData.DeviceRequest.bmRequestType & USB_REQUEST_TYPE_MASK;
	req = ControlData.DeviceRequest.bRequest & USB_REQUEST_MASK;

//	help_devreq(type, req); // print out device request

	if (type == USB_STANDARD_REQUEST)
		(*StandardDeviceRequest[req])();
	else if (type == USB_VENDOR_REQUEST)
		(*VendorDeviceRequest[req])();
	else
		stall_ep0();
}

/*******************************/