usbcore.c

针对飞利浦LPC214x的虚拟串口程序

/*----------------------------------------------------------------------------
*      U S B  -  K e r n e l
*----------------------------------------------------------------------------
*      Name:    usbcore.c
*      Purpose: USB Core Module file for Philips LPC214x Family 
*		Microprocessors
*      Version: V1.04
*----------------------------------------------------------------------------
*      This software is supplied "AS IS" without any warranties, express, 
*      implied or statutory, including but not limited to the implied 
*      warranties of fitness for purpose, satisfactory quality and 
*      noninfringement. Keil extends you a royalty-free right to reproduce and
*      distribute executable files created using this software for use on 
*      Philips LPC2xxx microcontroller devices only. Nothing else gives you the 
*      right to use this software. 
*
*      Copyright (c) 2005 Keil Software.
*		Modified by Philips Semiconductor
*---------------------------------------------------------------------------*/
#include "type.h"

#include "usb.h"
#include "usbcfg.h"
#include "usbhw.h"
#include "usbcore.h"
#include "usbdesc.h"
#include "vcomuser.h"


WORD  USB_DeviceStatus;
BYTE  USB_DeviceAddress;
BYTE  USB_Configuration;
DWORD USB_EndPointMask;
DWORD USB_EndPointHalt;
BYTE  USB_NumInterfaces;
BYTE  USB_AltSetting[USB_IF_NUM];

BYTE  EP0Buf[USB_MAX_PACKET0];

USB_EP_DATA EP0Data;

USB_SETUP_PACKET SetupPacket;


/*
*  Reset USB Core
*    Parameters:      None
*    Return Value:    None
*/

void USB_ResetCore (void) {
	
	USB_DeviceStatus  = USB_POWER;
	USB_DeviceAddress = 0;
	USB_Configuration = 0;
	USB_EndPointMask  = 0x00010001;
	USB_EndPointHalt  = 0x00000000;
}


/*
*  USB Request - Setup Stage
*    (global SetupPacket)
*    Parameters:      None
*    Return Value:    None
*/

void USB_SetupStage (void) {
	USB_ReadEP(0x00, (BYTE *)&SetupPacket);
}


/*
*  USB Request - Data In Stage
*    Parameters:      None (global EP0Data)
*    Return Value:    None
*/

void USB_DataInStage (void) {
	DWORD cnt;
	
	if (EP0Data.Count > USB_MAX_PACKET0) {
		cnt = USB_MAX_PACKET0;
	} else {
		cnt = EP0Data.Count;
	}
	cnt = USB_WriteEP(0x80, EP0Data.pData, cnt);
	EP0Data.pData += cnt;
	EP0Data.Count -= cnt;
}


/*
*  USB Request - Data Out Stage
*    Parameters:      None (global EP0Data)
*    Return Value:    None
*/

void USB_DataOutStage (void) {
	DWORD cnt;
	
	cnt = USB_ReadEP(0x00, EP0Data.pData);
	EP0Data.pData += cnt;
	EP0Data.Count -= cnt;
}


/*
*  USB Request - Status In Stage
*    Parameters:      None
*    Return Value:    None
*/

void USB_StatusInStage (void) {
	USB_WriteEP(0x80, NULL, 0);
}


/*
*  USB Request - Status Out Stage
*    Parameters:      None
*    Return Value:    None
*/

void USB_StatusOutStage (void) {
	USB_ReadEP(0x00, EP0Buf);
}


/*
*  Get Status USB Request
*    Parameters:      None (global SetupPacket)
*    Return Value:    TRUE - Success, FALSE - Error
*/

__inline BOOL USB_GetStatus (void) {
	DWORD n, m;
	
	switch (SetupPacket.bmRequestType.BM.Recipient) {
    case REQUEST_TO_DEVICE:
		EP0Data.pData = (BYTE *)&USB_DeviceStatus;
		USB_DataInStage();
		break;
    case REQUEST_TO_INTERFACE:
		if ((USB_Configuration != 0) && (SetupPacket.wIndex.WB.L < USB_NumInterfaces)) {
			*((WORD *)EP0Buf) = 0;
			EP0Data.pData = EP0Buf;
			USB_DataInStage();
		} else {
			return (FALSE);
		}
		break;
    case REQUEST_TO_ENDPOINT:
		n = SetupPacket.wIndex.WB.L & 0x8F;
		m = (n & 0x80) ? ((1 << 16) << n) : (1 << n);
		if (((USB_Configuration != 0) || ((n & 0x0F) == 0)) && (USB_EndPointMask & m)) {
			*((WORD *)EP0Buf) = (USB_EndPointHalt & m) ? 1 : 0;
			EP0Data.pData = EP0Buf;
			USB_DataInStage();
		} else {
			return (FALSE);
		}
		break;
    default:
		return (FALSE);
	}
	return (TRUE);
}


/*
*  Set/Clear Feature USB Request
*    Parameters:      sc:    0 - Clear, 1 - Set
*                            None (global SetupPacket)
*    Return Value:    TRUE - Success, FALSE - Error
*/

__inline BOOL USB_SetClrFeature (DWORD sc) {
	DWORD n, m;
	
	switch (SetupPacket.bmRequestType.BM.Recipient) {
    case REQUEST_TO_DEVICE:
		if (SetupPacket.wValue.W == USB_FEATURE_REMOTE_WAKEUP) {
			if (sc) {
				USB_WakeUpCfg(1);
				USB_DeviceStatus |=  USB_GETSTATUS_REMOTE_WAKEUP;
			} else {
				USB_WakeUpCfg(0);
				USB_DeviceStatus &= ~USB_GETSTATUS_REMOTE_WAKEUP;
			}
		} else {
			return (FALSE);
		}
		break;
    case REQUEST_TO_INTERFACE:
		return (FALSE);
    case REQUEST_TO_ENDPOINT:
		n = SetupPacket.wIndex.WB.L & 0x8F;
		m = (n & 0x80) ? ((1 << 16) << n) : (1 << n);
		if ((USB_Configuration != 0) && ((n & 0x0F) != 0) && (USB_EndPointMask & m)) {
			if (SetupPacket.wValue.W == USB_FEATURE_ENDPOINT_STALL) {
				if (sc) {
					USB_SetStallEP(n);
					USB_EndPointHalt |=  m;
				} else {
					USB_ClrStallEP(n);
					USB_EndPointHalt &= ~m;
				}
			} else {
				return (FALSE);
			}
		} else {
			return (FALSE);
		}
		break;
    default:
		return (FALSE);
	}
	return (TRUE);
}


/*
*  Get Descriptor USB Request
*    Parameters:      None (global SetupPacket)
*    Return Value:    TRUE - Success, FALSE - Error
*/

__inline BOOL USB_GetDescriptor (void) {
	BYTE  *pD;
	DWORD len, n;
	
	switch (SetupPacket.bmRequestType.BM.Recipient) {
    case REQUEST_TO_DEVICE:
		switch (SetupPacket.wValue.WB.H) {
        case USB_DEVICE_DESCRIPTOR_TYPE:
			EP0Data.pData = (BYTE *)USB_DeviceDescriptor;
			len = USB_DEVICE_DESC_SIZE;
			break;
        case USB_CONFIGURATION_DESCRIPTOR_TYPE:
			pD = (BYTE *)USB_ConfigDescriptor;
			for (n = 0; n != SetupPacket.wValue.WB.L; n++) {
				if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bLength != 0) {
					pD += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
				}
			}
			if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bLength == 0) {
				return (FALSE);
			}
			EP0Data.pData = pD;
			len = ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
			break;
        case USB_STRING_DESCRIPTOR_TYPE:
			EP0Data.pData = (BYTE *)USB_StringDescriptor + SetupPacket.wValue.WB.L;
			len = ((USB_STRING_DESCRIPTOR *)EP0Data.pData)->bLength;
			break;
        default:
			return (FALSE);
		}
		break;
		case REQUEST_TO_INTERFACE:
			switch (SetupPacket.wValue.WB.H) {
			default:
				return (FALSE);
			}
			break;
			default:
				return (FALSE);
	}
	
	if (EP0Data.Count > len) {
		EP0Data.Count = len;
	}
	USB_DataInStage();
	
	return (TRUE);
}


/*
*  Set Configuration USB Request
*    Parameters:      None (global SetupPacket)
*    Return Value:    TRUE - Success, FALSE - Error
*/

__inline BOOL USB_SetConfiguration (void) {
	USB_COMMON_DESCRIPTOR *pD;
	DWORD                  alt, n, m;
	
	if (SetupPacket.wValue.WB.L) {
		pD = (USB_COMMON_DESCRIPTOR *)USB_ConfigDescriptor;
		while (pD->bLength) {
			switch (pD->bDescriptorType) {
			case USB_CONFIGURATION_DESCRIPTOR_TYPE:
				if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bConfigurationValue == SetupPacket.wValue.WB.L) {
					USB_Configuration = SetupPacket.wValue.WB.L;
					USB_NumInterfaces = ((USB_CONFIGURATION_DESCRIPTOR *)pD)->bNumInterfaces;
					for (n = 0; n < USB_IF_NUM; n++) {
						USB_AltSetting[n] = 0;
					}
					for (n = 1; n < 16; n++) {
						if (USB_EndPointMask & (1 << n)) {
							USB_DisableEP(n);
						}
						if (USB_EndPointMask & ((1 << 16) << n)) {
							USB_DisableEP(n | 0x80);
						}
					}
					USB_EndPointMask = 0x00010001;
					USB_EndPointHalt = 0x00000000;
					USB_Configure(TRUE);
					if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bmAttributes & USB_CONFIG_SELF_POWERED) {