Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-26 05:54:46 -07:00
Code Issues Packages Projects Releases Wiki Activity

HAL usb: fix api return data

Browse Source
This commit is contained in:
SG
2022-11-12 09:09:22 +10:00
parent e6e073f1dc
commit 77d12f4a8e
1 changed files with 52 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
firmware/targets/f7/furi_hal/furi_hal_usb.c
View File

@@ -48,7 +48,7 @@ typedef struct {
FuriApiLock lock; FuriApiLock lock;
UsbApiEventType type; UsbApiEventType type;
UsbApiEventData data; UsbApiEventData data;
UsbApiEventReturnData return_data; UsbApiEventReturnData* return_data;
} UsbApiEventMessage; } UsbApiEventMessage;
typedef struct { typedef struct {
@@ -57,12 +57,10 @@ typedef struct {
bool enabled; bool enabled;
bool connected; bool connected;
bool mode_lock; bool mode_lock;
FuriHalUsbInterface* if_cur; FuriHalUsbInterface* interface;
FuriHalUsbInterface* if_next; void* interface_context;
void* if_ctx;
FuriHalUsbStateCallback callback; FuriHalUsbStateCallback callback;
void* cb_ctx; void* callback_context;
bool request_pending; bool request_pending;
} UsbSrv; } UsbSrv;
@@ -109,7 +107,7 @@ void furi_hal_usb_init(void) {
// Reset callback will be enabled after first mode change to avoid getting false reset events // Reset callback will be enabled after first mode change to avoid getting false reset events
usb.enabled = false; usb.enabled = false;
usb.if_cur = NULL; usb.interface = NULL;
NVIC_SetPriority(USB_LP_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0)); NVIC_SetPriority(USB_LP_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
NVIC_SetPriority(USB_HP_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 15, 0)); NVIC_SetPriority(USB_HP_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 15, 0));
NVIC_EnableIRQ(USB_LP_IRQn); NVIC_EnableIRQ(USB_LP_IRQn);
@@ -128,6 +126,10 @@ void furi_hal_usb_init(void) {
} }
bool furi_hal_usb_set_config(FuriHalUsbInterface* new_if, void* ctx) { bool furi_hal_usb_set_config(FuriHalUsbInterface* new_if, void* ctx) {
UsbApiEventReturnData return_data = {
.bool_value = false,
};
UsbApiEventMessage msg = { UsbApiEventMessage msg = {
.lock = api_lock_alloc_locked(), .lock = api_lock_alloc_locked(),
.type = UsbApiEventTypeSetConfig, .type = UsbApiEventTypeSetConfig,
@@ -136,34 +138,32 @@ bool furi_hal_usb_set_config(FuriHalUsbInterface* new_if, void* ctx) {
.interface = new_if, .interface = new_if,
.context = ctx, .context = ctx,
}, },
.return_data = .return_data = &return_data,
{
.bool_value = false,
},
}; };
furi_message_queue_put(usb.queue, &msg, FuriWaitForever); furi_message_queue_put(usb.queue, &msg, FuriWaitForever);
furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventMessage); furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventMessage);
api_lock_wait_unlock_and_free(msg.lock); api_lock_wait_unlock_and_free(msg.lock);
return msg.return_data.bool_value; return return_data.bool_value;
} }
FuriHalUsbInterface* furi_hal_usb_get_config() { FuriHalUsbInterface* furi_hal_usb_get_config() {
UsbApiEventReturnData return_data = {
.void_value = NULL,
};
UsbApiEventMessage msg = { UsbApiEventMessage msg = {
.lock = api_lock_alloc_locked(), .lock = api_lock_alloc_locked(),
.type = UsbApiEventTypeGetConfig, .type = UsbApiEventTypeGetConfig,
.return_data = .return_data = &return_data,
{
.void_value = NULL,
},
}; };
furi_message_queue_put(usb.queue, &msg, FuriWaitForever); furi_message_queue_put(usb.queue, &msg, FuriWaitForever);
furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventMessage); furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventMessage);
api_lock_wait_unlock_and_free(msg.lock); api_lock_wait_unlock_and_free(msg.lock);
return msg.return_data.void_value; return return_data.void_value;
} }
void furi_hal_usb_lock() { void furi_hal_usb_lock() {
@@ -189,20 +189,21 @@ void furi_hal_usb_unlock() {
} }
bool furi_hal_usb_is_locked() { bool furi_hal_usb_is_locked() {
UsbApiEventReturnData return_data = {
.bool_value = false,
};
UsbApiEventMessage msg = { UsbApiEventMessage msg = {
.lock = api_lock_alloc_locked(), .lock = api_lock_alloc_locked(),
.type = UsbApiEventTypeIsLocked, .type = UsbApiEventTypeIsLocked,
.return_data = .return_data = &return_data,
{
.bool_value = false,
},
}; };
furi_message_queue_put(usb.queue, &msg, FuriWaitForever); furi_message_queue_put(usb.queue, &msg, FuriWaitForever);
furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventMessage); furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventMessage);
api_lock_wait_unlock_and_free(msg.lock); api_lock_wait_unlock_and_free(msg.lock);
return msg.return_data.bool_value; return return_data.bool_value;
} }
void furi_hal_usb_disable() { void furi_hal_usb_disable() {
@@ -260,29 +261,29 @@ static usbd_respond usb_descriptor_get(usbd_ctlreq* req, void** address, uint16_
const uint8_t dnumber = req->wValue & 0xFF; const uint8_t dnumber = req->wValue & 0xFF;
const void* desc; const void* desc;
uint16_t len = 0; uint16_t len = 0;
if(usb.if_cur == NULL) return usbd_fail; if(usb.interface == NULL) return usbd_fail;
switch(dtype) { switch(dtype) {
case USB_DTYPE_DEVICE: case USB_DTYPE_DEVICE:
furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventRequest); furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventRequest);
if(usb.callback != NULL) { if(usb.callback != NULL) {
usb.callback(FuriHalUsbStateEventDescriptorRequest, usb.cb_ctx); usb.callback(FuriHalUsbStateEventDescriptorRequest, usb.callback_context);
} }
desc = usb.if_cur->dev_descr; desc = usb.interface->dev_descr;
break; break;
case USB_DTYPE_CONFIGURATION: case USB_DTYPE_CONFIGURATION:
desc = usb.if_cur->cfg_descr; desc = usb.interface->cfg_descr;
len = ((struct usb_string_descriptor*)(usb.if_cur->cfg_descr))->wString[0]; len = ((struct usb_string_descriptor*)(usb.interface->cfg_descr))->wString[0];
break; break;
case USB_DTYPE_STRING: case USB_DTYPE_STRING:
if(dnumber == UsbDevLang) { if(dnumber == UsbDevLang) {
desc = &dev_lang_desc; desc = &dev_lang_desc;
} else if((dnumber == UsbDevManuf) && (usb.if_cur->str_manuf_descr != NULL)) { } else if((dnumber == UsbDevManuf) && (usb.interface->str_manuf_descr != NULL)) {
desc = usb.if_cur->str_manuf_descr; desc = usb.interface->str_manuf_descr;
} else if((dnumber == UsbDevProduct) && (usb.if_cur->str_prod_descr != NULL)) { } else if((dnumber == UsbDevProduct) && (usb.interface->str_prod_descr != NULL)) {
desc = usb.if_cur->str_prod_descr; desc = usb.interface->str_prod_descr;
} else if((dnumber == UsbDevSerial) && (usb.if_cur->str_serial_descr != NULL)) { } else if((dnumber == UsbDevSerial) && (usb.interface->str_serial_descr != NULL)) {
desc = usb.if_cur->str_serial_descr; desc = usb.interface->str_serial_descr;
} else } else
return usbd_fail; return usbd_fail;
break; break;
@@ -305,7 +306,7 @@ static void reset_evt(usbd_device* dev, uint8_t event, uint8_t ep) {
UNUSED(ep); UNUSED(ep);
furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventReset); furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventReset);
if(usb.callback != NULL) { if(usb.callback != NULL) {
usb.callback(FuriHalUsbStateEventReset, usb.cb_ctx); usb.callback(FuriHalUsbStateEventReset, usb.callback_context);
} }
} }
@@ -313,14 +314,14 @@ static void susp_evt(usbd_device* dev, uint8_t event, uint8_t ep) {
UNUSED(dev); UNUSED(dev);
UNUSED(event); UNUSED(event);
UNUSED(ep); UNUSED(ep);
if((usb.if_cur != NULL) && (usb.connected == true)) { if((usb.interface != NULL) && (usb.connected == true)) {
usb.connected = false; usb.connected = false;
usb.if_cur->suspend(&udev); usb.interface->suspend(&udev);
furi_hal_power_insomnia_exit(); furi_hal_power_insomnia_exit();
} }
if(usb.callback != NULL) { if(usb.callback != NULL) {
usb.callback(FuriHalUsbStateEventSuspend, usb.cb_ctx); usb.callback(FuriHalUsbStateEventSuspend, usb.callback_context);
} }
} }
@@ -328,25 +329,25 @@ static void wkup_evt(usbd_device* dev, uint8_t event, uint8_t ep) {
UNUSED(dev); UNUSED(dev);
UNUSED(event); UNUSED(event);
UNUSED(ep); UNUSED(ep);
if((usb.if_cur != NULL) && (usb.connected == false)) { if((usb.interface != NULL) && (usb.connected == false)) {
usb.connected = true; usb.connected = true;
usb.if_cur->wakeup(&udev); usb.interface->wakeup(&udev);
furi_hal_power_insomnia_enter(); furi_hal_power_insomnia_enter();
} }
if(usb.callback != NULL) { if(usb.callback != NULL) {
usb.callback(FuriHalUsbStateEventWakeup, usb.cb_ctx); usb.callback(FuriHalUsbStateEventWakeup, usb.callback_context);
} }
} }
static void usb_process_mode_start(FuriHalUsbInterface* interface, void* context) { static void usb_process_mode_start(FuriHalUsbInterface* interface, void* context) {
if(usb.if_cur != NULL) { if(usb.interface != NULL) {
usb.if_cur->deinit(&udev); usb.interface->deinit(&udev);
} }
__disable_irq(); __disable_irq();
usb.if_cur = interface; usb.interface = interface;
usb.if_ctx = context; usb.interface_context = context;
__enable_irq(); __enable_irq();
if(interface != NULL) { if(interface != NULL) {
@@ -358,7 +359,7 @@ static void usb_process_mode_start(FuriHalUsbInterface* interface, void* context
} }
static void usb_process_mode_change(FuriHalUsbInterface* interface, void* context) { static void usb_process_mode_change(FuriHalUsbInterface* interface, void* context) {
if(interface != usb.if_cur) { if(interface != usb.interface) {
if(usb.enabled) { if(usb.enabled) {
// Disable current interface // Disable current interface
susp_evt(&udev, 0, 0); susp_evt(&udev, 0, 0);
@@ -382,7 +383,7 @@ static void usb_process_mode_reinit() {
usbd_enable(&udev, true); usbd_enable(&udev, true);
furi_delay_ms(USB_RECONNECT_DELAY); furi_delay_ms(USB_RECONNECT_DELAY);
usb_process_mode_start(usb.if_cur, usb.if_ctx); usb_process_mode_start(usb.interface, usb.interface_context);
} }
bool usb_process_set_config(FuriHalUsbInterface* interface, void* context) { bool usb_process_set_config(FuriHalUsbInterface* interface, void* context) {
@@ -396,7 +397,7 @@ bool usb_process_set_config(FuriHalUsbInterface* interface, void* context) {
void usb_process_enable(bool enable) { void usb_process_enable(bool enable) {
if(enable) { if(enable) {
if((!usb.enabled) && (usb.if_cur != NULL)) { if((!usb.enabled) && (usb.interface != NULL)) {
usbd_connect(&udev, true); usbd_connect(&udev, true);
usb.enabled = true; usb.enabled = true;
FURI_LOG_I(TAG, "USB Enable"); FURI_LOG_I(TAG, "USB Enable");
@@ -415,11 +416,11 @@ void usb_process_enable(bool enable) {
void usb_process_message(UsbApiEventMessage* message) { void usb_process_message(UsbApiEventMessage* message) {
switch(message->type) { switch(message->type) {
case UsbApiEventTypeSetConfig: case UsbApiEventTypeSetConfig:
message->return_data.bool_value = usb_process_set_config( message->return_data->bool_value = usb_process_set_config(
message->data.interface.interface, message->data.interface.context); message->data.interface.interface, message->data.interface.context);
break; break;
case UsbApiEventTypeGetConfig: case UsbApiEventTypeGetConfig:
message->return_data.void_value = usb.if_cur; message->return_data->void_value = usb.interface;
break; break;
case UsbApiEventTypeLock: case UsbApiEventTypeLock:
FURI_LOG_I(TAG, "Mode lock"); FURI_LOG_I(TAG, "Mode lock");
@@ -430,7 +431,7 @@ void usb_process_message(UsbApiEventMessage* message) {
usb.mode_lock = false; usb.mode_lock = false;
break; break;
case UsbApiEventTypeIsLocked: case UsbApiEventTypeIsLocked:
message->return_data.bool_value = usb.mode_lock; message->return_data->bool_value = usb.mode_lock;
break; break;
case UsbApiEventTypeDisable: case UsbApiEventTypeDisable:
usb_process_enable(false); usb_process_enable(false);
@@ -443,7 +444,7 @@ void usb_process_message(UsbApiEventMessage* message) {
break; break;
case UsbApiEventTypeSetStateCallback: case UsbApiEventTypeSetStateCallback:
usb.callback = message->data.state_callback.callback; usb.callback = message->data.state_callback.callback;
usb.cb_ctx = message->data.state_callback.context; usb.callback_context = message->data.state_callback.context;
break; break;
} }