Function usb_serial_flush

src/usb_serial.rs:230–276

This method will flush the current queue of data to the usb host. It is invoked automatically based on interrupts, but you can manually flush too if you'd like. It will short-cirucit if all the transfer queues are still active or if the USB host hasn't finished connecting. Returns how many bytes were written.

()

///
/// Returns how many bytes were written.
pub fn usb_serial_flush() -> u32 {
    // Verify we are in a good, configured state.
    if unsafe { CONFIGURED == false } {
        return 0;
    }

    // Prepare
    if unsafe { TX_BUFFER_TRANSIENT.size() } > 0 {
        let dtd = unsafe { &mut TX_DTD };

        if (dtd.status & 0x80) > 0 {
            return 0;
        }

        // Check for error condition
        if (dtd.status & 0xFF) > 0 {
            // This is actually kinda ok probably.
            // Some data may have been lost, idk, but
            // You can keep going and it'll magically
            // fix itself.

            // Returning zero on the other hand seems
            // to brick it because the error persists
            // until you prepare another queue.

            // return 0;
        }

        // Copy the data.
        let len = unsafe { TX_BUFFER_TRANSIENT.size() } as u32;
        let src_ptr = unsafe { TX_BUFFER_TRANSIENT.data.as_ptr() } as u32;
        let dst_ptr = unsafe { TX_BUFFER.as_ptr() } as u32;

        mem::copy(src_ptr, dst_ptr, len);

        unsafe {
            // Clear buffer
            TX_BUFFER_TRANSIENT.clear();
        }

        usb_prepare_transfer(dtd, dst_ptr, len, true);
        usb_transmit(CDC_TX_ENDPOINT as usize, dtd);
        return len;
    }

    return 0;
}

fn setup_cdc_descriptors() {
    let descriptors = usb_get_descriptors();