?? chap_9.c
字號:
/*
//*************************************************************************
//
// ZLGMCU
// www.zlgmcu.com
// File Name: chap_9.C
// Revision: 0.4(2002-07-08)
// Author: Liu Ying Bin
// Use library: USB51S.LIB
// Note: USB51S.LIB不帶DMA控制功能
//*************************************************************************
*/
#include <stdio.h>
#include <string.h>
#include <reg51.h> /* special function register declarations */
#include "d12ci.h"
#include "mainloop.h"
#include "isr.h"
#include "usb100.h"
#include "chap_9.h"
#define NUM_ENDPOINTS 4
#define CONFIG_DESCRIPTOR_LENGTH sizeof(USB_CONFIGURATION_DESCRIPTOR) \
+ sizeof(USB_INTERFACE_DESCRIPTOR) \
+ (NUM_ENDPOINTS * sizeof(USB_ENDPOINT_DESCRIPTOR))
extern CONTROL_XFER ControlData;
extern IO_REQUEST idata ioRequest;
extern EPPFLAGS bEPPflags;
extern code void (*VendorDeviceRequest[])(void);
//extern void help_devreq(unsigned char typ, unsigned char req);
/*
//*************************************************************************
// USB protocol function pointer arrays
//*************************************************************************
*/
//USB標準設備請求入口地址指針表
code 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
};
//設備描述符
code 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
};
//配置描述符
code USB_CONFIGURATION_DESCRIPTOR ConfigDescr =
{
sizeof(USB_CONFIGURATION_DESCRIPTOR),
USB_CONFIGURATION_DESCRIPTOR_TYPE,
SWAP(CONFIG_DESCRIPTOR_LENGTH),
1,
1,
0,
0x60,
0x1
};
//接口描述符
code 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
};
//端點描述符
code USB_ENDPOINT_DESCRIPTOR EP1_TXDescr =
{
sizeof(USB_ENDPOINT_DESCRIPTOR),
USB_ENDPOINT_DESCRIPTOR_TYPE,
0x81,
USB_ENDPOINT_TYPE_INTERRUPT,
SWAP(EP1_PACKET_SIZE),
10
};
code USB_ENDPOINT_DESCRIPTOR EP1_RXDescr =
{
sizeof(USB_ENDPOINT_DESCRIPTOR),
USB_ENDPOINT_DESCRIPTOR_TYPE,
0x1,
USB_ENDPOINT_TYPE_INTERRUPT,
SWAP(EP1_PACKET_SIZE),
10
};
code USB_ENDPOINT_DESCRIPTOR EP2_TXDescr =
{
sizeof(USB_ENDPOINT_DESCRIPTOR),
USB_ENDPOINT_DESCRIPTOR_TYPE,
0x82,
USB_ENDPOINT_TYPE_BULK,
SWAP(EP2_PACKET_SIZE),
10
};
code 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 code *)&DeviceDescr, sizeof(USB_DEVICE_DESCRIPTOR));
} else if (bDescriptor == USB_CONFIGURATION_DESCRIPTOR_TYPE) {
if (ControlData.DeviceRequest.wLength>CONFIG_DESCRIPTOR_LENGTH)
{ControlData.DeviceRequest.wLength=CONFIG_DESCRIPTOR_LENGTH;}
code_transmit((unsigned char code *)&ConfigDescr, ControlData.DeviceRequest.wLength);
//code_transmit((unsigned char code *)&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();
}
//Move by Liu Ying Bin
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)
{
if( len <= EP0_PACKET_SIZE) {
D12_WriteEndpoint(1, len, buf);
}
}
void code_transmit(unsigned char code * 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 control_handler()
{
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 if (type == USB_VENDOR_REQUEST)
(*VendorDeviceRequest[req])();
else
stall_ep0();
}
/*
void fn_usb_isr()
{
unsigned int i_st;
bEPPflags.bits.in_isr = 1;
i_st = D12_ReadInterruptRegister();
if(i_st != 0) {
if(i_st & D12_INT_BUSRESET) {
// bus_reset();
bEPPflags.bits.bus_reset = 1;
}
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)
ep2_txdone();
if(i_st & D12_INT_ENDP2OUT)
ep2_rxdone();
}
bEPPflags.bits.in_isr = 0;
}
*/
void stall_ep0(void)
{
D12_SetEndpointStatus(0, 1);
D12_SetEndpointStatus(1, 1);
}
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) ) {
D12_SetEndpointStatus(0, 1);
D12_SetEndpointStatus(1, 1);
bEPPflags.bits.control_state = USB_IDLE;
return;
}
ControlData.DeviceRequest.wValue = SWAP(ControlData.DeviceRequest.wValue);
ControlData.DeviceRequest.wIndex = SWAP(ControlData.DeviceRequest.wIndex);
ControlData.DeviceRequest.wLength = SWAP(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_SetEndpointStatus(0, 1);
D12_SetEndpointStatus(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)
{
single_transmit(0, 0);
return;
}
if( i >= EP0_PACKET_SIZE) {
D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData + ControlData.wCount);
ControlData.wCount += EP0_PACKET_SIZE;
bEPPflags.bits.control_state = USB_TRANSMIT;
}
else if( i != 0) {
D12_WriteEndpoint(1, i, ControlData.pData + ControlData.wCount);
ControlData.wCount += i;
bEPPflags.bits.control_state = USB_IDLE;
}
else if (i == 0){
D12_WriteEndpoint(1, 0, 0); // Send zero packet at the end ???
bEPPflags.bits.control_state = USB_IDLE;
}
}
void usbserve(void)
{
if (bEPPflags.bits.bus_reset) {
DISABLE;
bEPPflags.bits.bus_reset = 0;
ENABLE;
d12_busreset();
} // if bus reset
if (bEPPflags.bits.suspend) {
DISABLE;
bEPPflags.bits.suspend= 0;
ENABLE;
d12_suspend();
} // if suspend change
if (bEPPflags.bits.setup_packet){
DISABLE;
bEPPflags.bits.setup_packet = 0;
control_handler();
ENABLE;
} // if setup_packet
}
void GetVer(unsigned char * VerPoint)
{
unsigned char code Ver[]={"ZLGMCU USB51S V0.4"};
VerPoint = Ver;
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -