void cdc_set_line_coding_data(void) { // JTR handling an OUT token In the CDC stack this is the only function that handles an OUT data stage. unsigned long dwBaud, dwBaudrem; memcpy(&linecodeing, (const void *) EP0_Outbdp->BDADDR, sizeof (struct cdc_LineCodeing)); dwBaud = BAUDCLOCK_FREQ / linecodeing.dwDTERate; dwBaudrem = BAUDCLOCK_FREQ % linecodeing.dwDTERate; if (linecodeing.dwDTERate > (dwBaudrem << 1)) dwBaud--; UART_BAUD_setup(dwBaud); usb_unset_out_handler(0); // Unregister OUT handler; JTR serious bug fix in macro! usb_set_in_handler(0, cdc_set_line_coding_status); // JTR why bother? usb_ack_dat1(0); // JTR common addition for STD and CLASS ACK // JTR This part of the USB-CDC stack is worth highlighting // This is the only place that we have an OUT DATA packet on // EP0. At this point it has been completed. This stack unlike // the microchip stack does not have a common IN or OUT data // packet complete tail and therefore it is the responsibility // of each section to ensure that EP0 is set-up correctly for // the next setup packet. // Force EP0 OUT to the DAT0 state // after we have all our data packets. EP0_Outbdp->BDCNT = USB_EP0_BUFFER_SIZE; EP0_Outbdp->BDSTAT = UOWN | DTSEN; }
void cdc_set_line_coding_data(void) { // JTR handling an OUT token In the CDC stack this is the only function that handles an OUT data stage. memcpy(&linecodeing, (const void *) bdp->BDADDR, sizeof (struct cdc_LineCodeing)); usb_unset_out_handler(0); // Unregister OUT handler; JTR serious bug fix in macro! usb_set_in_handler(0, cdc_set_line_coding_status); // JTR why bother? usb_ack_dat1(rbdp, 0); // JTR common addition for STD and CLASS ACK // JTR This part of the USB-CDC stack is worth highlighting // This is the only place that we have an OUT DATA packet on // EP0. At this point it has been completed. This stack unlike // the microchip stack does not have a common IN or OUT data // packet complete tail and therefore it is the responsibility // of each section to ensure that EP0 is set-up correctly for // the next setup packet. // This next line inverts the DTS so that it is now ready for // a DAT0 packet. However it only works because we had one data // packet. For any amount of EVEN data packets it would not be // correct. // usb_ack_out(bdp); // JTR N/A Good for only odd number of data packets. // The correct thing to do is to force EP0 OUT to the DAT0 state // after we have all our data packets. bdp->BDCNT = USB_EP0_BUFFER_SIZE; bdp->BDSTAT = UOWN | DTSEN; }
void user_configured_init(void) { // JTR NEW FUNCTION // After the device is enumerated and configured then we set up non EP0 endpoints. // We only enable the endpoints we are using, not all of them. // Prior to this they are held in a disarmed state. // This function belongs to the current USB function and IS NOT generic. This is CLASS specific // and will vary from implementation to implementation. usb_unset_in_handler(1); usb_unset_in_handler(2); usb_unset_out_handler(2); USB_UEP1 = USB_EP_IN; USB_UEP2 = USB_EP_INOUT; /* Configure buffer descriptors */ #if USB_PP_BUF_MODE == 0 // JTR Setup CDC LINE_NOTICE EP (Interrupt IN) usb_bdt[USB_CALC_BD(1, USB_DIR_IN, USB_PP_EVEN)].BDCNT = 0; usb_bdt[USB_CALC_BD(1, USB_DIR_IN, USB_PP_EVEN)].BDADDR = cdc_acm_in_buffer; usb_bdt[USB_CALC_BD(1, USB_DIR_IN, USB_PP_EVEN)].BDSTAT = DTS + DTSEN; // Set DTS => First packet inverts, ie. is Data0 #else // TODO: Implement Ping-Pong buffering setup. #error "PP Mode not implemented yet" #endif usb_register_class_setup_handler(cdc_setup); cdc_trf_state = 0; CDC_Outbdp = &usb_bdt[USB_CALC_BD(2, USB_DIR_OUT, USB_PP_EVEN)]; CDC_Inbdp = &usb_bdt[USB_CALC_BD(2, USB_DIR_IN, USB_PP_EVEN)]; IsInBufferA = 0xFF; InPtr = cdc_In_bufferA; cdc_In_len = 0; CDC_Inbdp->BDADDR = &cdc_In_bufferA[0]; CDC_Inbdp->BDCNT = 0; CDC_Inbdp->BDSTAT = DTS + DTSEN; cdc_Out_len = 0; IsOutBufferA = 0xFF; OutPtr = cdc_Out_bufferA; CDC_Outbdp->BDCNT = CDC_BUFFER_SIZE; CDC_Outbdp->BDADDR = &cdc_Out_bufferA[0]; CDC_Outbdp->BDSTAT = UOWN + DTSEN; }
void user_configured_init(void) { // JTR NEW FUNCTION // After the device is enumerated and configured then we set up non EP0 endpoints. // We only enable the endpoints we are using, not all of them. // Prior to this they are held in a disarmed state. // This function belongs to the current USB function and IS NOT generic. This is CLASS specific // and will vary from implementation to implementation. usb_unset_in_handler(1); usb_unset_in_handler(2); usb_unset_out_handler(2); // JTR Macro has bug fix // JTR remove all USB_UEP[x] indexing from stack due to pointer bug (fixed?). // JTR experiment is the UEPx pointer system working? Lets try! // PASSED on PIC24 //USB_UEP[1] = USB_EP_IN; //USB_UEP[2] = USB_EP_INOUT; USB_UEP1 = USB_EP_IN; USB_UEP2 = USB_EP_INOUT; /* Configure buffer descriptors */ #if USB_PP_BUF_MODE == 0 // JTR Setup CDC LINE_NOTICE EP (Interrupt IN) usb_bdt[USB_CALC_BD(1, USB_DIR_IN, USB_PP_EVEN)].BDCNT = 0; usb_bdt[USB_CALC_BD(1, USB_DIR_IN, USB_PP_EVEN)].BDADDR = cdc_acm_in_buffer; usb_bdt[USB_CALC_BD(1, USB_DIR_IN, USB_PP_EVEN)].BDSTAT = DTS + DTSEN; // Set DTS => First packet inverts, ie. is Data0 usb_bdt[USB_CALC_BD(2, USB_DIR_OUT, USB_PP_EVEN)].BDCNT = CDC_BUFFER_SIZE; // JTR N/A endpoints[i].buffer_size; usb_bdt[USB_CALC_BD(2, USB_DIR_OUT, USB_PP_EVEN)].BDADDR = cdc_Out_buffer; usb_bdt[USB_CALC_BD(2, USB_DIR_OUT, USB_PP_EVEN)].BDSTAT = UOWN + DTSEN; usb_bdt[USB_CALC_BD(2, USB_DIR_IN, USB_PP_EVEN)].BDCNT = 0; usb_bdt[USB_CALC_BD(2, USB_DIR_IN, USB_PP_EVEN)].BDADDR = cdc_In_buffer; usb_bdt[USB_CALC_BD(2, USB_DIR_IN, USB_PP_EVEN)].BDSTAT = DTS + DTSEN; // Set DTS => First packet inverts, ie. is Data0 #else // TODO: Implement Ping-Pong buffering setup. #error "PP Mode not implemented yet" #endif usb_register_class_setup_handler(cdc_setup); Outbdp = &usb_bdt[USB_CALC_BD(2, USB_DIR_OUT, USB_PP_EVEN)]; Inbdp = &usb_bdt[USB_CALC_BD(2, USB_DIR_IN, USB_PP_EVEN)]; }
void usb_init(ROMPTR const BYTE *device_descriptor, ROMPTR const BYTE *config_descriptor, ROMPTR const BYTE *string_descriptor, int num_string_descriptors) { usb_device_descriptor = device_descriptor; usb_config_descriptor = config_descriptor; usb_string_descriptor = string_descriptor; usb_num_string_descriptors = num_string_descriptors; sof_handler = NULL; class_setup_handler = NULL; vendor_setup_handler = NULL; usb_unset_in_handler(0); usb_unset_out_handler(0); ClearUSBtoDefault(); ConfigureUsbHardware(); EnablePacketTransfer(); }
void usb_init(ROMPTR const unsigned char *device_descriptor, ROMPTR const unsigned char *config_descriptor, ROMPTR const unsigned char *string_descriptor, int num_string_descriptors) { int i; usb_device_descriptor = device_descriptor; usb_config_descriptor = config_descriptor; usb_string_descriptor = string_descriptor; usb_num_string_descriptors = num_string_descriptors; SetUsbAddress(0); // JTR added here. Probably not required though ResetPPbuffers(); DisableUsbInterrupts(); DisableAllUsbInterrupts(); ClearAllUsbErrorInterruptFlags(); ClearAllUsbInterruptFlags(); ConfigureUsbHardware(); sof_handler = NULL; class_setup_handler = NULL; vendor_setup_handler = NULL; for (i = 0; i < MAX_CHIP_EP; i++) { endpoints[i].out_handler = NULL; endpoints[i].in_handler = NULL; } // Register ep0 - no handlers usb_unset_in_handler(0); usb_unset_out_handler(0); // JTR All UEPx SPRs are hard coded. I cannot see much point of tables or indexing for these. // On the PIC16C765 such indexing was required for the STALL bit but now the STALL feature // is in the Buffer descriptor table not in the UEPx SPRs. // See changes to "USB_REQUEST_GET_STATUS" // USB_UEP[0] = endpoints[0].type; USB_UEP0 = USB_EP_CONTROL; /* Configure endpoints TODO: Only ep0 ? */ // JTR Right! code for other end points snipped...At this point we are only setting up EP0 #ifdef USB_SELF_POWERED usb_device_status = 0x0001; #else usb_device_status = 0x0000; #endif usb_device_state = 0x00; // JTR added flag byte for enumeration state usb_current_cfg = 0; // JTR formally usb_configured usb_addr_pending = 0x00; #if USB_PP_BUF_MODE == 0 usb_bdt[USB_CALC_BD(0, USB_DIR_OUT, USB_PP_EVEN)].BDCNT = USB_EP0_BUFFER_SIZE; // JTR endpoints[0].buffer_size; same thing done more obviously usb_bdt[USB_CALC_BD(0, USB_DIR_OUT, USB_PP_EVEN)].BDADDR = usb_ep0_out_buf; //endpoints[0].out_buffer; usb_bdt[USB_CALC_BD(0, USB_DIR_OUT, USB_PP_EVEN)].BDSTAT = UOWN + DTSEN; usb_bdt[USB_CALC_BD(0, USB_DIR_IN, USB_PP_EVEN)].BDCNT = 0; usb_bdt[USB_CALC_BD(0, USB_DIR_IN, USB_PP_EVEN)].BDADDR = usb_ep0_in_buf; //endpoints[0].in_buffer; usb_bdt[USB_CALC_BD(0, USB_DIR_IN, USB_PP_EVEN)].BDSTAT = DTS; // Set DTS => First packet inverts, ie. is Data0 #else // TODO: Implement Ping-Pong buffering setup. #error "PP Mode not implemented yet" #endif }