usb.c

D12 的一些 开发资料 对开发D12相当有用

union                                    //端点最后处理状态
{
 unsigned char Register;
 struct
 {
  unsigned char successful          :1;
  unsigned char error_code          :4;
  unsigned char setup_packet        :1;
  unsigned char data_1              :1;
  unsigned char prestatus_not_read  :1;
 }Status;
}Last_Status;


//*****************   延时x毫秒函数 ***********
void delay(unsigned int x)                
{
 unsigned int i;
 unsigned int j;
 for(i=0;i<x;i++)
 for(j=0;j<230;j++);
}
//********************************************


void write_usb_command(unsigned char usb_command)       //写USB命令
{
 USB_A0=USB_COMMAND_ADD;
 USB_DATA=usb_command;
 USB_WR=0;
 USB_WR=1;
 USB_DATA=0xFF;
}

void write_a_usb_data(unsigned char usb_data)        //写一字节USB数据
{
 USB_A0=USB_DATA_ADD;
 USB_DATA=usb_data;
 USB_WR=0;
 USB_WR=1;
 USB_DATA=0XFF;
}

unsigned char read_a_usb_data(void)                  //读一字节USB数据
{
 unsigned char temp;
 USB_A0=USB_DATA_ADD;
 USB_RD=0;
 temp=USB_DATA;
 USB_RD=1;
 return temp;
}


void read_interrupt_register(void)             //读USB中断寄存器
{
 write_usb_command(Read_Interrupt_Register);
 Interrupt_Register.Register[0]=read_a_usb_data();
 Interrupt_Register.Register[1]=read_a_usb_data();
}

void set_usb_addr(unsigned char addr)          //设置USB地址
{
 write_usb_command(Set_Address);
 write_a_usb_data(0x80|addr);
}

void set_endpoint_enable(void)                  //端点使能
{
 write_usb_command(Set_Endpoint_Enable);
 write_a_usb_data(0x01);
}

unsigned char select_endpoint(unsigned char endp)   //选择终端点
{
 write_usb_command(Select_EndPoint+endp);
 return read_a_usb_data();
}

unsigned char  read_last_status(unsigned char endp)   //读端点最后状态
{
 write_usb_command(Read_Last_Status+endp);
 return read_a_usb_data();
}

void set_endpoint_status(unsigned char endp,unsigned char status)  //设置端点状态
{
 write_usb_command(0x40+endp);
 write_a_usb_data(!status);
}

unsigned char read_endpoint_status(unsigned char endp)           //读端点状态
{
 write_usb_command(0x80+endp);
 return read_a_usb_data();
}

void clear_buffer(void)                        //清缓冲，在读取缓冲数据后调用
{
 write_usb_command(Clear_Buffer);
}

void validate_buffer(void)                    //缓冲区数据有效，在写缓冲后调用
{
 write_usb_command(Validate_Buffer);
}

void ack_setup(unsigned char endp)            //应答建立包
{
 select_endpoint(endp);
 write_usb_command(Ack_Setup);
}

void error(unsigned char number)             //出错处理
{
// unsigned char Error[]={"ERROR: "};
// prints(Error);
// printc(number);
 number=0;
}

unsigned char read_endpoint_buff(unsigned char endp,unsigned char len,unsigned char * buff)   //读终端点缓冲
{
 unsigned char i,j;
 read_last_status(endp);
 if(!(select_endpoint(endp))&0x01){error(0); return 0;}
 read_endpoint_status(endp);
 write_usb_command(Read_Buffer);
 read_a_usb_data();
 j=read_a_usb_data();
 if(j>len)
  j=len;
 for(i=0;i<j;i++)
  {
   USB_RD=0;
   *(buff+i)=USB_DATA;
   USB_RD=1;
  }
 clear_buffer();
 return j;
}

unsigned char write_endpoint_buff(unsigned char endp,unsigned char len,unsigned char * buff)    //写终端点缓冲
{
 unsigned char i;
 read_last_status(endp);
 select_endpoint(endp);
 write_usb_command(Write_Buffer);
 write_a_usb_data(0);
 write_a_usb_data(len);
 for(i=0;i<len;i++)
  {
   USB_DATA=*(buff+i);
   USB_WR=0;
   USB_WR=1;
  }
 USB_DATA=0XFF;
 validate_buffer();
 return len;
}

void disconnect_usb(void)
{
 write_usb_command(0xf3);
 write_a_usb_data(0x0e);
 write_a_usb_data(0x47);
 delay(100);
}

void connect_usb(void)                            //连接USB
{
 write_usb_command(0xf3);                         //初始化USBD12
 write_a_usb_data(0x1e);                          //连接USB
 write_a_usb_data(0x47);                          //设置频率
}

void init_usb(void)                              //初始化USB
{
 set_usb_addr(0);
 set_endpoint_enable();
}

void usb_bus_reset(void)                         //USB总线复位处理
{
// code unsigned char Usb_Bus_Reset[]={"USB BUS RESET"};
// prints(Usb_Bus_Reset);
 usb_flags.Register=0;
 set_endpoint_enable();
 SCSI.Status.Command=1;
 SCSI.Status.Data=0;
 csw.dCSWSignature=0x55534253;

}

void usb_bus_suspend(void)                       //USB总线挂起处理
{
// code unsigned char Usb_Bus_Suspend[]={"USB BUS SUSPEND"};
// prints(Usb_Bus_Suspend);
// send_to_comport(10);
}

void set_usb_address(void)                       //设置地址
{
 usb_flags.flags.set_addr=1;
 while(select_endpoint(1)&0x01);
 write_endpoint_buff(1,0,0);
 set_usb_addr(Control_Data.DeviceRequest.wValue);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}

void get_status(unsigned char receiver)           //获取状态响应
{
 unsigned char status[2];
 switch (receiver)
  {
   case 0:                        //获取设备状态
    status[0]=0x00;
    status[1]=0x00;
    break;
   case 1:                        //获取接口状态
    status[0]=0x00;
    status[0]=0x00;
    break;
   case 2:                        //获取端点状态
    status[0]=0x00;
    status[1]=0x00;
    break;
   }
  write_endpoint_buff(1,2,status);
  usb_flags.flags.usb_endp0_in=0;
}

void clear_feature(unsigned char receiver)    
{
 receiver=0;
 write_endpoint_buff(1,0,0);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}

void set_feature(unsigned char receiver)
{
 receiver=0;
 write_endpoint_buff(1,0,0);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}

void set_descriptor(void)
{
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}

void set_configuration(void)
{
 write_endpoint_buff(1,0,0);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}

void get_configuration(void)               //获取配置状态
{
 unsigned char value=0x01;
 write_endpoint_buff(1,1,&value);
 usb_flags.flags.usb_endp0_in=0;
}

void set_interface(void)                   //设置接口
{
 write_endpoint_buff(1,0,0);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}

void get_interface(void)                  //获取接口状态
{
 unsigned char value=0x01;
 write_endpoint_buff(1,1,&value);
 usb_flags.flags.usb_endp0_in=0;
}

void get_max_LUN(void)                   //获取磁盘最大逻辑单元号
{
 unsigned char max_LUN=MAX_LUN;          //只有一个逻辑单元
 write_endpoint_buff(1,1,&(max_LUN));
 usb_flags.flags.usb_endp0_in=0; 
}

void mass_storage_reset(void)            //USB大容量存储设备复位
{
 write_endpoint_buff(1,0,0);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
 SCSI.Status.Command=1;
 SCSI.Status.Data=0;
}


void get_descriptor(void)                    //获取描述符
{
    if(!usb_flags.flags.not_end)
     {
      switch(MSB(Control_Data.DeviceRequest.wValue))
	   {
        case DEVICE_DESCRIPTOR:
	         Control_Data.wCount=sizeof(DEVICE_DESCRIPTOR_STRUCT);
 	         Control_Data.pData=(unsigned char *)(&device_descriptor);
             break;
        case CONFIGURATION_DESCRIPTOR:
             Control_Data.wCount=SWAP(con_int_endp_descriptor.configuration_descriptor.wTotalLength);
			 Control_Data.pData=(unsigned char *)(&con_int_endp_descriptor);
             if(Control_Data.wLength<Control_Data.wCount)Control_Data.wCount=Control_Data.wLength;
             break;
		case STRING_DESCRIPTOR:
		     if(LSB(Control_Data.DeviceRequest.wValue)==0)
			  {
			   Control_Data.wCount=LANGUAGE_ID[0];
               Control_Data.pData=LANGUAGE_ID;
			  }
		     if(LSB(Control_Data.DeviceRequest.wValue)==2)
			  {
			   Control_Data.wCount=device_serial_number[0];
			   Control_Data.pData=device_serial_number;
			  }
			 break;
	   	}
      if(Control_Data.wLength<Control_Data.wCount)Control_Data.wCount=Control_Data.wLength;
	 }

    if(Control_Data.wCount>=MAX_CONTROL_DATA_SIZE)
     {
	  write_endpoint_buff(1,MAX_CONTROL_DATA_SIZE,Control_Data.pData);
	  Control_Data.pData+=MAX_CONTROL_DATA_SIZE;