chap_9.c

采用PDIUSBD12开发的USB总线与429总线数据转换的单片机固件程序

#include "D12ci.h"
#include "chap_9.h"

#include <reg51.h>

//#define EP0_PACKET_SIZE    16
//#define EP2_PACKET_SIZE    64
#define NUM_ENDPOINTS	   4

#define CONFIG_DESCRIPTOR_LENGTH    sizeof(USB_CONFIGURATION_DESCRIPTOR) \
									+ sizeof(USB_INTERFACE_DESCRIPTOR) \
									+ (NUM_ENDPOINTS * sizeof(USB_ENDPOINT_DESCRIPTOR))


//extern unsigned char idata EpBuf[];
extern EPPFLAGS bEPPflags;
extern CONTROL_XFER ControlData;
void stall_ep0(void);
void single_transmit(unsigned char * buf, unsigned char len);

void get_firmware_version(void);
void get_buffer_size(void);


//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 void (*VendorDeviceRequest[])(void) =
{
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,//read_write_register,
	reserved,
	reserved,
	reserved
};




/******************************************************************
                        协议控制子程序
      当主循环检测到bEPPflags.bits.setup_packet=1时，主循环就调用协
      议控制子程序来区分是usb标准请求，还是厂商请求，并根据请求类型
      跳转到相应的子程序,使用的是函数指针
******************************************************************/
void setup_handler()
{
    unsigned char type,req;//读取请求类型，保留bits5，bits6
    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();//无效请求，返回STALL
}


void init_unconfig(void)
{
	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 stall_ep0(void)
{
	D12_SetEndpointStatus(0, 1);
	D12_SetEndpointStatus(1, 1);
}

//设备描述符
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,
	1//**********************************************************************此处本来是25，现改为1
};

//配置描述符
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
};

//保留子程序
void reserved(void)
{
    stall_ep0();//返回
}

//获取状态
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 == 0x01)//USB_DEVICE_DESCRIPTOR_TYPE)
    {
		code_transmit((unsigned char code *)&DeviceDescr, 18);//sizeof(USB_DEVICE_DESCRIPTOR));
	}
    else if (bDescriptor ==0x02)// 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();
}

 /*
//获取固件版本号
void get_firmware_version()
{
	unsigned char i;

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

//获取端点2缓冲区大小
void get_buffer_size()
{
	unsigned char i[4];

	i[0] = EP2_PACKET_SIZE;
	i[1] = 0;
	i[2] = 0;
	i[3] = 0;
	single_transmit((unsigned char *)&i, 4);
}

//厂商请求处理
void read_write_register(void)
{
//	unsigned char i;

	if(ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK) {
		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(ControlData.DeviceRequest.wIndex == SETUP_DMA_REQUEST &&
			ControlData.DeviceRequest.wValue == 0 &&
			ControlData.DeviceRequest.wLength == 6)
			{
				if(ControlData.dataBuffer[5]==0x81)
					D12_WriteEndpoint(5, ControlData.dataBuffer[3], EpBuf);
				single_transmit(0, 0);
			}
		else
			stall_ep0();
	}	// if write register
}
 */