testusbbin.c

uCOS上移植的USB。今天终于可以使用我的了

  	outportb(D12_COMMAND,0x40+bEndp);
  	return inportb(D12_DATA);
}


void D12_SetEndpointStatus(unsigned char bEndp,unsigned char bStalled)
{
  	outportb(D12_COMMAND,0x40+bEndp);
  	outportb(D12_DATA,bStalled);
}

unsigned char D12_ReadEndpointStatus(unsigned char bEndp)
{
  	outportb(D12_COMMAND,0x80+bEndp);
  	return inportb(D12_DATA);
}


//send resume  command
void D12_SendResume(void)
{
  	outportb(D12_COMMAND,0xF6);
}

unsigned short D12_ReadCurrentFrameNumber(void)
{
	unsigned short i,j;
	outportb(D12_COMMAND,0xF5);
  	i=inportb(D12_DATA);
  	j=inportb(D12_DATA);
  	i+=(j<<8);
  	return i;	
}


unsigned char D12_ReadEndpoint(unsigned char endp,unsigned char len,unsigned char * buf)
{
	unsigned char i,j;
	outportb(D12_COMMAND,endp);
	if((inportb(D12_DATA)&D12_FULLEMPTY)==0)  return 0;
	outportb(D12_COMMAND,0x80+endp);
	i=inportb(D12_DATA);
	i=i&0x60;
	if(endp==4)
	{
		if(i==0x60)   bEPPflags.bits.ep2buf_full=1;
		else bEPPflags.bits.ep2buf_full=0;
	}
	outportb(D12_COMMAND,0xF0);
	j=inportb(D12_DATA);
	j=inportb(D12_DATA);
	if(j>len)  j=len;
	for(i=0;i<j;i++)  *(buf+i)=inportb(D12_DATA);
	outportb(D12_COMMAND,0xF2);
	return j;
}

unsigned char D12_WriteEndpoint(unsigned char endp,unsigned char len,unsigned char * buf)
{
	unsigned char i;
	outportb(D12_COMMAND,endp);
	inportb(D12_DATA);
	outportb(D12_COMMAND,0xF0);
	outportb(D12_DATA,0);
	outportb(D12_DATA,len);
	for(i=0;i<len;i++)  	outportb(D12_DATA,*(buf+i));
	outportb(D12_COMMAND,0xFA);
	return len;
}

//endpoint acknowledge 
void D12_AcknowledgeEndpoint(unsigned char endp)
{
	outportb(D12_COMMAND,endp);
	outportb(D12_COMMAND,0xF1);
	if(endp==0)
	outportb(D12_COMMAND,0xF2);		
}





//chap_9
USB_DEVICE_DESCRIPTOR DeviceDescr =
{
	sizeof(USB_DEVICE_DESCRIPTOR),
    USB_DEVICE_DESCRIPTOR_TYPE,
    SWAP(0x0100),
    USB_CLASS_CODE_TEST_CLASS_DEVICE,
    0, 0,
	EP0_PACKET_SIZE,
	SWAP(0x0471),
	SWAP(0x0666),
	SWAP(0x0100),
    0, 0, 0,
	25
};

 USB_CONFIGURATION_DESCRIPTOR ConfigDescr =
{
    sizeof(USB_CONFIGURATION_DESCRIPTOR),
    USB_CONFIGURATION_DESCRIPTOR_TYPE,
    SWAP(CONFIG_DESCRIPTOR_LENGTH),
	1,
	1,
    0,
	0x60,
	0x1
};

 USB_INTERFACE_DESCRIPTOR InterfaceDescr =
{
    sizeof(USB_INTERFACE_DESCRIPTOR),
    USB_INTERFACE_DESCRIPTOR_TYPE,
    0,
    0,
	NUM_ENDPOINTS,
	USB_CLASS_CODE_TEST_CLASS_DEVICE,
	USB_SUBCLASS_CODE_TEST_CLASS_D12,
	USB_PROTOCOL_CODE_TEST_CLASS_D12,
	0
};

 USB_ENDPOINT_DESCRIPTOR EP1_TXDescr =
{
	sizeof(USB_ENDPOINT_DESCRIPTOR),
	USB_ENDPOINT_DESCRIPTOR_TYPE,
	0x81,
	USB_ENDPOINT_TYPE_INTERRUPT,
	SWAP(EP1_PACKET_SIZE),
	10
};

 USB_ENDPOINT_DESCRIPTOR EP1_RXDescr =
{
	sizeof(USB_ENDPOINT_DESCRIPTOR),
	USB_ENDPOINT_DESCRIPTOR_TYPE,
	0x1,
	USB_ENDPOINT_TYPE_INTERRUPT,
	SWAP(EP1_PACKET_SIZE),
	10
};

USB_ENDPOINT_DESCRIPTOR EP2_TXDescr =
{
	sizeof(USB_ENDPOINT_DESCRIPTOR),
	USB_ENDPOINT_DESCRIPTOR_TYPE,
	0x82,
	USB_ENDPOINT_TYPE_BULK,
	SWAP(EP2_PACKET_SIZE),
	10
};

 USB_ENDPOINT_DESCRIPTOR EP2_RXDescr =
{
	sizeof(USB_ENDPOINT_DESCRIPTOR),
	USB_ENDPOINT_DESCRIPTOR_TYPE,
	0x2,
	USB_ENDPOINT_TYPE_BULK,
	SWAP(EP2_PACKET_SIZE),
	10
};

/*
   *************************************************************************
    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.wIndex & MAX_ENDPOINTS);
		if (ControlData.DeviceRequest.wIndex & (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.wValue == USB_FEATURE_REMOTE_WAKEUP) {
		DISABLE;
		bEPPflags.bits.remote_wakeup = 0;
		ENABLE;
		single_transmit(0, 0);
	}
	else if (bRecipient == USB_RECIPIENT_ENDPOINT
		&& ControlData.DeviceRequest.wValue == USB_FEATURE_ENDPOINT_STALL) {
		endp = (unsigned char)(ControlData.DeviceRequest.wIndex & MAX_ENDPOINTS);
		if (ControlData.DeviceRequest.wIndex & (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.wValue == USB_FEATURE_REMOTE_WAKEUP) {
		DISABLE;
		bEPPflags.bits.remote_wakeup = 1;
		ENABLE;
		single_transmit(0, 0);
	}
	else if (bRecipient == USB_RECIPIENT_ENDPOINT
		&& ControlData.DeviceRequest.wValue == USB_FEATURE_ENDPOINT_STALL) {
		endp = (unsigned char)(ControlData.DeviceRequest.wIndex & MAX_ENDPOINTS);
		if (ControlData.DeviceRequest.wIndex & (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.wValue &
		DEVICE_ADDRESS_MASK), 1);
	single_transmit(0, 0);
}

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

	if (bDescriptor == USB_DEVICE_DESCRIPTOR_TYPE) {
		code_transmit((unsigned char *)&DeviceDescr, sizeof(USB_DEVICE_DESCRIPTOR));
	} else if (bDescriptor == USB_CONFIGURATION_DESCRIPTOR_TYPE) {
		code_transmit((unsigned char *)&ConfigDescr, CONFIG_DESCRIPTOR_LENGTH);
	} else
		stall_ep0();
}

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

	single_transmit(&c, 1);
}

void set_configuration(void)
{
	if (ControlData.DeviceRequest.wValue == 0) {
		/* put device in unconfigured state */
		single_transmit(0, 0);
		DISABLE;
		bEPPflags.bits.configuration = 0;
		ENABLE;
		init_unconfig();
	} else if (ControlData.DeviceRequest.wValue == 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.wValue == 0 && ControlData.DeviceRequest.wIndex == 0)
		single_transmit(0, 0);
	else
		stall_ep0();
}

/*
void control_handler(void)
{
	unsigned char type,req;
	type=ControlData.DeviceRequest.bmRequest&USB_REQUEST_TYPE_MASK;
	req=ControlData.DeviceRequest.bRequest&USB_REQUEST_MASK;
	if(type==USB_STANDARD_REQUEST)    (*StandardDeviceRequest[req])();
	else if(type==USB_VENDOR_REQUEST)    (*VendorDeviceRequest[req])();
	else stall_ep0();
}   */


//epphal
void dma_start(PIO_REQUEST pio)
{
}

void outportb(unsigned int Addr,unsigned char Data)
{
       asm volatile("st    X,%0" ::"r" (Data),"e" (Addr) );	
}

unsigned char inportb(unsigned int Addr)
{	
	unsigned char data;
	asm volatile("ld    %0,X" :"=r" (data):"e" (Addr) );
	return data;
}



//protodma


void get_firmware_version(void)
{
	unsigned char i;

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

void get_buffer_size(void)
{
	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(void)
{
//	memcpy((unsigned char *)&ioRequest + ControlData.DeviceRequest.wValue,
//		ControlData.dataBuffer,
//		ControlData.DeviceRequest.wLength);

	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) 
  VT102DispStr(1,  23, "Read Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.", COLOR_WHITE, COLOR_BLACK);		
//			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.wIndex == GET_FIRMWARE_VERSION &&
			ControlData.DeviceRequest.wValue == 0 &&
			ControlData.DeviceRequest.wLength == 1)
			get_firmware_version();
		else
		if(ControlData.DeviceRequest.wIndex == GET_BUFFER_SIZE &&
			ControlData.DeviceRequest.wValue == 0 &&
			ControlData.DeviceRequest.wLength == 4)
			get_buffer_size();
		else
			stall_ep0();

	}	// if read register
	else{
		if(bEPPflags.bits.verbose) {
  VT102DispStr(1,  23, "Read Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.", COLOR_WHITE, COLOR_BLACK);		
//			printf("Write Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.\n",
//				ControlData.DeviceRequest.wValue,
//				ControlData.DeviceRequest.wLength,
//				ControlData.DeviceRequest.wIndex);
  VT102DispStr(1,  23, "Data: ", COLOR_WHITE, COLOR_BLACK);		
//			printf("Data: ");
			for(i = 0; i < ControlData.DeviceRequest.wLength; i ++)
  VT102DispStr(1,  23, "0x%bx", COLOR_WHITE, COLOR_BLACK);		
//				printf("0x%bx, ", *((ControlData.dataBuffer)+i));
//			printf("\n");
		}

		if(ControlData.DeviceRequest.wIndex == SETUP_DMA_REQUEST &&
			ControlData.DeviceRequest.wValue == 0 &&
			ControlData.DeviceRequest.wLength == 6)
			setup_dma_request();
		else
			stall_ep0();
	}	// if write register
}



unsigned char D12_GetDMA(void)
{
	return bEPPflags.bits.dma_state;
}