📄 subp.c
字号:
#include <sl811.h>
#include <des.h>
#include <reg51.h>
#include <varial.h>
//--------------------------------
// wait usb reset 5ms
//-------------------------------
void Delay(void)
{
BYTE i,u;
for(u=40;u>0;u--)
{
i=255;
while(i--);
}
}
//*****************************************************************************************
// BYTE Read from SL811H
// a = register address
// return = data in register
//*****************************************************************************************
BYTE SL811Read( BYTE a)
{
SL811H_ADDR = a;
return (SL811H_DATA);
}
//*****************************************************************************************
// BYTE Write to SL811H
// a = register address
// d = data to be written to this register address
//*****************************************************************************************
void SL811Write( BYTE a, BYTE d)
{
SL811H_ADDR = a;
SL811H_DATA = d;
}
//*****************************************************************************************
// Buffer Read from SL811H
// addr = buffer start address
// s = return buffer address where data are to be save/read
// c = buffer data length
//*****************************************************************************************
void SL811BufRead( BYTE addr, BYTE *s, BYTE c)
{
SL811H_ADDR = addr;
while (c--)
*s++ = SL811H_DATA;
}
//*****************************************************************************************
// Buffer Write to SL811H
// addr = buffer start address
// s = buffer address where data are to be written
// c = buffer data length
//*****************************************************************************************
void SL811BufWrite( BYTE addr, BYTE *s, BYTE c)
{// BYTE i;
SL811H_ADDR = addr;
while (c--)
SL811H_DATA = *s++;
// for(i=0;i<c;i++)
// SL811H_DATA = *(s+i);
}
//*****************************************************************************************
// Swap high and low BYTE
//*****************************************************************************************
WORD WordSwap(WORD input)
{
return(((input&0x00FF)<<8)|((input&0xFF00)>>8));
}
//*****************************************************************************************
// Audio Control Key Scanning Routine
//*****************************************************************************************
void audio_key_scan(void)
{
// Audio_Keys = (~P1) & AUDIO_KEYS; // Mute/Vol Up/Vol Down Keys
// if(Audio_Keys != Prev_Audio_Keys) // Detect for any changes
// {
key_temp=P1;
if((key_temp&0xff)!=0xff)
{ Delay();
Delay();
key_temp=P1;
if((key_temp&0xff)!=0xff)
{ Delay();
Delay();
if((~key_temp)>=0x10)
key2=~key_temp;
else
key1=~key_temp;
flag_ep1=1;
SL811Write(EP1A_Slave_Buf,key1); // send bitmap back to host
SL811Write(EP1A_Slave_Buf+1,key2);
// SL811BufWrite(EP1A_Slave_Buf,(BYTE*)key,0x31);
EP1A_IN_Arm(EP1A_Slave_Buf,2,ep1_toggle); // Arm Ep1 and toggle data
key1=key2=0;
}
}
else
EP1A_IN_Arm(0,0,ep1_toggle);
// SL811Write(EP1AControl,SEND_STALL); //send nak
//}
//Prev_Audio_Keys = Audio_Keys; // update previous key states
}
//*****************************************************************************************
// Internet Control Key Scanning Routine
//*****************************************************************************************
/*void internet_key_scan(void)
{
return;
}
*/
//*****************************************************************************************
// EP1 interrupt service routine
//*****************************************************************************************
void ep1_isr(void)
//int ep1_isr(void)
{
SL811Write(IntStatus,EP1_DONE); // clear EP1 interrupt
// if(SL811Read(EP1AStatus) & EP_ACK) // check for ACK bit set
ep1_toggle = (((SL811Read(EP1AControl)&DATAX)==0) ? 1:0);
// else // toggle DATA sequence
audio_key_scan();
// return;
}
//*****************************************************************************************
// EP1's IN Token Arming (using Set A)
//*****************************************************************************************
void EP1A_IN_Arm( BYTE buf_adr, BYTE len, BYTE seq)
{
SL811Write(EP1AAddress,buf_adr); // ep1 address buffer start adress
SL811Write(EP1AXferLen,len); // max length of transfer allowed
if(seq)
SL811Write(EP1AControl,DATA1_IN); // armed to transmit to host, DATA1
else
SL811Write(EP1AControl,DATA0_IN); // armed to transmit to host, DATA0
}
//*****************************************************************************************
// SOF interrupt service routine (act as 1ms timer)
//*****************************************************************************************
//int sof_isr(void)
/*int sof_isr(void)
{
SL811Write(IntStatus,SOF_DONE); // clear SOF interrupt
sof_cnt++; // track msec timing
if(sof_cnt==TIME_OUT) //5 reset counter on specify
{ // time out.
sof_cnt = 0;
timeout = 1; // set timeout flag
}
return;
}
*/
//*****************************************************************************************
// EP0 interrupt service routine
//*****************************************************************************************
//int ep0_isr(void)
void ep0_isr(void)
{
BYTE status, byte_rx, len_xfr;
BYTE req_type,data_seq;
SL811Write(IntStatus,EP0_DONE); // clear EP0 interrupt
status = SL811Read(EP0AStatus); // get packet status
byte_rx = SL811Read(EP0AXferLen) - SL811Read(EP0ACounter); // get no. of BYTEs received
// for OUT data from host
//----------------------------------------------------------------------------------------
// ACK received
//----------------------------------------------------------------------------------------
if(status & EP_ACK)
{
//----------------------------------------------------------------
// Set newly assigned USB address
//----------------------------------------------------------------
if(Slave_USBaddr)
{ // if new USB address was assigned,
SL811Write(USBAddress,Slave_USBaddr); // communicate all USB transaction
Slave_USBaddr = 0; // using this new address.
}
//================================================================
// SETUP's ACKed
//================================================================
//status = SL811Read(EP0AStatus);
if(status & EP_SETUP)
{
SL811BufRead(EP0A_Slave_Buf, ( BYTE*)&dReq, byte_rx); // capture SETUP data request
len_req = WordSwap(dReq.wLength); // len_req = actual requested length
in_buffer_idx = 0; // reset buffer locatio indexing
IN_NULL = FALSE; // these are for IN-NULL packet
IN_EXACT = FALSE; // transfer condition
req_type = (dReq.bmRequest&0x60)>>5; // decode for Std,Class,Vendor type
switch (req_type) // Parse bmRequest Type
{
//---------------------------------------------------------------------
// Standard USB Requests
//---------------------------------------------------------------------
case STD_REQUEST:
switch (dReq.bRequest) // Parse bRequest
{
case GET_DESCRIPTOR:
switch (( BYTE)dReq.wValue) // Parse wValue
{
case DEVICE:
SL811BufWrite(EP0A_Slave_Buf,( BYTE*)Dev_Descp,DEV_LEN); // load Device Descp
len_req = (len_req>=DEV_LEN) ? DEV_LEN:len_req; // get exact data length
break;
case CONFIGURATION:
SL811BufWrite(EP0A_Slave_Buf,( BYTE*)Cfg_Descp,CFG_LEN); // load Config Descp
len_req = (len_req>=CFG_LEN) ? CFG_LEN:len_req; // get exact data length
break;
case HID_DEV:
SL811BufWrite(EP0A_Slave_Buf,( BYTE*)Cfg_Descp+18,HID_LEN);// load HID Class Descp
len_req = (len_req>=HID_LEN) ? HID_LEN:len_req; // get exact data length
break;
case HID_REPORT:
SL811BufWrite(EP0A_Slave_Buf,( BYTE*)Rep_Descp,REP_LEN); // load Report Descp
len_req = (len_req>=REP_LEN) ? REP_LEN:len_req; // get exact data length
break;
case STRING:
switch(dReq.wValue>>8) // get string index
{
case 0x00: SL811BufWrite(EP0A_Slave_Buf,( BYTE*)LangString,LangString[0]);
len_req = (len_req>=LangString[0]) ? LangString[0]:len_req;
break;
case 0x01: SL811BufWrite(EP0A_Slave_Buf,( BYTE*)MfgString,MfgString[0]);
len_req = (len_req>=MfgString[0]) ? MfgString[0]:len_req;
break;
case 0x02: SL811BufWrite(EP0A_Slave_Buf,( BYTE*)ProdString,ProdString[0]);
len_req = (len_req>=ProdString[0]) ? ProdString[0]:len_req;
break;
}
break;
}
if (len_req == WordSwap(dReq.wLength)) // if requested length is equal to the
IN_EXACT = TRUE; // exact length of descriptor, set IN_EXACT
// is use during IN-NULL pkt trasnmission
len_xfr = (len_req>=EP0_LEN) ? EP0_LEN:( BYTE)len_req; // get current IN transfer length
EP0A_IN_Arm(EP0A_Slave_Buf,len_xfr,1); // Arm IN response, start with DATA1 seq
in_buffer_idx += len_xfr; // update to next muliple buffer location
len_req -= len_xfr; // update data length for current transfer
break;
case GET_CONFIG:
SL811Write(EP0A_Slave_Buf,Slave_ConfigVal); // load current configuration value
EP0A_IN_Arm(EP0A_Slave_Buf,1,1); // send 1 BYTE data back to host
len_req = 0;
break;
case GET_INTERFACE:
SL811Write(EP0A_Slave_Buf,Slave_IfcAlt[dReq.wIndex>>8]);// load current alternate setting
EP0A_IN_Arm(EP0A_Slave_Buf,1,1); // send 1 BYTE data back to host
len_req = 0;
break;
case GET_STATUS:
switch(dReq.bmRequest&0x03) // check for recipients
{
case RECIPIENT_DEV: // load current device status
SL811Write(EP0A_Slave_Buf,(Slave_RemoteWU<<1)|BUS_POWERED);
break;
case RECIPIENT_IFC:
SL811Write(EP0A_Slave_Buf,0); // first BYTE = 0
break;
case RECIPIENT_ENP:
if((dReq.wIndex>>8) & 0x80) // for IN direction endpoint
{
if(Slave_inEPstall & (0x01<<((dReq.wIndex>>8)&0x0F)))
SL811Write(EP0A_Slave_Buf,1); // first BYTE = 1 (IN endpoint stall)
else
SL811Write(EP0A_Slave_Buf,0); // first BYTE = 0 (IN endpoint not stall)
}
else // for OUT direction endpoint
{
if(Slave_outEPstall & (0x01<<((dReq.wIndex>>8)&0x0F)))
SL811Write(EP0A_Slave_Buf,1); // first BYTE = 1 (OUT endpoint stall)
else
SL811Write(EP0A_Slave_Buf,0); // first BYTE = 0 (OUT endpoint not stall)
}
break;
}
SL811Write(EP0A_Slave_Buf+1,0); // second BYTE = 0
EP0A_IN_Arm(EP0A_Slave_Buf,2,1); // send 2 BYTEs data back to host
len_req = 0; // reset request length to zero
break;
case SET_FEATURE:
case CLEAR_FEATURE:
switch(dReq.bmRequest&0x03) // check for recipients
{
case RECIPIENT_DEV:
if((dReq.wValue>>8) == 1) // feature selector = 1 (remote wakeup)
{
if(dReq.bRequest==SET_FEATURE) // set remote wake up status
Slave_RemoteWU = 1;
if(dReq.bRequest==CLEAR_FEATURE) // clear remote wake up status
Slave_RemoteWU = 0;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -