/* UART to USB com port init routine */
ErrorCode_t UCOM_init(USBD_HANDLE_T hUsb, USB_CORE_DESCS_T *pDesc, USBD_API_INIT_PARAM_T *pUsbParam)
{
USBD_CDC_INIT_PARAM_T cdc_param;
ErrorCode_t ret = LPC_OK;
uint32_t ep_indx;
USB_CDC_CTRL_T *pCDC;
/* Store USB stack handle for future use. */
g_uCOM.hUsb = hUsb;
/* Initi CDC params */
memset((void *) &cdc_param, 0, sizeof(USBD_CDC_INIT_PARAM_T));
cdc_param.mem_base = pUsbParam->mem_base;
cdc_param.mem_size = pUsbParam->mem_size;
cdc_param.cif_intf_desc = (uint8_t *) find_IntfDesc(pDesc->high_speed_desc, CDC_COMMUNICATION_INTERFACE_CLASS);
cdc_param.dif_intf_desc = (uint8_t *) find_IntfDesc(pDesc->high_speed_desc, CDC_DATA_INTERFACE_CLASS);
cdc_param.SetLineCode = UCOM_SetLineCode;
/* Init CDC interface */
ret = USBD_API->cdc->init(hUsb, &cdc_param, &g_uCOM.hCdc);
if (ret == LPC_OK) {
/* allocate transfer buffers */
g_uCOM.txBuf = (uint8_t *) cdc_param.mem_base;
cdc_param.mem_base += UCOM_BUF_SZ;
cdc_param.mem_size -= UCOM_BUF_SZ;
g_uCOM.rxBuf = (uint8_t *) cdc_param.mem_base;
cdc_param.mem_base += UCOM_BUF_SZ;
cdc_param.mem_size -= UCOM_BUF_SZ;
/* register endpoint interrupt handler */
ep_indx = (((USB_CDC_IN_EP & 0x0F) << 1) + 1);
ret = USBD_API->core->RegisterEpHandler(hUsb, ep_indx, UCOM_bulk_hdlr, &g_uCOM);
if (ret == LPC_OK) {
/* register endpoint interrupt handler */
ep_indx = ((USB_CDC_OUT_EP & 0x0F) << 1);
ret = USBD_API->core->RegisterEpHandler(hUsb, ep_indx, UCOM_bulk_hdlr, &g_uCOM);
/* Init UART port for bridging */
UCOM_UartInit();
/* Set the line coding values as per UART Settings */
pCDC = (USB_CDC_CTRL_T *) g_uCOM.hCdc;
pCDC->line_coding.dwDTERate = 115200;
pCDC->line_coding.bDataBits = 8;
}
/* update mem_base and size variables for cascading calls. */
pUsbParam->mem_base = cdc_param.mem_base;
pUsbParam->mem_size = cdc_param.mem_size;
}
return ret;
}
void usb_init(void)
{
static Bool bUsbInit = FALSE;
USBD_API_INIT_PARAM_T usb_param;
USB_CORE_DESCS_T desc;
ErrorCode_t ret = LPC_OK;
if(bUsbInit)
return;
usb_pin_clk_init();
/* Initialize call back structures */
memset((void *) &usb_param, 0, sizeof(USBD_API_INIT_PARAM_T));
usb_param.usb_reg_base = LPC_USB0_BASE;
usb_param.max_num_ep = 2;
usb_param.mem_base = USB_STACK_MEM_BASE;
usb_param.mem_size = USB_STACK_MEM_SIZE;
/* Set the USB descriptors */
desc.device_desc = (uint8_t *) &USB_DeviceDescriptor[0];
desc.string_desc = (uint8_t *) &USB_StringDescriptor[0];
/* Note, to pass USBCV test full-speed only devices should have both
descriptor arrays point to same location and device_qualifier set to 0.
*/
desc.high_speed_desc = (uint8_t *) &USB_FsConfigDescriptor[0];
desc.full_speed_desc = (uint8_t *) &USB_FsConfigDescriptor[0];
desc.device_qualifier = 0;
/* USB Initialization */
ret = USBD_API->hw->Init(&g_hUsb, &desc, &usb_param);
if (ret == LPC_OK) {
/* Init USB HID bridge interface */
ret = UCOM_init(g_hUsb, find_IntfDesc(desc.high_speed_desc, USB_DEVICE_CLASS_HUMAN_INTERFACE), &usb_param);
ret = dfu_init(g_hUsb, find_IntfDesc(desc.high_speed_desc, USB_DEVICE_CLASS_APP), &usb_param);
if (ret == LPC_OK) {
/* Make sure USB and IRQ priorities are same for this example */
NVIC_SetPriority(USB0_IRQn, 1);
/* Enable USB interrrupts */
NVIC_EnableIRQ(USB0_IRQn);
/* Now connect */
USBD_API->hw->Connect(g_hUsb, 1);
}
}
bUsbInit = TRUE;
}
/* Memory storage based MSC_Disk init routine */
ErrorCode_t mscDisk_init(USBD_HANDLE_T hUsb, USB_CORE_DESCS_T *pDesc, USBD_API_INIT_PARAM_T *pUsbParam)
{
USBD_MSC_INIT_PARAM_T msc_param;
ErrorCode_t ret = LPC_OK;
memset((void *) &msc_param, 0, sizeof(USBD_MSC_INIT_PARAM_T));
msc_param.mem_base = pUsbParam->mem_base;
msc_param.mem_size = pUsbParam->mem_size;
/* mass storage paramas */
msc_param.InquiryStr = (uint8_t *) g_InquiryStr;
msc_param.BlockCount = MSC_MEM_DISK_BLOCK_COUNT;
msc_param.BlockSize = MSC_MEM_DISK_BLOCK_SIZE;
msc_param.MemorySize = MSC_MEM_DISK_SIZE;
/* Install memory storage callback routines */
msc_param.MSC_Write = translate_wr;
msc_param.MSC_Read = translate_rd;
msc_param.MSC_Verify = translate_verify;
msc_param.MSC_GetWriteBuf = translate_GetWrBuf;
msc_param.intf_desc = (uint8_t *) find_IntfDesc(pDesc->full_speed_desc, USB_DEVICE_CLASS_STORAGE);
ret = USBD_API->msc->init(hUsb, &msc_param);
/* update memory variables */
pUsbParam->mem_base = msc_param.mem_base;
pUsbParam->mem_size = msc_param.mem_size;
return ret;
}
/* Virtual com port init routine */
ErrorCode_t vcom_init(USBD_HANDLE_T hUsb, USB_CORE_DESCS_T *pDesc, USBD_API_INIT_PARAM_T *pUsbParam)
{
USBD_CDC_INIT_PARAM_T cdc_param;
ErrorCode_t ret = LPC_OK;
uint32_t ep_indx;
g_vCOM.hUsb = hUsb;
memset((void *) &cdc_param, 0, sizeof(USBD_CDC_INIT_PARAM_T));
cdc_param.mem_base = pUsbParam->mem_base;
cdc_param.mem_size = pUsbParam->mem_size;
cdc_param.cif_intf_desc = (uint8_t *) find_IntfDesc(pDesc->high_speed_desc, CDC_COMMUNICATION_INTERFACE_CLASS);
cdc_param.dif_intf_desc = (uint8_t *) find_IntfDesc(pDesc->high_speed_desc, CDC_DATA_INTERFACE_CLASS);
cdc_param.SetLineCode = VCOM_SetLineCode;
ret = USBD_API->cdc->init(hUsb, &cdc_param, &g_vCOM.hCdc);
if (ret == LPC_OK) {
/* allocate transfer buffers */
g_vCOM.rx_buff = (uint8_t *) cdc_param.mem_base;
cdc_param.mem_base += VCOM_RX_BUF_SZ;
cdc_param.mem_size -= VCOM_RX_BUF_SZ;
/* register endpoint interrupt handler */
ep_indx = (((USB_CDC_IN_EP & 0x0F) << 1) + 1);
ret = USBD_API->core->RegisterEpHandler(hUsb, ep_indx, VCOM_bulk_in_hdlr, &g_vCOM);
if (ret == LPC_OK) {
/* register endpoint interrupt handler */
ep_indx = ((USB_CDC_OUT_EP & 0x0F) << 1);
ret = USBD_API->core->RegisterEpHandler(hUsb, ep_indx, VCOM_bulk_out_hdlr, &g_vCOM);
}
/* update mem_base and size variables for cascading calls. */
pUsbParam->mem_base = cdc_param.mem_base;
pUsbParam->mem_size = cdc_param.mem_size;
}
return ret;
}
ErrorCode_t hid_generic_init(USBD_HANDLE_T hUsb, USB_CORE_DESCS_T *pDesc, USBD_API_INIT_PARAM_T *pUsbParam) {
USB_INTERFACE_DESCRIPTOR *pIntfDesc = find_IntfDesc(pDesc->high_speed_desc, USB_DEVICE_CLASS_HUMAN_INTERFACE);
USBD_HID_INIT_PARAM_T hid_param;
USB_HID_REPORT_T reports_data[1];
ErrorCode_t ret = LPC_OK;
memset((void *) &hid_param, 0, sizeof(USBD_HID_INIT_PARAM_T));
/* HID paramas */
hid_param.max_reports = 1;
/* Init reports_data */
reports_data[0].len = HID_ReportDescSize;
reports_data[0].idle_time = 0;
reports_data[0].desc = (uint8_t *) &HID_ReportDescriptor[0];
if (pIntfDesc == 0) {
return ERR_FAILED;
}
hid_param.mem_base = pUsbParam->mem_base;
hid_param.mem_size = pUsbParam->mem_size;
hid_param.intf_desc = (uint8_t *) pIntfDesc;
/* user defined functions */
hid_param.HID_GetReport = HID_GetReport;
hid_param.HID_SetReport = HID_SetReport;
hid_param.HID_EpIn_Hdlr = HID_Ep_Hdlr;
hid_param.HID_EpOut_Hdlr = HID_Ep_Hdlr;
hid_param.report_data = reports_data;
ret = USBD_API->hid->init(hUsb, &hid_param);
/* allocate USB accessable memory space for report data */
loopback_report = (uint8_t *) hid_param.mem_base;
hid_param.mem_base += 4;
hid_param.mem_size += 4;
/* update memory variables */
pUsbParam->mem_base = hid_param.mem_base;
pUsbParam->mem_size = hid_param.mem_size;
puts("hid_generic_init: Initialization Done!");
assert(ret == 0);
return ret;
}
ErrorCode_t initCom(USBD_HANDLE_T hUsb, USB_CORE_DESCS_T *pDesc,USBD_API_INIT_PARAM_T *pUsbParam, UCOM_DATA_T *com, int o)
{
if(o>=3)
{
return specialCase(hUsb,pDesc , pUsbParam, com, o);
}
ErrorCode_t ret = LPC_OK;
USBD_CDC_INIT_PARAM_T cdc_param2;
com->hUsb = hUsb;
com->port=o;
/* Initi CDC params */
memset((void *) &cdc_param2, 0, sizeof(USBD_CDC_INIT_PARAM_T));
cdc_param2.mem_base = pUsbParam->mem_base;
cdc_param2.mem_size = pUsbParam->mem_size;
cdc_param2.cif_intf_desc = (uint8_t *) find_IntfDesc(pDesc->high_speed_desc, CDC_COMMUNICATION_INTERFACE_CLASS,o);
cdc_param2.dif_intf_desc = (uint8_t *) find_IntfDesc(pDesc->high_speed_desc, CDC_DATA_INTERFACE_CLASS,o);
UCOM_UartInit(o);
switch(o)
{
case 0:
cdc_param2.SetLineCode = UCOM_SetLineCode0;
case 1:
cdc_param2.SetLineCode = UCOM_SetLineCode1;
case 2:
cdc_param2.SetLineCode = UCOM_SetLineCode2;
break;
default:
break;
}
cdc_param2.CDC_BulkIN_Hdlr= com->pInHdlr;
cdc_param2.CDC_BulkOUT_Hdlr= com->pOutHdlr;
ret = USBD_API->cdc->init(hUsb, &cdc_param2, &com->hCdc);
if (ret == LPC_OK) {
/* allocate transfer buffers */
com->txBuf = (uint8_t *) cdc_param2.mem_base;
cdc_param2.mem_base += UCOM_BUF_SZ;
cdc_param2.mem_size -= UCOM_BUF_SZ;
com->rxBuf = (uint8_t *) cdc_param2.mem_base;
cdc_param2.mem_base += UCOM_BUF_SZ;
cdc_param2.mem_size -= UCOM_BUF_SZ;
/* Init UART port for bridging */
/* Set the line coding values as per UART Settings */
USB_CDC_CTRL_T * pCDC = (USB_CDC_CTRL_T *) com->hCdc;
pCDC->line_coding.dwDTERate = 115200;
pCDC->line_coding.bDataBits = 8;
uint32_t ep_indx = ((( com->inEndpoint & 0x0F) << 1) +1);
if (ret == LPC_OK) {
ret = USBD_API->core->RegisterEpHandler(hUsb, ep_indx, com->pInHdlr, com);
}
ep_indx = (( com->outEndpoint & 0x0F) << 1);
if (ret == LPC_OK) {
ret = USBD_API->core->RegisterEpHandler(hUsb, ep_indx, com->pOutHdlr, com);
}
USBD_API->hw->EnableEvent(hUsb,com->inEndpoint,USB_EVT_IN,1 );
USBD_API->hw->EnableEvent(hUsb,com->inEndpoint,USB_EVT_IN_NAK,1 );
USBD_API->hw->EnableEvent(hUsb,com->outEndpoint,USB_EVT_OUT,1 );
USBD_API->hw->EnableEvent(hUsb,com->outEndpoint,USB_EVT_OUT_NAK,1 );
USBD_API->hw->ResetEP(hUsb,com->inEndpoint);
USBD_API->hw->ResetEP(hUsb,com->outEndpoint);
USB_ENDPOINT_DESCRIPTOR d;
d.bLength=USB_ENDPOINT_DESC_SIZE;
d.bDescriptorType=USB_ENDPOINT_DESCRIPTOR_TYPE;
d.bEndpointAddress=com->inEndpoint;
d.bmAttributes=USB_ENDPOINT_TYPE_BULK;
d.bInterval=0;
d.wMaxPacketSize=64;
USBD_API->hw->ConfigEP(hUsb,&d);
d.bLength=USB_ENDPOINT_DESC_SIZE;
d.bDescriptorType=USB_ENDPOINT_DESCRIPTOR_TYPE;
d.bEndpointAddress=com->outEndpoint;
d.bmAttributes=USB_ENDPOINT_TYPE_BULK;
d.bInterval=0;
d.wMaxPacketSize=64;
USBD_API->hw->ConfigEP(hUsb,&d);
/* update mem_base and size variables for cascading calls. */
pUsbParam->mem_base = cdc_param2.mem_base;
pUsbParam->mem_size = cdc_param2.mem_size;
}
return ret;
}
