usb.c

avr与PC机之间的通信

	} else
		stall_ep0();
}

void set_address(void)
{
	D12_SetAddressEnable((unsigned char)(ControlData.DeviceRequest.wValue &
		DEVICE_ADDRESS_MASK), 1);
	single_transmit(0, 0);
}

unsigned short D12_ReadChipID(void)
{
	unsigned short i,j;
	if(bEPPflags.bits.in_isr == 0)
		DISABLE;
	outportb(D12_COMMAND, 0xFD);
	i=inportb(D12_DATA);
	j=inportb(D12_DATA);
	i += (j<<8);
	if(bEPPflags.bits.in_isr == 0)
		ENABLE;
	return i;
}

void code_transmit(unsigned char *pRomData, unsigned short len)
{
	ControlData.wCount = 0;
	if(ControlData.wLength > len)
		ControlData.wLength = len;

	ControlData.pData = pRomData;
	if( ControlData.wLength >= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData);
		ControlData.wCount += EP0_PACKET_SIZE;

		DISABLE;
		bEPPflags.bits.control_state = USB_TRANSMIT;
		ENABLE;
	}
	else {
		D12_WriteEndpoint(1, ControlData.wLength, pRomData);
		ControlData.wCount += ControlData.wLength;
		DISABLE;
		bEPPflags.bits.control_state = USB_IDLE;
		ENABLE;
	}
}


void get_descriptor(void)
{
	unsigned char bDescriptor = MSB(ControlData.DeviceRequest.wValue);
//	put_c('g');
	if (bDescriptor == USB_DEVICE_DESCRIPTOR_TYPE) 
	{
//		put_c('d');
		code_transmit((unsigned char *)&DeviceDescr, sizeof(USB_DEVICE_DESCRIPTOR));
	} 
	else if (bDescriptor == USB_CONFIGURATION_DESCRIPTOR_TYPE) 
	{
//		put_c('c');
		code_transmit((unsigned char *)&TRANFER_DESC, 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 (*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
};



void control_handler(void)
{
	unsigned char type, req;

	type = ControlData.DeviceRequest.bmRequestType & USB_REQUEST_TYPE_MASK;
	req = ControlData.DeviceRequest.bRequest & USB_REQUEST_MASK;
	if (type == USB_STANDARD_REQUEST)
		(*StandardDeviceRequest[req])();
	else
		stall_ep0();
}

void disconnect_USB(void)
{
	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK, D12_SETTOONE | D12_CLOCK_12M);
}

void connect_USB(void)
{
	D12_SetDMA(D12_ENDP4INTENABLE | D12_ENDP5INTENABLE);
	D12_SetMode(D12_NOLAZYCLOCK|D12_SOFTCONNECT, D12_SETTOONE | D12_CLOCK_12M);
}

void reconnect_USB(void)
{
	disconnect_USB();
	connect_USB();
}
//this part from isr.c


void bus_reset(void)
{
}

void ep0_rxdone(void)
{
	unsigned char ep_last, i;

	ep_last = D12_ReadLastTransactionStatus(0); // Clear interrupt flag

	if (ep_last & D12_SETUPPACKET) {

		ControlData.wLength = 0;
		ControlData.wCount = 0;

		if( D12_ReadEndpoint(0, sizeof(ControlData.DeviceRequest),
			(unsigned char *)(&(ControlData.DeviceRequest))) != sizeof(DEVICE_REQUEST) ) {
			//setup包出错,返回
			D12_SetEndpointStatusIsr(0, 1);
			D12_SetEndpointStatusIsr(1, 1);
			bEPPflags.bits.control_state = USB_IDLE;
			
			return;
		}

		ControlData.DeviceRequest.wValue = ControlData.DeviceRequest.wValue;
		ControlData.DeviceRequest.wIndex = ControlData.DeviceRequest.wIndex;
		ControlData.DeviceRequest.wLength = ControlData.DeviceRequest.wLength;

		// Acknowledge setup here to unlock in/out endp
		D12_AcknowledgeEndpoint(0);
		D12_AcknowledgeEndpoint(1);

		ControlData.wLength = ControlData.DeviceRequest.wLength;
		ControlData.wCount = 0;

		if (ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK) {
			bEPPflags.bits.setup_packet = 1;
			bEPPflags.bits.control_state = USB_TRANSMIT;		/* get command */
		}
		else {
			if (ControlData.DeviceRequest.wLength == 0) {
				bEPPflags.bits.setup_packet = 1;
				bEPPflags.bits.control_state = USB_IDLE;		/* set command */
			}
			else {
				if(ControlData.DeviceRequest.wLength > MAX_CONTROLDATA_SIZE) {
					bEPPflags.bits.control_state = USB_IDLE;
					D12_SetEndpointStatusIsr(0, 1);
					D12_SetEndpointStatusIsr(1, 1);
				}
				else {
					bEPPflags.bits.control_state = USB_RECEIVE;	/* set command with OUT token */
				}
			} // set command with data
		} // else set command
	} // if setup packet

	else if (bEPPflags.bits.control_state == USB_RECEIVE) {
		i =	D12_ReadEndpoint(0, EP0_PACKET_SIZE,
			ControlData.dataBuffer + ControlData.wCount);

		ControlData.wCount += i;
		if( i != EP0_PACKET_SIZE || ControlData.wCount >= ControlData.wLength) {
			bEPPflags.bits.setup_packet = 1;
			bEPPflags.bits.control_state = USB_IDLE;
		}
	}

	else {
		bEPPflags.bits.control_state = USB_IDLE;
	}
}

void ep0_txdone(void)
{
	short i = ControlData.wLength - ControlData.wCount;

	D12_ReadLastTransactionStatus(1); // Clear interrupt flag

	if (bEPPflags.bits.control_state != USB_TRANSMIT) 
		return;

	if( i >= EP0_PACKET_SIZE) {
		D12_WriteEndpointIsr(1, EP0_PACKET_SIZE, ControlData.pData + ControlData.wCount);
		ControlData.wCount += EP0_PACKET_SIZE;

		bEPPflags.bits.control_state = USB_TRANSMIT;
	}
	else if( i != 0) {
		D12_WriteEndpointIsr(1, i, ControlData.pData + ControlData.wCount);
		ControlData.wCount += i;

		bEPPflags.bits.control_state = USB_IDLE;
	}
	else if (i == 0){
		D12_WriteEndpointIsr(1, 0, 0); // Send zero packet at the end ???

		bEPPflags.bits.control_state = USB_IDLE;
	}
}

void dma_eot(void)
{

}

void ep1_txdone(void)
{
	D12_ReadLastTransactionStatus(3); /* Clear interrupt flag */
}

void ep1_rxdone(void)
{
	unsigned char len;

	D12_ReadLastTransactionStatus(2); /* Clear interrupt flag */

	len = D12_ReadEndpoint(2, sizeof(GenEpBuf), GenEpBuf);

	if(len != 0)
	{
		bEPPflags.bits.ep1_rxdone = 1;

	}
}

void main_txdone(void)
{
	D12_ReadLastTransactionStatus(5);
}

void main_rxdone(void)
{
	unsigned char len;
	D12_ReadLastTransactionStatus(4);
	len = D12_ReadEndpoint(4, sizeof(EpBuf),EpBuf);

	if(len != 0)
	{
		bEPPflags.bits.main_rxdone = 1;
	}
}

void fn_usb_isr(void)
{
	unsigned int i_st;
//	unsigned char test;

	bEPPflags.bits.in_isr = 1;

	i_st = D12_ReadInterruptRegister();
//    test=(unsigned char)i_st;
//	put_c(test);
	if(i_st != 0) {
		if(i_st & D12_INT_BUSRESET) 
		{
			bus_reset();
			bEPPflags.bits.bus_reset = 1;
		}
		else
		{
			if(i_st & D12_INT_EOT)
				dma_eot();
			if(i_st & D12_INT_SUSPENDCHANGE)
				bEPPflags.bits.suspend = 1;
	
			if(i_st & D12_INT_ENDP0IN)
				ep0_txdone();
			if(i_st & D12_INT_ENDP0OUT)
				ep0_rxdone();
			if(i_st & D12_INT_ENDP1IN)
				ep1_txdone();
			if(i_st & D12_INT_ENDP1OUT)
				ep1_rxdone();
			if(i_st & D12_INT_ENDP2IN)
				main_txdone();
			if(i_st & D12_INT_ENDP2OUT)
				main_rxdone();
		}
	}

	bEPPflags.bits.in_isr = 0;
}

void Control(void)//具体操作
{
	PORTC=GenEpBuf[0];
}

/*void uart_init(void)
{
 	 UCSRC = (1<<URSEL) | 0x06;
	 UBRRL=(F_CPU/BAUD/16-1)%256;
	 UBRRH=(F_CPU/BAUD/16-1)/256;
	 UCSRA=0X00;
	 UCSRB = (1<<RXCIE)|(1<<RXEN)|(1<<TXEN);
}*/


SIGNAL(SIG_INTERRUPT0)//外中断0
{
//	put_c('i');
	DISABLE;
	fn_usb_isr();
//	put_c('f');
	ENABLE;	
}

//this part for main
//this part from mainloop.c
//断开USB
void init_port(void)
{
	DDRB=0xFF;
	Set_Bit(PORTB,D12_WR);//WR disable
	Set_Bit(PORTB,D12_RD);//RD disable
	Clr_Bit(PORTB,D12_CS);//cs enable
	Clr_Bit(PORTB,D12_ALE);
	DDRD=0xFF;
	PORTD|=(1<<PD2);
	DDRD&=~(1<<PD2);
	DDRD&=~(1<<PD0);
	DDRD|=(1<<PD1);
	PORTC=0xFF;
	DDRC=0xFF;
	DDRA=0xFF;
	MCUCR=0xC0;
	GICR|=(1<<INT0);
	GenEpBuf[0]=0xFF;
}

int main(void)
{
//	unsigned int id;
//	unsigned char low;
//  unsigned char high;
	delay1();
	delay1();
	delay1();
	delay1();
	DISABLE;
	init_port();
//	uart_init();
//	put_c('b');
//	id=D12_ReadChipID();
//	low=(unsigned char)id;
//	high=id>>8;
//	put_c(low);
//	put_c(high);
	reconnect_USB();
	ENABLE;
	while(1)
	{	
		if (bEPPflags.bits.bus_reset) 
		{
//			put_c(0xFF);
			DISABLE;
			bEPPflags.bits.bus_reset = 0;
			ENABLE;
		} 
		if (bEPPflags.bits.setup_packet)
		{
			DISABLE;
			bEPPflags.bits.setup_packet = 0;
			ENABLE;
			control_handler();
		} // if setup_packet
    	if(bEPPflags.bits.configuration)				
			Control();
	} 
}