From 974e8899e0d53f7bc386886e65b8c94ac3c6d6fb Mon Sep 17 00:00:00 2001 From: George Beckstein Date: Thu, 14 Mar 2019 22:23:19 -0400 Subject: [PATCH] Autoformatted with astyle --- .../TARGET_MCU_NRF52840/USBPhyHw.h | 18 +- .../TARGET_MCU_NRF52840/USBPhy_Nordic.cpp | 826 +++++++++--------- 2 files changed, 443 insertions(+), 401 deletions(-) diff --git a/usb/device/targets/TARGET_NORDIC/TARGET_MCU_NRF52840/USBPhyHw.h b/usb/device/targets/TARGET_NORDIC/TARGET_MCU_NRF52840/USBPhyHw.h index 3cf7ebf89b..99e0b19814 100644 --- a/usb/device/targets/TARGET_NORDIC/TARGET_MCU_NRF52840/USBPhyHw.h +++ b/usb/device/targets/TARGET_NORDIC/TARGET_MCU_NRF52840/USBPhyHw.h @@ -21,8 +21,8 @@ #include "USBPhy.h" extern "C" { - #include "nrf_drv_usbd.h" - #include "nrfx_power.h" +#include "nrf_drv_usbd.h" +#include "nrfx_power.h" } class USBPhyHw : public USBPhy { @@ -41,7 +41,7 @@ public: virtual void sof_disable(); virtual void set_address(uint8_t address); virtual void remote_wakeup(); - virtual const usb_ep_table_t* endpoint_table(); + virtual const usb_ep_table_t *endpoint_table(); virtual uint32_t ep0_set_max_packet(uint32_t max_packet); virtual void ep0_setup_read_result(uint8_t *buffer, uint32_t size); @@ -62,7 +62,7 @@ public: virtual void process(); - static void _usb_event_handler(nrf_drv_usbd_evt_t const * const p_event); + static void _usb_event_handler(nrf_drv_usbd_evt_t const *const p_event); static void _usb_power_event_handler(nrfx_power_usb_evt_t event); static void _usb_virtual_status_event_handler(void); @@ -73,10 +73,10 @@ private: bool connect_enabled; typedef enum usb_hw_event_type_t { - USB_HW_EVENT_NONE = 0, - USB_HW_EVENT_USBD = 1, - USB_HW_EVENT_POWER = 2, - USB_HW_EVENT_VIRTUAL_STATUS = 3 + USB_HW_EVENT_NONE = 0, + USB_HW_EVENT_USBD = 1, + USB_HW_EVENT_POWER = 2, + USB_HW_EVENT_VIRTUAL_STATUS = 3 } usb_hw_event_type_t; // Event type to process @@ -95,7 +95,7 @@ private: nrf_drv_usbd_transfer_t transfer_buf[18]; // Returns the appropriate transfer structure buffer for the given endpoint - nrf_drv_usbd_transfer_t* get_transfer_buffer(usb_ep_t endpoint); + nrf_drv_usbd_transfer_t *get_transfer_buffer(usb_ep_t endpoint); // Returns the corresponding enumeration given an mbed endpoint number static nrf_drv_usbd_ep_t get_nordic_endpoint(usb_ep_t endpoint); diff --git a/usb/device/targets/TARGET_NORDIC/TARGET_MCU_NRF52840/USBPhy_Nordic.cpp b/usb/device/targets/TARGET_NORDIC/TARGET_MCU_NRF52840/USBPhy_Nordic.cpp index 8a022674df..4771087bf2 100644 --- a/usb/device/targets/TARGET_NORDIC/TARGET_MCU_NRF52840/USBPhy_Nordic.cpp +++ b/usb/device/targets/TARGET_NORDIC/TARGET_MCU_NRF52840/USBPhy_Nordic.cpp @@ -24,8 +24,8 @@ #define MAX_PACKET_ISO NRF_DRV_USBD_ISOSIZE #define ENDPOINT_NON_ISO (USB_EP_ATTR_ALLOW_BULK | USB_EP_ATTR_ALLOW_INT) -#define IS_IN_EP(ep) (ep & 0x80) // Checks if the given endpoint is an IN endpoint (MSB set) -#define IS_OUT_EP(ep) (ep & ~0x80) // Checks if the given endpoint is an OUT endpoint (MSB clear) +#define IS_IN_EP(ep) (ep & 0x80) // Checks if the given endpoint is an IN endpoint (MSB set) +#define IS_OUT_EP(ep) (ep & ~0x80) // Checks if the given endpoint is an OUT endpoint (MSB clear) // If this bit is set in setup.bmRequestType, the setup transfer // is DEVICE->HOST (IN transfer) @@ -45,549 +45,591 @@ static USBPhyHw *instance = 0; static volatile bool virtual_status_xfer_event; -static void usbd_event_handler(nrf_drv_usbd_evt_t const * const p_event); +static void usbd_event_handler(nrf_drv_usbd_evt_t const *const p_event); static void power_usb_event_handler(nrfx_power_usb_evt_t event); -USBPhy *get_usb_phy() { - static USBPhyHw usbphy; - return &usbphy; +USBPhy *get_usb_phy() +{ + static USBPhyHw usbphy; + return &usbphy; } USBPhyHw::USBPhyHw() : - events(NULL), sof_enabled(false), connect_enabled(false), - usb_event_type(USB_HW_EVENT_NONE), - usb_power_event(NRFX_POWER_USB_EVT_REMOVED) { + events(NULL), sof_enabled(false), connect_enabled(false), + usb_event_type(USB_HW_EVENT_NONE), + usb_power_event(NRFX_POWER_USB_EVT_REMOVED) +{ } -USBPhyHw::~USBPhyHw() { +USBPhyHw::~USBPhyHw() +{ } -void USBPhyHw::init(USBPhyEvents *events) { +void USBPhyHw::init(USBPhyEvents *events) +{ - this->events = events; + this->events = events; - ret_code_t ret; + ret_code_t ret; - // Initialize power module to track USB Power events - ret = nrfx_power_init(NULL); - MBED_ASSERT(ret == NRF_SUCCESS); + // Initialize power module to track USB Power events + ret = nrfx_power_init(NULL); + MBED_ASSERT(ret == NRF_SUCCESS); - // Register callback for USB Power events - static const nrfx_power_usbevt_config_t config = { .handler = - power_usb_event_handler }; - nrfx_power_usbevt_init(&config); + // Register callback for USB Power events + static const nrfx_power_usbevt_config_t config = { + .handler = power_usb_event_handler + }; - // Initialize USB Device driver - ret = nrf_drv_usbd_init(usbd_event_handler); - MBED_ASSERT(ret == NRF_SUCCESS); + nrfx_power_usbevt_init(&config); - /* Configure selected size of the packed on EP0 */ - nrf_drv_usbd_ep_max_packet_size_set(NRF_DRV_USBD_EPOUT0, MAX_PACKET_SIZE_SETUP); - nrf_drv_usbd_ep_max_packet_size_set(NRF_DRV_USBD_EPIN0, MAX_PACKET_SIZE_SETUP); + // Initialize USB Device driver + ret = nrf_drv_usbd_init(usbd_event_handler); + MBED_ASSERT(ret == NRF_SUCCESS); - // Store a reference to this instance - instance = this; + /* Configure selected size of the packed on EP0 */ + nrf_drv_usbd_ep_max_packet_size_set(NRF_DRV_USBD_EPOUT0, MAX_PACKET_SIZE_SETUP); + nrf_drv_usbd_ep_max_packet_size_set(NRF_DRV_USBD_EPIN0, MAX_PACKET_SIZE_SETUP); - virtual_status_xfer_event = false; + // Store a reference to this instance + instance = this; - /* - * Configure ISOIN endpoint to respond with ZLP when - * no data is ready to be sent - */ - NRF_USBD->ISOINCONFIG |= 0x01; // set RESPONSE to 1 (respond with ZLP) + virtual_status_xfer_event = false; - // Set up the IRQ handler - NVIC_SetVector(USBD_IRQn, (uint32_t)USBD_HAL_IRQHandler); + /* + * Configure ISOIN endpoint to respond with ZLP when + * no data is ready to be sent + */ + NRF_USBD->ISOINCONFIG |= 0x01; // set RESPONSE to 1 (respond with ZLP) - // Enable the power events - nrfx_power_usbevt_enable(); + // Set up the IRQ handler + NVIC_SetVector(USBD_IRQn, (uint32_t)USBD_HAL_IRQHandler); + + // Enable the power events + nrfx_power_usbevt_enable(); } -void USBPhyHw::deinit() { - // Disconnect and disable interrupt - disconnect(); - // Disable the USB Device driver - ret_code_t ret = nrf_drv_usbd_uninit(); - MBED_ASSERT(ret == NRF_SUCCESS); - //NVIC_DisableIRQ(USBD_IRQn); // This is handled by the Nordic driver +void USBPhyHw::deinit() +{ + // Disconnect and disable interrupt + disconnect(); - // Disable the power peripheral driver - nrfx_power_uninit(); + // Disable the USB Device driver + ret_code_t ret = nrf_drv_usbd_uninit(); + MBED_ASSERT(ret == NRF_SUCCESS); - // Clear the instance pointer - instance = 0; + // Disable the power peripheral driver + nrfx_power_uninit(); + + // Clear the instance pointer + instance = 0; } -bool USBPhyHw::powered() { - if (nrfx_power_usbstatus_get() == NRFX_POWER_USB_STATE_CONNECTED - || nrfx_power_usbstatus_get() == NRFX_POWER_USB_STATE_READY) - return true; - else - return false; +bool USBPhyHw::powered() +{ + if (nrfx_power_usbstatus_get() == NRFX_POWER_USB_STATE_CONNECTED + || nrfx_power_usbstatus_get() == NRFX_POWER_USB_STATE_READY) { + return true; + } else { + return false; + } } -void USBPhyHw::connect() { +void USBPhyHw::connect() +{ - // To save power, we only enable the USBD peripheral - // when there's actually VBUS detected + // To save power, we only enable the USBD peripheral + // when there's actually VBUS detected - // So flag that the USB stack is ready to connect - this->connect_enabled = true; + // So flag that the USB stack is ready to connect + this->connect_enabled = true; - // If VBUS is already available, enable immediately - if(nrfx_power_usbstatus_get() == NRFX_POWER_USB_STATE_CONNECTED) - { - // Enabling USB will cause NRF_DRV_POWER_USB_EVT_READY - // to occur, which will start the USBD peripheral - // when the internal regulator has settled - if(!nrf_drv_usbd_is_enabled()) - nrf_drv_usbd_enable(); + // If VBUS is already available, enable immediately + if (nrfx_power_usbstatus_get() == NRFX_POWER_USB_STATE_CONNECTED) { + // Enabling USB will cause NRF_DRV_POWER_USB_EVT_READY + // to occur, which will start the USBD peripheral + // when the internal regulator has settled + if (!nrf_drv_usbd_is_enabled()) { + nrf_drv_usbd_enable(); + } - if(nrfx_power_usbstatus_get() == NRFX_POWER_USB_STATE_READY - && !nrf_drv_usbd_is_started()) - nrf_drv_usbd_start(true); - } + if (nrfx_power_usbstatus_get() == NRFX_POWER_USB_STATE_READY + && !nrf_drv_usbd_is_started()) { + nrf_drv_usbd_start(true); + } + } } -void USBPhyHw::disconnect() { +void USBPhyHw::disconnect() +{ - this->connect_enabled = false; + this->connect_enabled = false; - if(nrf_drv_usbd_is_started()) - nrf_drv_usbd_stop(); - if(nrf_drv_usbd_is_enabled()) - nrf_drv_usbd_disable(); + if (nrf_drv_usbd_is_started()) { + nrf_drv_usbd_stop(); + } + if (nrf_drv_usbd_is_enabled()) { + nrf_drv_usbd_disable(); + } } -void USBPhyHw::configure() { - // Not needed +void USBPhyHw::configure() +{ + // Not needed } -void USBPhyHw::unconfigure() { - // Remove all endpoints (except control, obviously) - nrf_drv_usbd_ep_default_config(); +void USBPhyHw::unconfigure() +{ + // Remove all endpoints (except control, obviously) + nrf_drv_usbd_ep_default_config(); } -void USBPhyHw::sof_enable() { - // TODO - Enable SOF interrupt - // Can this safely be done if - // nrf_drv_usbd_start is called with SoF enabled? - // For now just mask the interrupt with a boolean flag - sof_enabled = true; +void USBPhyHw::sof_enable() +{ + // TODO - Enable SOF interrupt + // Can this safely be done if + // nrf_drv_usbd_start is called with SoF enabled? + // For now just mask the interrupt with a boolean flag + sof_enabled = true; } -void USBPhyHw::sof_disable() { - // TODO - Disable SOF interrupt - // Can this safely be done if - // nrf_drv_usbd_start is called with SoF enabled? - sof_enabled = false; +void USBPhyHw::sof_disable() +{ + // TODO - Disable SOF interrupt + // Can this safely be done if + // nrf_drv_usbd_start is called with SoF enabled? + sof_enabled = false; } -void USBPhyHw::set_address(uint8_t address) { - // nothing to do, handled by hardware; but don't STALL +void USBPhyHw::set_address(uint8_t address) +{ + // nothing to do, handled by hardware; but don't STALL } -void USBPhyHw::remote_wakeup() { - // Not supported(?) +void USBPhyHw::remote_wakeup() +{ + // Not supported(?) } -const usb_ep_table_t *USBPhyHw::endpoint_table() { +const usb_ep_table_t *USBPhyHw::endpoint_table() +{ - static const usb_ep_table_t template_table = - { - 1536, // 64 bytes per bulk/int endpoint pair (8), 1023 bytes for iso endpoint pair (1) - { - { USB_EP_ATTR_ALLOW_CTRL | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { USB_EP_ATTR_ALLOW_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, - } - }; - return &template_table; + static const usb_ep_table_t template_table = { + 1536, // 64 bytes per bulk/int endpoint pair (8), 1023 bytes for iso endpoint pair (1) + { + { USB_EP_ATTR_ALLOW_CTRL | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { ENDPOINT_NON_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { USB_EP_ATTR_ALLOW_ISO | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + { 0 | USB_EP_ATTR_DIR_IN_AND_OUT, 0, 0 }, + } + }; + return &template_table; } -uint32_t USBPhyHw::ep0_set_max_packet(uint32_t max_packet) { - disable_usb_interrupts(); +uint32_t USBPhyHw::ep0_set_max_packet(uint32_t max_packet) +{ + disable_usb_interrupts(); - if (max_packet > MAX_PACKET_SIZE_SETUP) - max_packet = MAX_PACKET_SIZE_SETUP; + if (max_packet > MAX_PACKET_SIZE_SETUP) { + max_packet = MAX_PACKET_SIZE_SETUP; + } - nrf_drv_usbd_ep_max_packet_size_set(NRF_DRV_USBD_EPOUT0, max_packet); - nrf_drv_usbd_ep_max_packet_size_set(NRF_DRV_USBD_EPIN0, max_packet); + nrf_drv_usbd_ep_max_packet_size_set(NRF_DRV_USBD_EPOUT0, max_packet); + nrf_drv_usbd_ep_max_packet_size_set(NRF_DRV_USBD_EPIN0, max_packet); - enable_usb_interrupts(); + enable_usb_interrupts(); - return max_packet; + return max_packet; } // read setup packet -void USBPhyHw::ep0_setup_read_result(uint8_t *buffer, uint32_t size) { +void USBPhyHw::ep0_setup_read_result(uint8_t *buffer, uint32_t size) +{ - disable_usb_interrupts(); + disable_usb_interrupts(); - if (size > sizeof(this->setup_buf)) { - size = sizeof(this->setup_buf); - } - memcpy(buffer, &this->setup_buf, size); + if (size > sizeof(this->setup_buf)) { + size = sizeof(this->setup_buf); + } + memcpy(buffer, &this->setup_buf, size); - enable_usb_interrupts(); + enable_usb_interrupts(); } -void USBPhyHw::ep0_read(uint8_t *data, uint32_t size) { +void USBPhyHw::ep0_read(uint8_t *data, uint32_t size) +{ - // Check for status stage - if(data == NULL && size == 0) - { - // If the data stage transfer direction was OUT - if(setup_buf.bmRequestType & SETUP_TRANSFER_DIR_MASK) - { - // This is the status stage -- trigger the status task and notify the Mbed stack - // Don't trigger status stage unless endpoint is not busy! - // (Causes an undocumented hardware-initiated stall on the control endpoint) - if(nrf_drv_usbd_ep_is_busy(NRF_DRV_USBD_EPIN0)) - nrf_usbd_shorts_enable(NRF_USBD_SHORT_EP0DATADONE_EP0STATUS_MASK); - else - nrf_usbd_task_trigger(NRF_USBD_TASK_EP0STATUS); + // Check for status stage + if (data == NULL && size == 0) { + // If the data stage transfer direction was OUT + if (setup_buf.bmRequestType & SETUP_TRANSFER_DIR_MASK) { + // This is the status stage -- trigger the status task and notify the Mbed stack + // Don't trigger status stage unless endpoint is not busy! + // (Causes an undocumented hardware-initiated stall on the control endpoint) + if (nrf_drv_usbd_ep_is_busy(NRF_DRV_USBD_EPIN0)) { + nrf_usbd_shorts_enable(NRF_USBD_SHORT_EP0DATADONE_EP0STATUS_MASK); + } else { + nrf_usbd_task_trigger(NRF_USBD_TASK_EP0STATUS); + } - virtual_status_xfer_event = true; + virtual_status_xfer_event = true; - // Trigger an interrupt to process the virtual status event - NRFX_IRQ_PENDING_SET(USBD_IRQn); + // Trigger an interrupt to process the virtual status event + NRFX_IRQ_PENDING_SET(USBD_IRQn); - return; - } - } + return; + } + } - nrf_drv_usbd_transfer_t* transfer = get_transfer_buffer((usb_ep_t)(NRF_DRV_USBD_EPOUT0)); - memset(transfer, 0, sizeof(nrf_drv_usbd_transfer_t)); - transfer->p_data.rx = data; - transfer->size = size; + nrf_drv_usbd_transfer_t *transfer = get_transfer_buffer((usb_ep_t)(NRF_DRV_USBD_EPOUT0)); + memset(transfer, 0, sizeof(nrf_drv_usbd_transfer_t)); + transfer->p_data.rx = data; + transfer->size = size; - nrf_drv_usbd_setup_data_clear(); // tell the hardware to receive another OUT packet + nrf_drv_usbd_setup_data_clear(); // tell the hardware to receive another OUT packet - ret_code_t ret = nrf_drv_usbd_ep_transfer(NRF_DRV_USBD_EPOUT0, transfer); - MBED_ASSERT(ret == NRF_SUCCESS); + ret_code_t ret = nrf_drv_usbd_ep_transfer(NRF_DRV_USBD_EPOUT0, transfer); + MBED_ASSERT(ret == NRF_SUCCESS); } -uint32_t USBPhyHw::ep0_read_result() { - return nrf_drv_usbd_epout_size_get(NRF_DRV_USBD_EPOUT0); +uint32_t USBPhyHw::ep0_read_result() +{ + return nrf_drv_usbd_epout_size_get(NRF_DRV_USBD_EPOUT0); } -void USBPhyHw::ep0_write(uint8_t *buffer, uint32_t size) { +void USBPhyHw::ep0_write(uint8_t *buffer, uint32_t size) +{ - // Check for status stage - if(buffer == NULL && size == 0) - { - // If the requested size was 0 OR the data stage transfer direction was OUT - if(setup_buf.wLength == 0 - || ((setup_buf.bmRequestType & SETUP_TRANSFER_DIR_MASK) == 0)) - { + // Check for status stage + if (buffer == NULL && size == 0) { + // If the requested size was 0 OR the data stage transfer direction was OUT + if (setup_buf.wLength == 0 + || ((setup_buf.bmRequestType & SETUP_TRANSFER_DIR_MASK) == 0)) { - // This is the status stage -- trigger the status task and notify the Mbed stack + // This is the status stage -- trigger the status task and notify the Mbed stack - // Don't trigger status stage unless endpoint is not busy! - // (Causes an undocumented hardware-initiated stall on the control endpoint) - if(nrf_drv_usbd_ep_is_busy(NRF_DRV_USBD_EPOUT0)) - nrf_usbd_shorts_enable(NRF_USBD_SHORT_EP0DATADONE_EP0STATUS_MASK); - else - nrf_usbd_task_trigger(NRF_USBD_TASK_EP0STATUS); + // Don't trigger status stage unless endpoint is not busy! + // (Causes an undocumented hardware-initiated stall on the control endpoint) + if (nrf_drv_usbd_ep_is_busy(NRF_DRV_USBD_EPOUT0)) { + nrf_usbd_shorts_enable(NRF_USBD_SHORT_EP0DATADONE_EP0STATUS_MASK); + } else { + nrf_usbd_task_trigger(NRF_USBD_TASK_EP0STATUS); + } - virtual_status_xfer_event = true; + virtual_status_xfer_event = true; - // Trigger an interrupt to process the virtual status event - NRFX_IRQ_PENDING_SET(USBD_IRQn); + // Trigger an interrupt to process the virtual status event + NRFX_IRQ_PENDING_SET(USBD_IRQn); - return; - } - } + return; + } + } - nrf_drv_usbd_transfer_t* transfer = get_transfer_buffer(NRF_DRV_USBD_EPIN0); - memset(transfer, 0, sizeof(nrf_drv_usbd_transfer_t)); - transfer->p_data.tx = buffer; - transfer->size = size; + nrf_drv_usbd_transfer_t *transfer = get_transfer_buffer(NRF_DRV_USBD_EPIN0); + memset(transfer, 0, sizeof(nrf_drv_usbd_transfer_t)); + transfer->p_data.tx = buffer; + transfer->size = size; - if(size == 0) - transfer->flags |= NRF_DRV_USBD_TRANSFER_ZLP_FLAG; + if (size == 0) { + transfer->flags |= NRF_DRV_USBD_TRANSFER_ZLP_FLAG; + } - ret_code_t ret = nrf_drv_usbd_ep_transfer(NRF_DRV_USBD_EPIN0, transfer); - MBED_ASSERT(ret == NRF_SUCCESS); + ret_code_t ret = nrf_drv_usbd_ep_transfer(NRF_DRV_USBD_EPIN0, transfer); + MBED_ASSERT(ret == NRF_SUCCESS); } -void USBPhyHw::ep0_stall() { - // Note: This stall must be automatically cleared by the next setup packet - nrf_drv_usbd_setup_stall(); +void USBPhyHw::ep0_stall() +{ + // Note: This stall must be automatically cleared by the next setup packet + nrf_drv_usbd_setup_stall(); } -bool USBPhyHw::endpoint_add(usb_ep_t endpoint, uint32_t max_packet, usb_ep_type_t type) { - nrf_drv_usbd_ep_t nrf_ep = get_nordic_endpoint(endpoint); - nrf_drv_usbd_ep_enable(nrf_ep); - nrf_drv_usbd_ep_max_packet_size_set(nrf_ep, max_packet); - return nrf_drv_usbd_ep_enable_check(nrf_ep); +bool USBPhyHw::endpoint_add(usb_ep_t endpoint, uint32_t max_packet, usb_ep_type_t type) +{ + nrf_drv_usbd_ep_t nrf_ep = get_nordic_endpoint(endpoint); + nrf_drv_usbd_ep_enable(nrf_ep); + nrf_drv_usbd_ep_max_packet_size_set(nrf_ep, max_packet); + return nrf_drv_usbd_ep_enable_check(nrf_ep); } -void USBPhyHw::endpoint_remove(usb_ep_t endpoint) { - nrf_drv_usbd_ep_t nrf_ep = get_nordic_endpoint(endpoint); - // Reset data toggle for bulk/interrupt endpoints - if(nrf_ep != NRF_DRV_USBD_EPOUT8 && nrf_ep != NRF_DRV_USBD_EPIN8) - nrf_drv_usbd_ep_dtoggle_clear(nrf_ep); +void USBPhyHw::endpoint_remove(usb_ep_t endpoint) +{ + nrf_drv_usbd_ep_t nrf_ep = get_nordic_endpoint(endpoint); + // Reset data toggle for bulk/interrupt endpoints + if (nrf_ep != NRF_DRV_USBD_EPOUT8 && nrf_ep != NRF_DRV_USBD_EPIN8) { + nrf_drv_usbd_ep_dtoggle_clear(nrf_ep); + } - nrf_drv_usbd_ep_disable(nrf_ep); + nrf_drv_usbd_ep_disable(nrf_ep); } -void USBPhyHw::endpoint_stall(usb_ep_t endpoint) { - nrf_drv_usbd_ep_stall(get_nordic_endpoint(endpoint)); +void USBPhyHw::endpoint_stall(usb_ep_t endpoint) +{ + nrf_drv_usbd_ep_stall(get_nordic_endpoint(endpoint)); } -void USBPhyHw::endpoint_unstall(usb_ep_t endpoint) { - nrf_drv_usbd_ep_t ep = get_nordic_endpoint(endpoint); - nrf_drv_usbd_ep_stall_clear(ep); +void USBPhyHw::endpoint_unstall(usb_ep_t endpoint) +{ + nrf_drv_usbd_ep_t ep = get_nordic_endpoint(endpoint); + nrf_drv_usbd_ep_stall_clear(ep); - /* - * This is a somewhat hacky fix to fully "unload" - * an IN endpoint after a buffer has been - * transferred via EasyDMA... - */ + /* + * This is a somewhat hacky fix to fully "unload" + * an IN endpoint after a buffer has been + * transferred via EasyDMA... + */ - nrf_drv_usbd_ep_disable(ep); - nrf_drv_usbd_ep_enable(ep); + nrf_drv_usbd_ep_disable(ep); + nrf_drv_usbd_ep_enable(ep); } -bool USBPhyHw::endpoint_read(usb_ep_t endpoint, uint8_t *data, uint32_t size) { - nrf_drv_usbd_transfer_t* transfer = get_transfer_buffer(endpoint); - memset(transfer, 0, sizeof(nrf_drv_usbd_transfer_t)); - transfer->p_data.rx = data; - transfer->size = size; +bool USBPhyHw::endpoint_read(usb_ep_t endpoint, uint8_t *data, uint32_t size) +{ + nrf_drv_usbd_transfer_t *transfer = get_transfer_buffer(endpoint); + memset(transfer, 0, sizeof(nrf_drv_usbd_transfer_t)); + transfer->p_data.rx = data; + transfer->size = size; - ret_code_t ret = nrf_drv_usbd_ep_transfer(get_nordic_endpoint(endpoint), transfer); - return (ret == NRF_SUCCESS); + ret_code_t ret = nrf_drv_usbd_ep_transfer(get_nordic_endpoint(endpoint), transfer); + return (ret == NRF_SUCCESS); } -uint32_t USBPhyHw::endpoint_read_result(usb_ep_t endpoint) { - return nrf_drv_usbd_epout_size_get(get_nordic_endpoint(endpoint)); +uint32_t USBPhyHw::endpoint_read_result(usb_ep_t endpoint) +{ + return nrf_drv_usbd_epout_size_get(get_nordic_endpoint(endpoint)); } -bool USBPhyHw::endpoint_write(usb_ep_t endpoint, uint8_t *data, uint32_t size) { - nrf_drv_usbd_transfer_t* transfer = get_transfer_buffer(endpoint); - memset(transfer, 0, sizeof(nrf_drv_usbd_transfer_t)); - transfer->p_data.tx = data; - transfer->size = size; +bool USBPhyHw::endpoint_write(usb_ep_t endpoint, uint8_t *data, uint32_t size) +{ + nrf_drv_usbd_transfer_t *transfer = get_transfer_buffer(endpoint); + memset(transfer, 0, sizeof(nrf_drv_usbd_transfer_t)); + transfer->p_data.tx = data; + transfer->size = size; - // If this is a zero-length-packet (ZLP) - // Set the ZLP flag - if(size == 0) - transfer->flags |= NRF_DRV_USBD_TRANSFER_ZLP_FLAG; + // If this is a zero-length-packet (ZLP) + // Set the ZLP flag + if (size == 0) { + transfer->flags |= NRF_DRV_USBD_TRANSFER_ZLP_FLAG; + } - ret_code_t ret = nrf_drv_usbd_ep_transfer(get_nordic_endpoint(endpoint), transfer); - return (ret == NRF_SUCCESS); + ret_code_t ret = nrf_drv_usbd_ep_transfer(get_nordic_endpoint(endpoint), transfer); + return (ret == NRF_SUCCESS); } -void USBPhyHw::endpoint_abort(usb_ep_t endpoint) { - nrf_drv_usbd_ep_abort(get_nordic_endpoint(endpoint)); +void USBPhyHw::endpoint_abort(usb_ep_t endpoint) +{ + nrf_drv_usbd_ep_abort(get_nordic_endpoint(endpoint)); } -void USBPhyHw::process() { +void USBPhyHw::process() +{ - if (usb_event_type == USB_HW_EVENT_USBD) { + if (usb_event_type == USB_HW_EVENT_USBD) { - // Process regular USBD events - switch (usb_event.type) { - case NRF_DRV_USBD_EVT_SUSPEND: - events->suspend(true); - break; - case NRF_DRV_USBD_EVT_RESUME: - events->suspend(false); - break; - case NRF_DRV_USBD_EVT_WUREQ: - break; - case NRF_DRV_USBD_EVT_RESET: - this->_reset(); - events->reset(); - break; - case NRF_DRV_USBD_EVT_SOF: - if(sof_enabled) - events->sof(usb_event.data.sof.framecnt); - break; - case NRF_DRV_USBD_EVT_EPTRANSFER: - if(usb_event.data.eptransfer.status == NRF_USBD_EP_OK) - { - if(!nrf_drv_usbd_ep_stall_check(usb_event.data.eptransfer.ep)) - { - if(IS_IN_EP(usb_event.data.eptransfer.ep)) - { - if((usb_event.data.eptransfer.ep & 0x7F) == 0) - events->ep0_in(); - else - events->in((usb_ep_t) usb_event.data.eptransfer.ep); - } - else - { - if((usb_event.data.eptransfer.ep & 0x7F) == 0) - events->ep0_out(); - else - events->out((usb_ep_t) usb_event.data.eptransfer.ep); - } - } - } - break; - case NRF_DRV_USBD_EVT_SETUP: { - nrf_drv_usbd_ep_stall_clear(NRF_DRV_USBD_EPIN0); - nrf_drv_usbd_ep_stall_clear(NRF_DRV_USBD_EPOUT0); + // Process regular USBD events + switch (usb_event.type) { + case NRF_DRV_USBD_EVT_SUSPEND: + events->suspend(true); + break; + case NRF_DRV_USBD_EVT_RESUME: + events->suspend(false); + break; + case NRF_DRV_USBD_EVT_WUREQ: + break; + case NRF_DRV_USBD_EVT_RESET: + this->_reset(); + events->reset(); + break; + case NRF_DRV_USBD_EVT_SOF: + if (sof_enabled) { + events->sof(usb_event.data.sof.framecnt); + } + break; + case NRF_DRV_USBD_EVT_EPTRANSFER: + if (usb_event.data.eptransfer.status == NRF_USBD_EP_OK) { + if (!nrf_drv_usbd_ep_stall_check(usb_event.data.eptransfer.ep)) { + if (IS_IN_EP(usb_event.data.eptransfer.ep)) { + if ((usb_event.data.eptransfer.ep & 0x7F) == 0) { + events->ep0_in(); + } else { + events->in((usb_ep_t) usb_event.data.eptransfer.ep); + } + } else { + if ((usb_event.data.eptransfer.ep & 0x7F) == 0) { + events->ep0_out(); + } else { + events->out((usb_ep_t) usb_event.data.eptransfer.ep); + } + } + } + } + break; + case NRF_DRV_USBD_EVT_SETUP: { + nrf_drv_usbd_ep_stall_clear(NRF_DRV_USBD_EPIN0); + nrf_drv_usbd_ep_stall_clear(NRF_DRV_USBD_EPOUT0); - // Copy the setup packet into the internal buffer - nrf_drv_usbd_setup_get(&setup_buf); + // Copy the setup packet into the internal buffer + nrf_drv_usbd_setup_get(&setup_buf); - // Notify the Mbed stack - events->ep0_setup(); - } - break; - default: - break; + // Notify the Mbed stack + events->ep0_setup(); + } + break; + default: + break; - } - } - else if (usb_event_type == USB_HW_EVENT_POWER) - { - // Process USB power-related events - switch (usb_power_event) { - case NRFX_POWER_USB_EVT_DETECTED: - if(this->connect_enabled) { - if(!nrf_drv_usbd_is_enabled()) - nrf_drv_usbd_enable(); - events->power(true); - } - break; - case NRFX_POWER_USB_EVT_REMOVED: - events->power(false); - break; - case NRFX_POWER_USB_EVT_READY: - if(!nrf_drv_usbd_is_started()) - nrf_drv_usbd_start(true); - break; - default: - ASSERT(false); - } - } - else if (usb_event_type == USB_HW_EVENT_VIRTUAL_STATUS) - { - // Notify Mbed stack of status stage transfer completion - if(setup_buf.bmRequestType & SETUP_TRANSFER_DIR_MASK) // DATA IN transfer, Status OUT transfer - events->ep0_out(); - else // DATA OUT transfer, Status IN transfer - events->ep0_in(); - } + } + } else if (usb_event_type == USB_HW_EVENT_POWER) { + // Process USB power-related events + switch (usb_power_event) { + case NRFX_POWER_USB_EVT_DETECTED: + if (this->connect_enabled) { + if (!nrf_drv_usbd_is_enabled()) { + nrf_drv_usbd_enable(); + } + events->power(true); + } + break; + case NRFX_POWER_USB_EVT_REMOVED: + events->power(false); + break; + case NRFX_POWER_USB_EVT_READY: + if (!nrf_drv_usbd_is_started()) { + nrf_drv_usbd_start(true); + } + break; + default: + ASSERT(false); + } + } else if (usb_event_type == USB_HW_EVENT_VIRTUAL_STATUS) { + // Notify Mbed stack of status stage transfer completion + if (setup_buf.bmRequestType & SETUP_TRANSFER_DIR_MASK) { // DATA IN transfer, Status OUT transfer + events->ep0_out(); + } else { // DATA OUT transfer, Status IN transfer + events->ep0_in(); + } + } - // Unflag the event type - usb_event_type = USB_HW_EVENT_NONE; + // Unflag the event type + usb_event_type = USB_HW_EVENT_NONE; - // Re-enable interrupt - enable_usb_interrupts(); + // Re-enable interrupt + enable_usb_interrupts(); } void USBPhyHw::_usb_event_handler( - nrf_drv_usbd_evt_t const * const p_event) { - disable_usb_interrupts(); - // Copy the event data into internal memory - memcpy(&instance->usb_event, p_event, sizeof(instance->usb_event)); - // Tell the upper layers of the stack to process the event - instance->usb_event_type = USB_HW_EVENT_USBD; - instance->events->start_process(); + nrf_drv_usbd_evt_t const *const p_event) +{ + disable_usb_interrupts(); + // Copy the event data into internal memory + memcpy(&instance->usb_event, p_event, sizeof(instance->usb_event)); + // Tell the upper layers of the stack to process the event + instance->usb_event_type = USB_HW_EVENT_USBD; + instance->events->start_process(); } -void USBPhyHw::_usb_power_event_handler(nrfx_power_usb_evt_t event) { - disable_usb_interrupts(); - // Copy the event data into internal memory - instance->usb_power_event = event; - // Tell the upper layers of the stack to process the event - instance->usb_event_type = USB_HW_EVENT_POWER; - instance->events->start_process(); +void USBPhyHw::_usb_power_event_handler(nrfx_power_usb_evt_t event) +{ + disable_usb_interrupts(); + // Copy the event data into internal memory + instance->usb_power_event = event; + // Tell the upper layers of the stack to process the event + instance->usb_event_type = USB_HW_EVENT_POWER; + instance->events->start_process(); } -void USBPhyHw::_usb_virtual_status_event_handler(void) { - disable_usb_interrupts(); +void USBPhyHw::_usb_virtual_status_event_handler(void) +{ + disable_usb_interrupts(); - // Tell the upper layers of the stack to process the event - instance->usb_event_type = USB_HW_EVENT_VIRTUAL_STATUS; - instance->events->start_process(); + // Tell the upper layers of the stack to process the event + instance->usb_event_type = USB_HW_EVENT_VIRTUAL_STATUS; + instance->events->start_process(); } -nrf_drv_usbd_transfer_t* USBPhyHw::get_transfer_buffer(usb_ep_t endpoint) { - // Index is base endpoint number * 2 (output), add 1 for input endpoints - return &transfer_buf[(((endpoint & 0x7F) << 1) + ((endpoint & 0x80) >> 7))]; +nrf_drv_usbd_transfer_t *USBPhyHw::get_transfer_buffer(usb_ep_t endpoint) +{ + // Index is base endpoint number * 2 (output), add 1 for input endpoints + return &transfer_buf[(((endpoint & 0x7F) << 1) + ((endpoint & 0x80) >> 7))]; } -nrf_drv_usbd_ep_t USBPhyHw::get_nordic_endpoint(usb_ep_t endpoint) { - // Clear the most-significant-bit (input endpoint flag) - return (nrf_drv_usbd_ep_t) endpoint; +nrf_drv_usbd_ep_t USBPhyHw::get_nordic_endpoint(usb_ep_t endpoint) +{ + // Clear the most-significant-bit (input endpoint flag) + return (nrf_drv_usbd_ep_t) endpoint; } void USBPhyHw::_reset(void) { - // Disable all endpoints except for control endpoints - nrf_drv_usbd_ep_default_config(); + // Disable all endpoints except for control endpoints + nrf_drv_usbd_ep_default_config(); - nrf_drv_usbd_setup_clear(); + nrf_drv_usbd_setup_clear(); - usb_event_type = USB_HW_EVENT_NONE; + usb_event_type = USB_HW_EVENT_NONE; - // Clear all endpoint interrupts - NRFX_IRQ_PENDING_CLEAR(USBD_IRQn); - nrf_usbd_event_clear((nrf_usbd_event_t)0x01FFFFFF); + // Clear all endpoint interrupts + NRFX_IRQ_PENDING_CLEAR(USBD_IRQn); + nrf_usbd_event_clear((nrf_usbd_event_t)0x01FFFFFF); } -void USBPhyHw::enable_usb_interrupts(void) { - // Enable USB and USB-related power interrupts - NRFX_IRQ_ENABLE(USBD_IRQn); - nrfx_power_usbevt_enable(); +void USBPhyHw::enable_usb_interrupts(void) +{ + // Enable USB and USB-related power interrupts + NRFX_IRQ_ENABLE(USBD_IRQn); + nrfx_power_usbevt_enable(); } -void USBPhyHw::disable_usb_interrupts(void) { - // Disable USB and USB-related power interrupts - NRFX_IRQ_DISABLE(USBD_IRQn); - nrfx_power_usbevt_disable(); +void USBPhyHw::disable_usb_interrupts(void) +{ + // Disable USB and USB-related power interrupts + NRFX_IRQ_DISABLE(USBD_IRQn); + nrfx_power_usbevt_disable(); } -static void power_usb_event_handler(nrfx_power_usb_evt_t event) { - if(instance) { - // Pass the event on to the USBPhyHW instance - instance->_usb_power_event_handler(event); - } +static void power_usb_event_handler(nrfx_power_usb_evt_t event) +{ + if (instance) { + // Pass the event on to the USBPhyHW instance + instance->_usb_power_event_handler(event); + } } -static void usbd_event_handler(nrf_drv_usbd_evt_t const * const p_event) { - if(instance) { - // Pass the event on to the USBPhyHW instance - instance->_usb_event_handler(p_event); - } +static void usbd_event_handler(nrf_drv_usbd_evt_t const *const p_event) +{ + if (instance) { + // Pass the event on to the USBPhyHW instance + instance->_usb_event_handler(p_event); + } } void USBD_HAL_IRQHandler(void) { - // Process the virtual status stage transfer event - if(virtual_status_xfer_event) - { - if(instance) { - instance->_usb_virtual_status_event_handler(); - } + // Process the virtual status stage transfer event + if (virtual_status_xfer_event) { + if (instance) { + instance->_usb_virtual_status_event_handler(); + } - virtual_status_xfer_event = false; + virtual_status_xfer_event = false; - } - // Call Nordic driver IRQ handler - USBD_IRQHandler(); + } + // Call Nordic driver IRQ handler + USBD_IRQHandler(); }