From 0769c38d26bdb2941385c32ff66a25beeb987f75 Mon Sep 17 00:00:00 2001 From: David Cross Date: Thu, 23 Sep 2010 17:24:45 -0700 Subject: Staging: west bridge, removal of " " before ";" This patch fixes removes all of the the " ;"'s in the west bridge driver and instead replaces them with ";" only. Although this is a large patch, this is the only thing that it does. I can break it up on a file basis if needed. Signed-off-by: David Cross Signed-off-by: Greg Kroah-Hartman --- .../staging/westbridge/astoria/api/src/cyasusb.c | 2592 ++++++++++---------- 1 file changed, 1296 insertions(+), 1296 deletions(-) (limited to 'drivers/staging/westbridge/astoria/api/src/cyasusb.c') diff --git a/drivers/staging/westbridge/astoria/api/src/cyasusb.c b/drivers/staging/westbridge/astoria/api/src/cyasusb.c index d0ffc2cfe77..5a219701206 100644 --- a/drivers/staging/westbridge/astoria/api/src/cyasusb.c +++ b/drivers/staging/westbridge/astoria/api/src/cyasusb.c @@ -36,7 +36,7 @@ cy_as_usb_ack_setup_packet( cy_as_function_callback cb, /* Client supplied data */ uint32_t client - ) ; + ); static void cy_as_usb_func_callback( @@ -44,21 +44,21 @@ cy_as_usb_func_callback( uint8_t context, cy_as_ll_request_response *rqt, cy_as_ll_request_response *resp, - cy_as_return_status_t ret) ; + cy_as_return_status_t ret); /* * Reset the USB EP0 state */ static void cy_as_usb_reset_e_p0_state(cy_as_device *dev_p) { - cy_as_log_debug_message(6, "cy_as_usb_reset_e_p0_state called") ; + cy_as_log_debug_message(6, "cy_as_usb_reset_e_p0_state called"); - cy_as_device_clear_ack_delayed(dev_p) ; - cy_as_device_clear_setup_packet(dev_p) ; + cy_as_device_clear_ack_delayed(dev_p); + cy_as_device_clear_setup_packet(dev_p); if (cy_as_device_is_usb_async_pending(dev_p, 0)) - cy_as_usb_cancel_async((cy_as_device_handle)dev_p, 0) ; + cy_as_usb_cancel_async((cy_as_device_handle)dev_p, 0); - dev_p->usb_pending_buffer = 0 ; + dev_p->usb_pending_buffer = 0; } /* @@ -68,18 +68,18 @@ static cy_as_return_status_t is_usb_active(cy_as_device *dev_p) { if (!cy_as_device_is_configured(dev_p)) - return CY_AS_ERROR_NOT_CONFIGURED ; + return CY_AS_ERROR_NOT_CONFIGURED; if (!cy_as_device_is_firmware_loaded(dev_p)) - return CY_AS_ERROR_NO_FIRMWARE ; + return CY_AS_ERROR_NO_FIRMWARE; if (dev_p->usb_count == 0) - return CY_AS_ERROR_NOT_RUNNING ; + return CY_AS_ERROR_NOT_RUNNING; if (cy_as_device_is_in_suspend_mode(dev_p)) - return CY_AS_ERROR_IN_SUSPEND ; + return CY_AS_ERROR_IN_SUSPEND; - return CY_AS_ERROR_SUCCESS ; + return CY_AS_ERROR_SUCCESS; } static void @@ -89,69 +89,69 @@ usb_ack_callback(cy_as_device_handle h, cy_as_funct_c_b_type type, void *data) { - cy_as_device *dev_p = (cy_as_device *)h ; + cy_as_device *dev_p = (cy_as_device *)h; - (void)client ; - (void)status ; - (void)data ; + (void)client; + (void)status; + (void)data; - cy_as_hal_assert(type == CY_FUNCT_CB_NODATA) ; + cy_as_hal_assert(type == CY_FUNCT_CB_NODATA); if (dev_p->usb_pending_buffer) { - cy_as_usb_io_callback cb ; + cy_as_usb_io_callback cb; - cb = dev_p->usb_cb[0] ; - dev_p->usb_cb[0] = 0 ; - cy_as_device_clear_usb_async_pending(dev_p, 0) ; + cb = dev_p->usb_cb[0]; + dev_p->usb_cb[0] = 0; + cy_as_device_clear_usb_async_pending(dev_p, 0); if (cb) cb(h, 0, dev_p->usb_pending_size, - dev_p->usb_pending_buffer, dev_p->usb_error) ; + dev_p->usb_pending_buffer, dev_p->usb_error); - dev_p->usb_pending_buffer = 0 ; + dev_p->usb_pending_buffer = 0; } - cy_as_device_clear_setup_packet(dev_p) ; + cy_as_device_clear_setup_packet(dev_p); } static void my_usb_request_callback_usb_event(cy_as_device *dev_p, cy_as_ll_request_response *req_p) { - uint16_t ev ; - uint16_t val ; - cy_as_device_handle h = (cy_as_device_handle)dev_p ; + uint16_t ev; + uint16_t val; + cy_as_device_handle h = (cy_as_device_handle)dev_p; - ev = cy_as_ll_request_response__get_word(req_p, 0) ; + ev = cy_as_ll_request_response__get_word(req_p, 0); switch (ev) { case 0: /* Reserved */ cy_as_ll_send_status_response(dev_p, CY_RQT_USB_RQT_CONTEXT, - CY_AS_ERROR_INVALID_REQUEST, 0) ; - break ; + CY_AS_ERROR_INVALID_REQUEST, 0); + break; case 1: /* Reserved */ cy_as_ll_send_status_response(dev_p, CY_RQT_USB_RQT_CONTEXT, - CY_AS_ERROR_INVALID_REQUEST, 0) ; - break ; + CY_AS_ERROR_INVALID_REQUEST, 0); + break; case 2: /* USB Suspend */ - dev_p->usb_last_event = cy_as_event_usb_suspend ; + dev_p->usb_last_event = cy_as_event_usb_suspend; if (dev_p->usb_event_cb_ms) - dev_p->usb_event_cb_ms(h, cy_as_event_usb_suspend, 0) ; + dev_p->usb_event_cb_ms(h, cy_as_event_usb_suspend, 0); else if (dev_p->usb_event_cb) - dev_p->usb_event_cb(h, cy_as_event_usb_suspend, 0) ; + dev_p->usb_event_cb(h, cy_as_event_usb_suspend, 0); cy_as_ll_send_status_response(dev_p, - CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ; + CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0); break; case 3: /* USB Resume */ - dev_p->usb_last_event = cy_as_event_usb_resume ; + dev_p->usb_last_event = cy_as_event_usb_resume; if (dev_p->usb_event_cb_ms) - dev_p->usb_event_cb_ms(h, cy_as_event_usb_resume, 0) ; + dev_p->usb_event_cb_ms(h, cy_as_event_usb_resume, 0); else if (dev_p->usb_event_cb) - dev_p->usb_event_cb(h, cy_as_event_usb_resume, 0) ; + dev_p->usb_event_cb(h, cy_as_event_usb_resume, 0); cy_as_ll_send_status_response(dev_p, - CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ; - break ; + CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0); + break; case 4: /* USB Reset */ /* @@ -161,75 +161,75 @@ my_usb_request_callback_usb_event(cy_as_device *dev_p, * enumeration based requests. */ if (cy_as_device_is_ack_delayed(dev_p)) - cy_as_usb_reset_e_p0_state(dev_p) ; + cy_as_usb_reset_e_p0_state(dev_p); - dev_p->usb_last_event = cy_as_event_usb_reset ; + dev_p->usb_last_event = cy_as_event_usb_reset; if (dev_p->usb_event_cb_ms) - dev_p->usb_event_cb_ms(h, cy_as_event_usb_reset, 0) ; + dev_p->usb_event_cb_ms(h, cy_as_event_usb_reset, 0); else if (dev_p->usb_event_cb) - dev_p->usb_event_cb(h, cy_as_event_usb_reset, 0) ; + dev_p->usb_event_cb(h, cy_as_event_usb_reset, 0); cy_as_ll_send_status_response(dev_p, - CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ; - cy_as_device_clear_usb_high_speed(dev_p) ; - cy_as_usb_set_dma_sizes(dev_p) ; - dev_p->usb_max_tx_size = 0x40 ; - cy_as_dma_set_max_dma_size(dev_p, 0x06, 0x40) ; - break ; + CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0); + cy_as_device_clear_usb_high_speed(dev_p); + cy_as_usb_set_dma_sizes(dev_p); + dev_p->usb_max_tx_size = 0x40; + cy_as_dma_set_max_dma_size(dev_p, 0x06, 0x40); + break; case 5: /* USB Set Configuration */ /* The configuration to set */ - val = cy_as_ll_request_response__get_word(req_p, 1) ; - dev_p->usb_last_event = cy_as_event_usb_set_config ; + val = cy_as_ll_request_response__get_word(req_p, 1); + dev_p->usb_last_event = cy_as_event_usb_set_config; if (dev_p->usb_event_cb_ms) dev_p->usb_event_cb_ms(h, - cy_as_event_usb_set_config, &val) ; + cy_as_event_usb_set_config, &val); else if (dev_p->usb_event_cb) dev_p->usb_event_cb(h, - cy_as_event_usb_set_config, &val) ; + cy_as_event_usb_set_config, &val); cy_as_ll_send_status_response(dev_p, - CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ; - break ; + CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0); + break; case 6: /* USB Speed change */ /* Connect speed */ - val = cy_as_ll_request_response__get_word(req_p, 1) ; - dev_p->usb_last_event = cy_as_event_usb_speed_change ; + val = cy_as_ll_request_response__get_word(req_p, 1); + dev_p->usb_last_event = cy_as_event_usb_speed_change; if (dev_p->usb_event_cb_ms) dev_p->usb_event_cb_ms(h, - cy_as_event_usb_speed_change, &val) ; + cy_as_event_usb_speed_change, &val); else if (dev_p->usb_event_cb) dev_p->usb_event_cb(h, - cy_as_event_usb_speed_change, &val) ; + cy_as_event_usb_speed_change, &val); cy_as_ll_send_status_response(dev_p, - CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ; - cy_as_device_set_usb_high_speed(dev_p) ; - cy_as_usb_set_dma_sizes(dev_p) ; - dev_p->usb_max_tx_size = 0x200 ; - cy_as_dma_set_max_dma_size(dev_p, 0x06, 0x200) ; - break ; + CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0); + cy_as_device_set_usb_high_speed(dev_p); + cy_as_usb_set_dma_sizes(dev_p); + dev_p->usb_max_tx_size = 0x200; + cy_as_dma_set_max_dma_size(dev_p, 0x06, 0x200); + break; case 7: /* USB Clear Feature */ /* EP Number */ - val = cy_as_ll_request_response__get_word(req_p, 1) ; + val = cy_as_ll_request_response__get_word(req_p, 1); if (dev_p->usb_event_cb_ms) dev_p->usb_event_cb_ms(h, - cy_as_event_usb_clear_feature, &val) ; + cy_as_event_usb_clear_feature, &val); if (dev_p->usb_event_cb) dev_p->usb_event_cb(h, - cy_as_event_usb_clear_feature, &val) ; + cy_as_event_usb_clear_feature, &val); cy_as_ll_send_status_response(dev_p, - CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ; - break ; + CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0); + break; default: - cy_as_hal_print_message("invalid event type\n") ; + cy_as_hal_print_message("invalid event type\n"); cy_as_ll_send_data_response(dev_p, CY_RQT_USB_RQT_CONTEXT, - CY_RESP_USB_INVALID_EVENT, sizeof(ev), &ev) ; - break ; + CY_RESP_USB_INVALID_EVENT, sizeof(ev), &ev); + break; } } @@ -237,21 +237,21 @@ static void my_usb_request_callback_usb_data(cy_as_device *dev_p, cy_as_ll_request_response *req_p) { - cy_as_end_point_number_t ep ; - uint8_t type ; - uint16_t len ; - uint16_t val ; - cy_as_device_handle h = (cy_as_device_handle)dev_p ; + cy_as_end_point_number_t ep; + uint8_t type; + uint16_t len; + uint16_t val; + cy_as_device_handle h = (cy_as_device_handle)dev_p; - val = cy_as_ll_request_response__get_word(req_p, 0) ; - ep = (cy_as_end_point_number_t)((val >> 13) & 0x01) ; - len = (val & 0x1ff) ; + val = cy_as_ll_request_response__get_word(req_p, 0); + ep = (cy_as_end_point_number_t)((val >> 13) & 0x01); + len = (val & 0x1ff); - cy_as_hal_assert(len <= 64) ; + cy_as_hal_assert(len <= 64); cy_as_ll_request_response__unpack(req_p, - 1, len, dev_p->usb_ep_data) ; + 1, len, dev_p->usb_ep_data); - type = (uint8_t)((val >> 14) & 0x03) ; + type = (uint8_t)((val >> 14) & 0x03); if (type == 0) { if (cy_as_device_is_ack_delayed(dev_p)) { /* @@ -260,59 +260,59 @@ my_usb_request_callback_usb_data(cy_as_device *dev_p, * our state with respect to EP0 to be ready * to process the new packet. */ - cy_as_usb_reset_e_p0_state(dev_p) ; + cy_as_usb_reset_e_p0_state(dev_p); } if (len != 8) cy_as_ll_send_status_response(dev_p, CY_RQT_USB_RQT_CONTEXT, - CY_AS_ERROR_INVALID_REQUEST, 0) ; + CY_AS_ERROR_INVALID_REQUEST, 0); else { - cy_as_device_clear_ep0_stalled(dev_p) ; - cy_as_device_set_setup_packet(dev_p) ; + cy_as_device_clear_ep0_stalled(dev_p); + cy_as_device_set_setup_packet(dev_p); cy_as_ll_send_status_response(dev_p, CY_RQT_USB_RQT_CONTEXT, - CY_AS_ERROR_SUCCESS, 0) ; + CY_AS_ERROR_SUCCESS, 0); if (dev_p->usb_event_cb_ms) dev_p->usb_event_cb_ms(h, cy_as_event_usb_setup_packet, - dev_p->usb_ep_data) ; + dev_p->usb_ep_data); else dev_p->usb_event_cb(h, cy_as_event_usb_setup_packet, - dev_p->usb_ep_data) ; + dev_p->usb_ep_data); if ((!cy_as_device_is_ack_delayed(dev_p)) && (!cy_as_device_is_ep0_stalled(dev_p))) cy_as_usb_ack_setup_packet(h, - usb_ack_callback, 0) ; + usb_ack_callback, 0); } } else if (type == 2) { if (len != 0) cy_as_ll_send_status_response(dev_p, CY_RQT_USB_RQT_CONTEXT, - CY_AS_ERROR_INVALID_REQUEST, 0) ; + CY_AS_ERROR_INVALID_REQUEST, 0); else { if (dev_p->usb_event_cb_ms) dev_p->usb_event_cb_ms(h, - cy_as_event_usb_status_packet, 0) ; + cy_as_event_usb_status_packet, 0); else dev_p->usb_event_cb(h, - cy_as_event_usb_status_packet, 0) ; + cy_as_event_usb_status_packet, 0); cy_as_ll_send_status_response(dev_p, CY_RQT_USB_RQT_CONTEXT, - CY_AS_ERROR_SUCCESS, 0) ; + CY_AS_ERROR_SUCCESS, 0); } } else if (type == 1) { /* * we need to hand the data associated with these * endpoints to the DMA module. */ - cy_as_dma_received_data(dev_p, ep, len, dev_p->usb_ep_data) ; + cy_as_dma_received_data(dev_p, ep, len, dev_p->usb_ep_data); cy_as_ll_send_status_response(dev_p, - CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ; + CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0); } } @@ -320,79 +320,79 @@ static void my_usb_request_callback_inquiry(cy_as_device *dev_p, cy_as_ll_request_response *req_p) { - cy_as_usb_inquiry_data_dep cbdata ; - cy_as_usb_inquiry_data cbdata_ms ; - void *data ; - uint16_t val ; - cy_as_device_handle h = (cy_as_device_handle)dev_p ; - uint8_t def_inq_data[64] ; - uint8_t evpd ; - uint8_t codepage ; - cy_bool updated ; - uint16_t length ; + cy_as_usb_inquiry_data_dep cbdata; + cy_as_usb_inquiry_data cbdata_ms; + void *data; + uint16_t val; + cy_as_device_handle h = (cy_as_device_handle)dev_p; + uint8_t def_inq_data[64]; + uint8_t evpd; + uint8_t codepage; + cy_bool updated; + uint16_t length; - cy_as_bus_number_t bus ; - uint32_t device ; - cy_as_media_type media ; + cy_as_bus_number_t bus; + uint32_t device; + cy_as_media_type media; - val = cy_as_ll_request_response__get_word(req_p, 0) ; - bus = cy_as_storage_get_bus_from_address(val) ; - device = cy_as_storage_get_device_from_address(val) ; - media = cy_as_storage_get_media_from_address(val) ; + val = cy_as_ll_request_response__get_word(req_p, 0); + bus = cy_as_storage_get_bus_from_address(val); + device = cy_as_storage_get_device_from_address(val); + media = cy_as_storage_get_media_from_address(val); - val = cy_as_ll_request_response__get_word(req_p, 1) ; - evpd = (uint8_t)((val >> 8) & 0x01) ; - codepage = (uint8_t)(val & 0xff) ; + val = cy_as_ll_request_response__get_word(req_p, 1); + evpd = (uint8_t)((val >> 8) & 0x01); + codepage = (uint8_t)(val & 0xff); - length = cy_as_ll_request_response__get_word(req_p, 2) ; - data = (void *)def_inq_data ; + length = cy_as_ll_request_response__get_word(req_p, 2); + data = (void *)def_inq_data; - updated = cy_false ; + updated = cy_false; if (dev_p->usb_event_cb_ms) { - cbdata_ms.bus = bus ; - cbdata_ms.device = device ; - cbdata_ms.updated = updated ; - cbdata_ms.evpd = evpd ; - cbdata_ms.codepage = codepage ; - cbdata_ms.length = length ; - cbdata_ms.data = data ; - - cy_as_hal_assert(cbdata_ms.length <= sizeof(def_inq_data)) ; + cbdata_ms.bus = bus; + cbdata_ms.device = device; + cbdata_ms.updated = updated; + cbdata_ms.evpd = evpd; + cbdata_ms.codepage = codepage; + cbdata_ms.length = length; + cbdata_ms.data = data; + + cy_as_hal_assert(cbdata_ms.length <= sizeof(def_inq_data)); cy_as_ll_request_response__unpack(req_p, - 3, cbdata_ms.length, cbdata_ms.data) ; + 3, cbdata_ms.length, cbdata_ms.data); dev_p->usb_event_cb_ms(h, - cy_as_event_usb_inquiry_before, &cbdata_ms) ; + cy_as_event_usb_inquiry_before, &cbdata_ms); updated = cbdata_ms.updated; - data = cbdata_ms.data ; - length = cbdata_ms.length ; + data = cbdata_ms.data; + length = cbdata_ms.length; } else if (dev_p->usb_event_cb) { - cbdata.media = media ; - cbdata.updated = updated ; - cbdata.evpd = evpd ; - cbdata.codepage = codepage ; - cbdata.length = length ; - cbdata.data = data ; + cbdata.media = media; + cbdata.updated = updated; + cbdata.evpd = evpd; + cbdata.codepage = codepage; + cbdata.length = length; + cbdata.data = data; cy_as_hal_assert(cbdata.length <= - sizeof(def_inq_data)) ; + sizeof(def_inq_data)); cy_as_ll_request_response__unpack(req_p, 3, - cbdata.length, cbdata.data) ; + cbdata.length, cbdata.data); dev_p->usb_event_cb(h, - cy_as_event_usb_inquiry_before, &cbdata) ; + cy_as_event_usb_inquiry_before, &cbdata); - updated = cbdata.updated ; - data = cbdata.data ; - length = cbdata.length ; + updated = cbdata.updated; + data = cbdata.data; + length = cbdata.length; } if (updated && length > 192) cy_as_hal_print_message("an inquiry result from a " "cy_as_event_usb_inquiry_before event " - "was greater than 192 bytes.") ; + "was greater than 192 bytes."); /* Now send the reply with the data back * to the West Bridge device */ @@ -403,175 +403,175 @@ my_usb_request_callback_inquiry(cy_as_device *dev_p, */ cy_as_ll_send_data_response(dev_p, CY_RQT_USB_RQT_CONTEXT, - CY_RESP_INQUIRY_DATA, length, data) ; + CY_RESP_INQUIRY_DATA, length, data); } else { /* * the callback did not modify the data, just acknowledge * that we processed the request */ cy_as_ll_send_status_response(dev_p, - CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1) ; + CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1); } if (dev_p->usb_event_cb_ms) dev_p->usb_event_cb_ms(h, - cy_as_event_usb_inquiry_after, &cbdata_ms) ; + cy_as_event_usb_inquiry_after, &cbdata_ms); else if (dev_p->usb_event_cb) dev_p->usb_event_cb(h, - cy_as_event_usb_inquiry_after, &cbdata) ; + cy_as_event_usb_inquiry_after, &cbdata); } static void my_usb_request_callback_start_stop(cy_as_device *dev_p, cy_as_ll_request_response *req_p) { - cy_as_bus_number_t bus ; - cy_as_media_type media ; - uint32_t device ; - uint16_t val ; + cy_as_bus_number_t bus; + cy_as_media_type media; + uint32_t device; + uint16_t val; if (dev_p->usb_event_cb_ms || dev_p->usb_event_cb) { - cy_bool loej ; - cy_bool start ; - cy_as_device_handle h = (cy_as_device_handle)dev_p ; + cy_bool loej; + cy_bool start; + cy_as_device_handle h = (cy_as_device_handle)dev_p; - val = cy_as_ll_request_response__get_word(req_p, 0) ; - bus = cy_as_storage_get_bus_from_address(val) ; - device = cy_as_storage_get_device_from_address(val) ; - media = cy_as_storage_get_media_from_address(val) ; + val = cy_as_ll_request_response__get_word(req_p, 0); + bus = cy_as_storage_get_bus_from_address(val); + device = cy_as_storage_get_device_from_address(val); + media = cy_as_storage_get_media_from_address(val); - val = cy_as_ll_request_response__get_word(req_p, 1) ; - loej = (val & 0x02) ? cy_true : cy_false ; - start = (val & 0x01) ? cy_true : cy_false ; + val = cy_as_ll_request_response__get_word(req_p, 1); + loej = (val & 0x02) ? cy_true : cy_false; + start = (val & 0x01) ? cy_true : cy_false; if (dev_p->usb_event_cb_ms) { - cy_as_usb_start_stop_data cbdata_ms ; + cy_as_usb_start_stop_data cbdata_ms; - cbdata_ms.bus = bus ; - cbdata_ms.device = device ; - cbdata_ms.loej = loej ; - cbdata_ms.start = start ; + cbdata_ms.bus = bus; + cbdata_ms.device = device; + cbdata_ms.loej = loej; + cbdata_ms.start = start; dev_p->usb_event_cb_ms(h, - cy_as_event_usb_start_stop, &cbdata_ms) ; + cy_as_event_usb_start_stop, &cbdata_ms); } else if (dev_p->usb_event_cb) { - cy_as_usb_start_stop_data_dep cbdata ; + cy_as_usb_start_stop_data_dep cbdata; - cbdata.media = media ; - cbdata.loej = loej ; - cbdata.start = start ; + cbdata.media = media; + cbdata.loej = loej; + cbdata.start = start; dev_p->usb_event_cb(h, - cy_as_event_usb_start_stop, &cbdata) ; + cy_as_event_usb_start_stop, &cbdata); } } cy_as_ll_send_status_response(dev_p, - CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1) ; + CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1); } static void my_usb_request_callback_uknown_c_b_w(cy_as_device *dev_p, cy_as_ll_request_response *req_p) { - uint16_t val ; - cy_as_device_handle h = (cy_as_device_handle)dev_p ; - uint8_t buf[16] ; + uint16_t val; + cy_as_device_handle h = (cy_as_device_handle)dev_p; + uint8_t buf[16]; - uint8_t response[4] ; - uint16_t reqlen ; - void *request ; - uint8_t status ; - uint8_t key ; - uint8_t asc ; - uint8_t ascq ; + uint8_t response[4]; + uint16_t reqlen; + void *request; + uint8_t status; + uint8_t key; + uint8_t asc; + uint8_t ascq; - val = cy_as_ll_request_response__get_word(req_p, 0) ; + val = cy_as_ll_request_response__get_word(req_p, 0); /* Failed by default */ - status = 1 ; + status = 1; /* Invalid command */ - key = 0x05 ; + key = 0x05; /* Invalid command */ - asc = 0x20 ; + asc = 0x20; /* Invalid command */ - ascq = 0x00 ; - reqlen = cy_as_ll_request_response__get_word(req_p, 1) ; - request = buf ; + ascq = 0x00; + reqlen = cy_as_ll_request_response__get_word(req_p, 1); + request = buf; - cy_as_hal_assert(reqlen <= sizeof(buf)) ; - cy_as_ll_request_response__unpack(req_p, 2, reqlen, request) ; + cy_as_hal_assert(reqlen <= sizeof(buf)); + cy_as_ll_request_response__unpack(req_p, 2, reqlen, request); if (dev_p->usb_event_cb_ms) { - cy_as_usb_unknown_command_data cbdata_ms ; - cbdata_ms.bus = cy_as_storage_get_bus_from_address(val) ; + cy_as_usb_unknown_command_data cbdata_ms; + cbdata_ms.bus = cy_as_storage_get_bus_from_address(val); cbdata_ms.device = - cy_as_storage_get_device_from_address(val) ; - cbdata_ms.reqlen = reqlen ; - cbdata_ms.request = request ; - cbdata_ms.status = status ; - cbdata_ms.key = key ; - cbdata_ms.asc = asc ; - cbdata_ms.ascq = ascq ; + cy_as_storage_get_device_from_address(val); + cbdata_ms.reqlen = reqlen; + cbdata_ms.request = request; + cbdata_ms.status = status; + cbdata_ms.key = key; + cbdata_ms.asc = asc; + cbdata_ms.ascq = ascq; dev_p->usb_event_cb_ms(h, - cy_as_event_usb_unknown_storage, &cbdata_ms) ; - status = cbdata_ms.status ; - key = cbdata_ms.key ; - asc = cbdata_ms.asc ; - ascq = cbdata_ms.ascq ; + cy_as_event_usb_unknown_storage, &cbdata_ms); + status = cbdata_ms.status; + key = cbdata_ms.key; + asc = cbdata_ms.asc; + ascq = cbdata_ms.ascq; } else if (dev_p->usb_event_cb) { - cy_as_usb_unknown_command_data_dep cbdata ; + cy_as_usb_unknown_command_data_dep cbdata; cbdata.media = - cy_as_storage_get_media_from_address(val) ; - cbdata.reqlen = reqlen ; - cbdata.request = request ; - cbdata.status = status ; - cbdata.key = key ; - cbdata.asc = asc ; - cbdata.ascq = ascq ; + cy_as_storage_get_media_from_address(val); + cbdata.reqlen = reqlen; + cbdata.request = request; + cbdata.status = status; + cbdata.key = key; + cbdata.asc = asc; + cbdata.ascq = ascq; dev_p->usb_event_cb(h, - cy_as_event_usb_unknown_storage, &cbdata) ; - status = cbdata.status ; - key = cbdata.key ; - asc = cbdata.asc ; - ascq = cbdata.ascq ; + cy_as_event_usb_unknown_storage, &cbdata); + status = cbdata.status; + key = cbdata.key; + asc = cbdata.asc; + ascq = cbdata.ascq; } - response[0] = status ; - response[1] = key ; - response[2] = asc ; - response[3] = ascq ; + response[0] = status; + response[1] = key; + response[2] = asc; + response[3] = ascq; cy_as_ll_send_data_response(dev_p, CY_RQT_USB_RQT_CONTEXT, - CY_RESP_UNKNOWN_SCSI_COMMAND, sizeof(response), response) ; + CY_RESP_UNKNOWN_SCSI_COMMAND, sizeof(response), response); } static void my_usb_request_callback_m_s_c_progress(cy_as_device *dev_p, cy_as_ll_request_response *req_p) { - uint16_t val1, val2 ; - cy_as_device_handle h = (cy_as_device_handle)dev_p ; + uint16_t val1, val2; + cy_as_device_handle h = (cy_as_device_handle)dev_p; if ((dev_p->usb_event_cb) || (dev_p->usb_event_cb_ms)) { - cy_as_m_s_c_progress_data cbdata ; + cy_as_m_s_c_progress_data cbdata; - val1 = cy_as_ll_request_response__get_word(req_p, 0) ; - val2 = cy_as_ll_request_response__get_word(req_p, 1) ; - cbdata.wr_count = (uint32_t)((val1 << 16) | val2) ; + val1 = cy_as_ll_request_response__get_word(req_p, 0); + val2 = cy_as_ll_request_response__get_word(req_p, 1); + cbdata.wr_count = (uint32_t)((val1 << 16) | val2); - val1 = cy_as_ll_request_response__get_word(req_p, 2) ; - val2 = cy_as_ll_request_response__get_word(req_p, 3) ; - cbdata.rd_count = (uint32_t)((val1 << 16) | val2) ; + val1 = cy_as_ll_request_response__get_word(req_p, 2); + val2 = cy_as_ll_request_response__get_word(req_p, 3); + cbdata.rd_count = (uint32_t)((val1 << 16) | val2); if (dev_p->usb_event_cb) dev_p->usb_event_cb(h, - cy_as_event_usb_m_s_c_progress, &cbdata) ; + cy_as_event_usb_m_s_c_progress, &cbdata); else dev_p->usb_event_cb_ms(h, - cy_as_event_usb_m_s_c_progress, &cbdata) ; + cy_as_event_usb_m_s_c_progress, &cbdata); } cy_as_ll_send_status_response(dev_p, - CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ; + CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0); } /* @@ -586,50 +586,50 @@ my_usb_request_callback(cy_as_device *dev_p, uint8_t context, cy_as_ll_request_response *resp_p, cy_as_return_status_t ret) { - uint16_t val ; - uint8_t code = cy_as_ll_request_response__get_code(req_p) ; + uint16_t val; + uint8_t code = cy_as_ll_request_response__get_code(req_p); - (void)resp_p ; - (void)context ; - (void)ret ; + (void)resp_p; + (void)context; + (void)ret; switch (code) { case CY_RQT_USB_EVENT: - my_usb_request_callback_usb_event(dev_p, req_p) ; - break ; + my_usb_request_callback_usb_event(dev_p, req_p); + break; case CY_RQT_USB_EP_DATA: - dev_p->usb_last_event = cy_as_event_usb_setup_packet ; - my_usb_request_callback_usb_data(dev_p, req_p) ; - break ; + dev_p->usb_last_event = cy_as_event_usb_setup_packet; + my_usb_request_callback_usb_data(dev_p, req_p); + break; case CY_RQT_SCSI_INQUIRY_COMMAND: - dev_p->usb_last_event = cy_as_event_usb_inquiry_after ; - my_usb_request_callback_inquiry(dev_p, req_p) ; - break ; + dev_p->usb_last_event = cy_as_event_usb_inquiry_after; + my_usb_request_callback_inquiry(dev_p, req_p); + break; case CY_RQT_SCSI_START_STOP_COMMAND: - dev_p->usb_last_event = cy_as_event_usb_start_stop ; - my_usb_request_callback_start_stop(dev_p, req_p) ; - break ; + dev_p->usb_last_event = cy_as_event_usb_start_stop; + my_usb_request_callback_start_stop(dev_p, req_p); + break; case CY_RQT_SCSI_UNKNOWN_COMMAND: - dev_p->usb_last_event = cy_as_event_usb_unknown_storage ; - my_usb_request_callback_uknown_c_b_w(dev_p, req_p) ; - break ; + dev_p->usb_last_event = cy_as_event_usb_unknown_storage; + my_usb_request_callback_uknown_c_b_w(dev_p, req_p); + break; case CY_RQT_USB_ACTIVITY_UPDATE: - dev_p->usb_last_event = cy_as_event_usb_m_s_c_progress ; - my_usb_request_callback_m_s_c_progress(dev_p, req_p) ; - break ; + dev_p->usb_last_event = cy_as_event_usb_m_s_c_progress; + my_usb_request_callback_m_s_c_progress(dev_p, req_p); + break; default: cy_as_hal_print_message("invalid request " - "received on USB context\n") ; - val = req_p->box0 ; + "received on USB context\n"); + val = req_p->box0; cy_as_ll_send_data_response(dev_p, CY_RQT_USB_RQT_CONTEXT, - CY_RESP_INVALID_REQUEST, sizeof(val), &val) ; - break ; + CY_RESP_INVALID_REQUEST, sizeof(val), &val); + break; } } @@ -640,39 +640,39 @@ my_handle_response_usb_start(cy_as_device *dev_p, cy_as_return_status_t ret) { if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; if (cy_as_ll_request_response__get_code(reply_p) != CY_RESP_SUCCESS_FAILURE) { - ret = CY_AS_ERROR_INVALID_RESPONSE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + goto destroy; } - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; /* * mark EP 0 and EP1 as 64 byte endpoints */ - cy_as_dma_set_max_dma_size(dev_p, 0, 64) ; - cy_as_dma_set_max_dma_size(dev_p, 1, 64) ; + cy_as_dma_set_max_dma_size(dev_p, 0, 64); + cy_as_dma_set_max_dma_size(dev_p, 1, 64); - dev_p->usb_count++ ; + dev_p->usb_count++; destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) { - cy_as_destroy_c_b_queue(dev_p->usb_func_cbs) ; + cy_as_destroy_c_b_queue(dev_p->usb_func_cbs); cy_as_ll_register_request_callback(dev_p, - CY_RQT_USB_RQT_CONTEXT, 0) ; + CY_RQT_USB_RQT_CONTEXT, 0); } - cy_as_device_clear_u_s_s_pending(dev_p) ; + cy_as_device_clear_u_s_s_pending(dev_p); - return ret ; + return ret; } @@ -691,125 +691,125 @@ cy_as_usb_start(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_ll_request_response *req_p, *reply_p ; - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; + cy_as_ll_request_response *req_p, *reply_p; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; - cy_as_device *dev_p ; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_start called") ; + cy_as_log_debug_message(6, "cy_as_usb_start called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; if (!cy_as_device_is_configured(dev_p)) - return CY_AS_ERROR_NOT_CONFIGURED ; + return CY_AS_ERROR_NOT_CONFIGURED; if (!cy_as_device_is_firmware_loaded(dev_p)) - return CY_AS_ERROR_NO_FIRMWARE ; + return CY_AS_ERROR_NO_FIRMWARE; if (cy_as_device_is_in_suspend_mode(dev_p)) - return CY_AS_ERROR_IN_SUSPEND ; + return CY_AS_ERROR_IN_SUSPEND; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; if (cy_as_device_is_u_s_s_pending(dev_p)) - return CY_AS_ERROR_STARTSTOP_PENDING ; + return CY_AS_ERROR_STARTSTOP_PENDING; - cy_as_device_set_u_s_s_pending(dev_p) ; + cy_as_device_set_u_s_s_pending(dev_p); if (dev_p->usb_count == 0) { /* * since we are just starting the stack, * mark USB as not connected to the remote host */ - cy_as_device_clear_usb_connected(dev_p) ; - dev_p->usb_phy_config = 0 ; + cy_as_device_clear_usb_connected(dev_p); + dev_p->usb_phy_config = 0; /* Queue for 1.0 Async Requests, kept for * backwards compatibility */ - dev_p->usb_func_cbs = cy_as_create_c_b_queue(CYAS_USB_FUNC_CB) ; + dev_p->usb_func_cbs = cy_as_create_c_b_queue(CYAS_USB_FUNC_CB); if (dev_p->usb_func_cbs == 0) { - cy_as_device_clear_u_s_s_pending(dev_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_device_clear_u_s_s_pending(dev_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } /* Reset the EP0 state */ - cy_as_usb_reset_e_p0_state(dev_p) ; + cy_as_usb_reset_e_p0_state(dev_p); /* * we register here becuase the start request may cause * events to occur before the response to the start request. */ cy_as_ll_register_request_callback(dev_p, - CY_RQT_USB_RQT_CONTEXT, my_usb_request_callback) ; + CY_RQT_USB_RQT_CONTEXT, my_usb_request_callback); /* Create the request to send to the West Bridge device */ req_p = cy_as_ll_create_request(dev_p, - CY_RQT_START_USB, CY_RQT_USB_RQT_CONTEXT, 0) ; + CY_RQT_START_USB, CY_RQT_USB_RQT_CONTEXT, 0); if (req_p == 0) { - cy_as_destroy_c_b_queue(dev_p->usb_func_cbs) ; - dev_p->usb_func_cbs = 0 ; - cy_as_device_clear_u_s_s_pending(dev_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_destroy_c_b_queue(dev_p->usb_func_cbs); + dev_p->usb_func_cbs = 0; + cy_as_device_clear_u_s_s_pending(dev_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } /* Reserve space for the reply, the reply data * will not exceed one word */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_destroy_c_b_queue(dev_p->usb_func_cbs) ; - dev_p->usb_func_cbs = 0 ; - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_device_clear_u_s_s_pending(dev_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_destroy_c_b_queue(dev_p->usb_func_cbs); + dev_p->usb_func_cbs = 0; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_device_clear_u_s_s_pending(dev_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { ret = cy_as_ll_send_request_wait_reply(dev_p, - req_p, reply_p) ; + req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; return my_handle_response_usb_start(dev_p, - req_p, reply_p, ret) ; + req_p, reply_p, ret); } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_START, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p, - cy_as_usb_func_callback) ; + cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); } else { - dev_p->usb_count++ ; + dev_p->usb_count++; if (cb) - cb(handle, ret, client, CY_FUNCT_CB_USB_START, 0) ; + cb(handle, ret, client, CY_FUNCT_CB_USB_START, 0); } - cy_as_device_clear_u_s_s_pending(dev_p) ; + cy_as_device_clear_u_s_s_pending(dev_p); - return ret ; + return ret; } void cy_as_usb_reset(cy_as_device *dev_p) { - int i ; + int i; - cy_as_device_clear_usb_connected(dev_p) ; + cy_as_device_clear_usb_connected(dev_p); - for (i = 0 ; i < sizeof(dev_p->usb_config) / - sizeof(dev_p->usb_config[0]) ; i++) { + for (i = 0; i < sizeof(dev_p->usb_config) / + sizeof(dev_p->usb_config[0]); i++) { /* * cancel all pending USB read/write operations, as it is * possible that the USB stack comes up in a different @@ -817,13 +817,13 @@ cy_as_usb_reset(cy_as_device *dev_p) */ if (cy_as_device_is_usb_async_pending(dev_p, i)) cy_as_usb_cancel_async(dev_p, - (cy_as_end_point_number_t)i) ; + (cy_as_end_point_number_t)i); - dev_p->usb_cb[i] = 0 ; - dev_p->usb_config[i].enabled = cy_false ; + dev_p->usb_cb[i] = 0; + dev_p->usb_config[i].enabled = cy_false; } - dev_p->usb_phy_config = 0 ; + dev_p->usb_phy_config = 0; } /* @@ -836,13 +836,13 @@ void cy_as_usb_cleanup(cy_as_device *dev_p) { if (dev_p->usb_count) { - cy_as_usb_reset_e_p0_state(dev_p) ; - cy_as_usb_reset(dev_p) ; + cy_as_usb_reset_e_p0_state(dev_p); + cy_as_usb_reset(dev_p); cy_as_hal_mem_set(dev_p->usb_config, 0, - sizeof(dev_p->usb_config)) ; - cy_as_destroy_c_b_queue(dev_p->usb_func_cbs) ; + sizeof(dev_p->usb_config)); + cy_as_destroy_c_b_queue(dev_p->usb_func_cbs); - dev_p->usb_count = 0 ; + dev_p->usb_count = 0; } } @@ -853,35 +853,35 @@ my_handle_response_usb_stop(cy_as_device *dev_p, cy_as_return_status_t ret) { if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; if (cy_as_ll_request_response__get_code(reply_p) != CY_RESP_SUCCESS_FAILURE) { - ret = CY_AS_ERROR_INVALID_RESPONSE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + goto destroy; } - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; /* * we sucessfully shutdown the stack, so * decrement to make the count zero. */ - cy_as_usb_cleanup(dev_p) ; + cy_as_usb_cleanup(dev_p); destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) cy_as_ll_register_request_callback(dev_p, - CY_RQT_USB_RQT_CONTEXT, 0) ; + CY_RQT_USB_RQT_CONTEXT, 0); - cy_as_device_clear_u_s_s_pending(dev_p) ; + cy_as_device_clear_u_s_s_pending(dev_p); - return ret ; + return ret; } /* @@ -895,87 +895,87 @@ cy_as_usb_stop(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_ll_request_response *req_p = 0, *reply_p = 0 ; - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; + cy_as_ll_request_response *req_p = 0, *reply_p = 0; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; - cy_as_device *dev_p ; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_stop called") ; + cy_as_log_debug_message(6, "cy_as_usb_stop called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_usb_connected(dev_p)) - return CY_AS_ERROR_USB_CONNECTED ; + return CY_AS_ERROR_USB_CONNECTED; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; if (cy_as_device_is_u_s_s_pending(dev_p)) - return CY_AS_ERROR_STARTSTOP_PENDING ; + return CY_AS_ERROR_STARTSTOP_PENDING; - cy_as_device_set_u_s_s_pending(dev_p) ; + cy_as_device_set_u_s_s_pending(dev_p); if (dev_p->usb_count == 1) { /* Create the request to send to the West Bridge device */ req_p = cy_as_ll_create_request(dev_p, CY_RQT_STOP_USB, - CY_RQT_USB_RQT_CONTEXT, 0) ; + CY_RQT_USB_RQT_CONTEXT, 0); if (req_p == 0) { - ret = CY_AS_ERROR_OUT_OF_MEMORY ; - goto destroy ; + ret = CY_AS_ERROR_OUT_OF_MEMORY; + goto destroy; } /* Reserve space for the reply, the reply data will not * exceed one word */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - ret = CY_AS_ERROR_OUT_OF_MEMORY ; - goto destroy ; + ret = CY_AS_ERROR_OUT_OF_MEMORY; + goto destroy; } if (cb == 0) { ret = cy_as_ll_send_request_wait_reply(dev_p, - req_p, reply_p) ; + req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; return my_handle_response_usb_stop(dev_p, - req_p, reply_p, ret) ; + req_p, reply_p, ret); } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_STOP, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p, - cy_as_usb_func_callback) ; + cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); } else if (dev_p->usb_count > 1) { /* * reset all LE_ps to inactive state, after cleaning * up any pending async read/write calls. */ - cy_as_usb_reset(dev_p) ; - dev_p->usb_count-- ; + cy_as_usb_reset(dev_p); + dev_p->usb_count--; if (cb) - cb(handle, ret, client, CY_FUNCT_CB_USB_STOP, 0) ; + cb(handle, ret, client, CY_FUNCT_CB_USB_STOP, 0); } - cy_as_device_clear_u_s_s_pending(dev_p) ; + cy_as_device_clear_u_s_s_pending(dev_p); - return ret ; + return ret; } /* @@ -986,23 +986,23 @@ cy_as_return_status_t cy_as_usb_register_callback(cy_as_device_handle handle, cy_as_usb_event_callback callback) { - cy_as_device *dev_p ; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_register_callback called") ; + cy_as_log_debug_message(6, "cy_as_usb_register_callback called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; if (!cy_as_device_is_configured(dev_p)) - return CY_AS_ERROR_NOT_CONFIGURED ; + return CY_AS_ERROR_NOT_CONFIGURED; if (!cy_as_device_is_firmware_loaded(dev_p)) - return CY_AS_ERROR_NO_FIRMWARE ; + return CY_AS_ERROR_NO_FIRMWARE; - dev_p->usb_event_cb = NULL ; - dev_p->usb_event_cb_ms = callback ; - return CY_AS_ERROR_SUCCESS ; + dev_p->usb_event_cb = NULL; + dev_p->usb_event_cb_ms = callback; + return CY_AS_ERROR_SUCCESS; } @@ -1011,18 +1011,18 @@ my_handle_response_no_data(cy_as_device *dev_p, cy_as_ll_request_response *req_p, cy_as_ll_request_response *reply_p) { - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; if (cy_as_ll_request_response__get_code(reply_p) != CY_RESP_SUCCESS_FAILURE) - ret = CY_AS_ERROR_INVALID_RESPONSE ; + ret = CY_AS_ERROR_INVALID_RESPONSE; else - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } static cy_as_return_status_t @@ -1032,23 +1032,23 @@ my_handle_response_connect(cy_as_device *dev_p, cy_as_return_status_t ret) { if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; if (cy_as_ll_request_response__get_code(reply_p) != CY_RESP_SUCCESS_FAILURE) { - ret = CY_AS_ERROR_INVALID_RESPONSE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + goto destroy; } - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); if (ret == CY_AS_ERROR_SUCCESS) - cy_as_device_set_usb_connected(dev_p) ; + cy_as_device_set_usb_connected(dev_p); destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } @@ -1065,64 +1065,64 @@ cy_as_usb_connect(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_ll_request_response *req_p , *reply_p ; - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; + cy_as_ll_request_response *req_p , *reply_p; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; - cy_as_device *dev_p ; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_connect called") ; + cy_as_log_debug_message(6, "cy_as_usb_connect called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; /* Create the request to send to the West Bridge device */ req_p = cy_as_ll_create_request(dev_p, - CY_RQT_SET_CONNECT_STATE, CY_RQT_USB_RQT_CONTEXT, 1) ; + CY_RQT_SET_CONNECT_STATE, CY_RQT_USB_RQT_CONTEXT, 1); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; /* 1 = Connect request */ - cy_as_ll_request_response__set_word(req_p, 0, 1) ; + cy_as_ll_request_response__set_word(req_p, 0, 1); /* Reserve space for the reply, the reply * data will not exceed one word */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { - ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p) ; + ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return my_handle_response_connect(dev_p, req_p, reply_p, ret) ; + return my_handle_response_connect(dev_p, req_p, reply_p, ret); } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_CONNECT, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p, - cy_as_usb_func_callback) ; + cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } static cy_as_return_status_t @@ -1132,23 +1132,23 @@ my_handle_response_disconnect(cy_as_device *dev_p, cy_as_return_status_t ret) { if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; if (cy_as_ll_request_response__get_code(reply_p) != CY_RESP_SUCCESS_FAILURE) { - ret = CY_AS_ERROR_INVALID_RESPONSE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + goto destroy; } - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); if (ret == CY_AS_ERROR_SUCCESS) - cy_as_device_clear_usb_connected(dev_p) ; + cy_as_device_clear_usb_connected(dev_p); destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } /* * This method forces a disconnect of the D+ and D- pins @@ -1161,66 +1161,66 @@ cy_as_usb_disconnect(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_ll_request_response *req_p , *reply_p ; - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; + cy_as_ll_request_response *req_p , *reply_p; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; - cy_as_device *dev_p ; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_disconnect called") ; + cy_as_log_debug_message(6, "cy_as_usb_disconnect called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; if (!cy_as_device_is_usb_connected(dev_p)) - return CY_AS_ERROR_USB_NOT_CONNECTED ; + return CY_AS_ERROR_USB_NOT_CONNECTED; /* Create the request to send to the West Bridge device */ req_p = cy_as_ll_create_request(dev_p, - CY_RQT_SET_CONNECT_STATE, CY_RQT_USB_RQT_CONTEXT, 1) ; + CY_RQT_SET_CONNECT_STATE, CY_RQT_USB_RQT_CONTEXT, 1); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; - cy_as_ll_request_response__set_word(req_p, 0, 0) ; + cy_as_ll_request_response__set_word(req_p, 0, 0); /* Reserve space for the reply, the reply * data will not exceed two bytes */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { - ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p) ; + ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; return my_handle_response_disconnect(dev_p, - req_p, reply_p, ret) ; + req_p, reply_p, ret); } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_DISCONNECT, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p, - cy_as_usb_func_callback) ; + cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } static cy_as_return_status_t @@ -1228,15 +1228,15 @@ my_handle_response_set_enum_config(cy_as_device *dev_p, cy_as_ll_request_response *req_p, cy_as_ll_request_response *reply_p) { - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; if (cy_as_ll_request_response__get_code(reply_p) != CY_RESP_SUCCESS_FAILURE) { - ret = CY_AS_ERROR_INVALID_RESPONSE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + goto destroy; } - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); if (ret == CY_AS_ERROR_SUCCESS) { /* @@ -1244,21 +1244,21 @@ my_handle_response_set_enum_config(cy_as_device *dev_p, * enumeration is going to happen on the P port * processor. now we must enable endpoint zero */ - cy_as_usb_end_point_config config ; + cy_as_usb_end_point_config config; - config.dir = cy_as_usb_in_out ; - config.type = cy_as_usb_control ; - config.enabled = cy_true ; + config.dir = cy_as_usb_in_out; + config.type = cy_as_usb_control; + config.enabled = cy_true; ret = cy_as_usb_set_end_point_config((cy_as_device_handle *) - dev_p, 0, &config) ; + dev_p, 0, &config); } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } /* @@ -1276,111 +1276,111 @@ my_usb_set_enum_config(cy_as_device *dev_p, cy_as_function_callback cb, uint32_t client) { - cy_as_ll_request_response *req_p , *reply_p ; - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; + cy_as_ll_request_response *req_p , *reply_p; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; - cy_as_log_debug_message(6, "cy_as_usb_set_enum_config called") ; + cy_as_log_debug_message(6, "cy_as_usb_set_enum_config called"); if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_usb_connected(dev_p)) - return CY_AS_ERROR_USB_CONNECTED ; + return CY_AS_ERROR_USB_CONNECTED; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; /* if we are using MTP firmware: */ if (dev_p->is_mtp_firmware == 1) { /* we cannot enumerate MSC */ if (mass_storage_interface != 0) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; if (bus_mask == 0) { if (mtp_interface != 0) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; } else if (bus_mask == 2) { /* enable EP 1 as it will be used */ cy_as_dma_enable_end_point(dev_p, 1, cy_true, - cy_as_direction_in) ; - dev_p->usb_config[1].enabled = cy_true ; - dev_p->usb_config[1].dir = cy_as_usb_in ; - dev_p->usb_config[1].type = cy_as_usb_int ; + cy_as_direction_in); + dev_p->usb_config[1].enabled = cy_true; + dev_p->usb_config[1].dir = cy_as_usb_in; + dev_p->usb_config[1].type = cy_as_usb_int; } else { - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; } /* if we are not using MTP firmware, we cannot enumerate MTP */ } else if (mtp_interface != 0) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; /* * if we are not enumerating mass storage, we should * not be providing an interface number. */ if (bus_mask == 0 && mass_storage_interface != 0) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; /* * if we are going to use mtp_interface, bus mask must be 2. */ if (mtp_interface != 0 && bus_mask != 2) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; /* Create the request to send to the West Bridge device */ req_p = cy_as_ll_create_request(dev_p, - CY_RQT_SET_USB_CONFIG, CY_RQT_USB_RQT_CONTEXT, 4) ; + CY_RQT_SET_USB_CONFIG, CY_RQT_USB_RQT_CONTEXT, 4); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; /* Marshal the structure */ cy_as_ll_request_response__set_word(req_p, 0, - (uint16_t)((media_mask << 8) | bus_mask)) ; + (uint16_t)((media_mask << 8) | bus_mask)); cy_as_ll_request_response__set_word(req_p, 1, - (uint16_t)use_antioch_enumeration) ; + (uint16_t)use_antioch_enumeration); cy_as_ll_request_response__set_word(req_p, 2, dev_p->is_mtp_firmware ? mtp_interface : - mass_storage_interface) ; + mass_storage_interface); cy_as_ll_request_response__set_word(req_p, 3, - (uint16_t)mass_storage_callbacks) ; + (uint16_t)mass_storage_callbacks); /* Reserve space for the reply, the reply * data will not exceed one word */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { - ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p) ; + ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; return my_handle_response_set_enum_config(dev_p, - req_p, reply_p) ; + req_p, reply_p); } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_SETENUMCONFIG, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p, - cy_as_usb_func_callback) ; + cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } /* @@ -1393,21 +1393,21 @@ cy_as_usb_set_enum_config(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_device *dev_p = (cy_as_device *)handle ; - uint8_t bus_mask, media_mask ; - uint32_t bus, device ; - cy_as_return_status_t ret ; + cy_as_device *dev_p = (cy_as_device *)handle; + uint8_t bus_mask, media_mask; + uint32_t bus, device; + cy_as_return_status_t ret; - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if ((cy_as_device_is_in_callback(dev_p)) && (cb != 0)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; /* Since we are mapping the media types to bus with NAND to 0 * and the rest to 1, and we are only allowing for enumerating @@ -1415,16 +1415,16 @@ cy_as_usb_set_enum_config(cy_as_device_handle handle, * positions where there a device is enabled and mark the bus * to be enumerated. */ - bus_mask = 0 ; - media_mask = 0 ; - media_mask = 0 ; + bus_mask = 0; + media_mask = 0; + media_mask = 0; for (bus = 0; bus < CY_AS_MAX_BUSES; bus++) { for (device = 0; device < CY_AS_MAX_STORAGE_DEVICES; device++) { if (config_p->devices_to_enumerate[bus][device] == cy_true) { - bus_mask |= (0x01 << bus) ; - media_mask |= dev_p->media_supported[bus] ; - media_mask |= dev_p->media_supported[bus] ; + bus_mask |= (0x01 << bus); + media_mask |= dev_p->media_supported[bus]; + media_mask |= dev_p->media_supported[bus]; } } } @@ -1436,7 +1436,7 @@ cy_as_usb_set_enum_config(cy_as_device_handle handle, config_p->mass_storage_callbacks, cb, client - ) ; + ); } @@ -1446,53 +1446,53 @@ my_handle_response_get_enum_config(cy_as_device *dev_p, cy_as_ll_request_response *reply_p, void *config_p) { - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; - uint16_t val ; - uint8_t bus_mask ; - uint32_t bus ; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; + uint16_t val; + uint8_t bus_mask; + uint32_t bus; if (cy_as_ll_request_response__get_code(reply_p) != CY_RESP_USB_CONFIG) { - ret = CY_AS_ERROR_INVALID_RESPONSE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + goto destroy; } /* Marshal the reply */ if (req_p->flags & CY_AS_REQUEST_RESPONSE_MS) { - uint32_t device ; + uint32_t device; cy_bool state; cy_as_usb_enum_control *ms_config_p = (cy_as_usb_enum_control *)config_p; bus_mask = (uint8_t) (cy_as_ll_request_response__get_word - (reply_p, 0) & 0xFF) ; + (reply_p, 0) & 0xFF); for (bus = 0; bus < CY_AS_MAX_BUSES; bus++) { if (bus_mask & (1 << bus)) - state = cy_true ; + state = cy_true; else - state = cy_false ; + state = cy_false; for (device = 0; device < CY_AS_MAX_STORAGE_DEVICES; device++) ms_config_p->devices_to_enumerate[bus][device] - = state ; + = state; } ms_config_p->antioch_enumeration = (cy_bool)cy_as_ll_request_response__get_word - (reply_p, 1) ; + (reply_p, 1); - val = cy_as_ll_request_response__get_word(reply_p, 2) ; + val = cy_as_ll_request_response__get_word(reply_p, 2); if (dev_p->is_mtp_firmware) { - ms_config_p->mass_storage_interface = 0 ; - ms_config_p->mtp_interface = (uint8_t)(val & 0xFF) ; + ms_config_p->mass_storage_interface = 0; + ms_config_p->mtp_interface = (uint8_t)(val & 0xFF); } else { ms_config_p->mass_storage_interface = - (uint8_t)(val & 0xFF) ; - ms_config_p->mtp_interface = 0 ; + (uint8_t)(val & 0xFF); + ms_config_p->mtp_interface = 0; } - ms_config_p->mass_storage_callbacks = (cy_bool)(val >> 8) ; + ms_config_p->mass_storage_callbacks = (cy_bool)(val >> 8); /* * firmware returns an invalid interface number for mass storage, @@ -1501,9 +1501,9 @@ my_handle_response_get_enum_config(cy_as_device *dev_p, */ if (bus_mask == 0) { if (dev_p->is_mtp_firmware) - ms_config_p->mtp_interface = 0 ; + ms_config_p->mtp_interface = 0; else - ms_config_p->mass_storage_interface = 0 ; + ms_config_p->mass_storage_interface = 0; } } else { cy_as_usb_enum_control_dep *ex_config_p = @@ -1511,13 +1511,13 @@ my_handle_response_get_enum_config(cy_as_device *dev_p, ex_config_p->enum_mass_storage = (uint8_t) ((cy_as_ll_request_response__get_word - (reply_p, 0) >> 8) & 0xFF) ; + (reply_p, 0) >> 8) & 0xFF); ex_config_p->antioch_enumeration = (cy_bool) - cy_as_ll_request_response__get_word(reply_p, 1) ; + cy_as_ll_request_response__get_word(reply_p, 1); - val = cy_as_ll_request_response__get_word(reply_p, 2) ; - ex_config_p->mass_storage_interface = (uint8_t)(val & 0xFF) ; - ex_config_p->mass_storage_callbacks = (cy_bool)(val >> 8) ; + val = cy_as_ll_request_response__get_word(reply_p, 2); + ex_config_p->mass_storage_interface = (uint8_t)(val & 0xFF); + ex_config_p->mass_storage_callbacks = (cy_bool)(val >> 8); /* * firmware returns an invalid interface number for mass @@ -1525,14 +1525,14 @@ my_handle_response_get_enum_config(cy_as_device *dev_p, * be converted to zero to match the input configuration. */ if (ex_config_p->enum_mass_storage == 0) - ex_config_p->mass_storage_interface = 0 ; + ex_config_p->mass_storage_interface = 0; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } /* @@ -1547,65 +1547,65 @@ my_usb_get_enum_config(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_ll_request_response *req_p , *reply_p ; - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; + cy_as_ll_request_response *req_p , *reply_p; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; - cy_as_device *dev_p ; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_get_enum_config called") ; + cy_as_log_debug_message(6, "cy_as_usb_get_enum_config called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; /* Create the request to send to the West Bridge device */ req_p = cy_as_ll_create_request(dev_p, - CY_RQT_GET_USB_CONFIG, CY_RQT_USB_RQT_CONTEXT, 0) ; + CY_RQT_GET_USB_CONFIG, CY_RQT_USB_RQT_CONTEXT, 0); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; /* Reserve space for the reply, the reply data * will not exceed two bytes */ - reply_p = cy_as_ll_create_response(dev_p, 3) ; + reply_p = cy_as_ll_create_response(dev_p, 3); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { - ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p) ; + ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; /* we need to know the type of request to * know how to manage the data */ req_p->flags |= req_flags; return my_handle_response_get_enum_config(dev_p, - req_p, reply_p, config_p) ; + req_p, reply_p, config_p); } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_GETENUMCONFIG, config_p, dev_p->func_cbs_usb, req_flags, req_p, reply_p, - cy_as_usb_func_callback) ; + cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } /* @@ -1637,74 +1637,74 @@ cy_as_usb_set_descriptor(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_ll_request_response *req_p , *reply_p ; - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; - uint16_t pktlen ; + cy_as_ll_request_response *req_p , *reply_p; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; + uint16_t pktlen; - cy_as_device *dev_p ; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_set_descriptor called") ; + cy_as_log_debug_message(6, "cy_as_usb_set_descriptor called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; if (length > CY_AS_MAX_USB_DESCRIPTOR_SIZE) - return CY_AS_ERROR_INVALID_DESCRIPTOR ; + return CY_AS_ERROR_INVALID_DESCRIPTOR; - pktlen = (uint16_t)length / 2 ; + pktlen = (uint16_t)length / 2; if (length % 2) - pktlen++ ; - pktlen += 2 ; /* 1 for type, 1 for length */ + pktlen++; + pktlen += 2; /* 1 for type, 1 for length */ /* Create the request to send to the West Bridge device */ req_p = cy_as_ll_create_request(dev_p, CY_RQT_SET_DESCRIPTOR, - CY_RQT_USB_RQT_CONTEXT, (uint16_t)pktlen) ; + CY_RQT_USB_RQT_CONTEXT, (uint16_t)pktlen); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; cy_as_ll_request_response__set_word(req_p, 0, - (uint16_t)((uint8_t)type | (index << 8))) ; + (uint16_t)((uint8_t)type | (index << 8))); cy_as_ll_request_response__set_word(req_p, 1, - (uint16_t)length) ; - cy_as_ll_request_response__pack(req_p, 2, length, desc_p) ; + (uint16_t)length); + cy_as_ll_request_response__pack(req_p, 2, length, desc_p); - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { - ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p) ; + ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return my_handle_response_no_data(dev_p, req_p, reply_p) ; + return my_handle_response_no_data(dev_p, req_p, reply_p); } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_SETDESCRIPTOR, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p, - cy_as_usb_func_callback) ; + cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } /* @@ -1716,61 +1716,61 @@ cy_as_usb_clear_descriptors(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_ll_request_response *req_p , *reply_p ; - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; + cy_as_ll_request_response *req_p , *reply_p; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; - cy_as_device *dev_p ; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_clear_descriptors called") ; + cy_as_log_debug_message(6, "cy_as_usb_clear_descriptors called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if ((cy_as_device_is_in_callback(dev_p)) && (cb == 0)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; /* Create the request to send to the West Bridge device */ req_p = cy_as_ll_create_request(dev_p, - CY_RQT_CLEAR_DESCRIPTORS, CY_RQT_USB_RQT_CONTEXT, 1) ; + CY_RQT_CLEAR_DESCRIPTORS, CY_RQT_USB_RQT_CONTEXT, 1); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { - ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p) ; + ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return my_handle_response_no_data(dev_p, req_p, reply_p) ; + return my_handle_response_no_data(dev_p, req_p, reply_p); } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_CLEARDESCRIPTORS, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p, - cy_as_usb_func_callback) ; + cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } static cy_as_return_status_t @@ -1779,34 +1779,34 @@ my_handle_response_get_descriptor(cy_as_device *dev_p, cy_as_ll_request_response *reply_p, cy_as_get_descriptor_data *data) { - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; - uint32_t retlen ; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; + uint32_t retlen; if (cy_as_ll_request_response__get_code(reply_p) == CY_RESP_SUCCESS_FAILURE) { - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; - goto destroy ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); + goto destroy; } else if (cy_as_ll_request_response__get_code(reply_p) != CY_RESP_USB_DESCRIPTOR) { - ret = CY_AS_ERROR_INVALID_RESPONSE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + goto destroy; } - retlen = cy_as_ll_request_response__get_word(reply_p, 0) ; + retlen = cy_as_ll_request_response__get_word(reply_p, 0); if (retlen > data->length) { - ret = CY_AS_ERROR_INVALID_SIZE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_SIZE; + goto destroy; } - ret = CY_AS_ERROR_SUCCESS ; + ret = CY_AS_ERROR_SUCCESS; cy_as_ll_request_response__unpack(reply_p, 1, - retlen, data->desc_p) ; + retlen, data->desc_p); destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } /* @@ -1820,96 +1820,96 @@ cy_as_usb_get_descriptor(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_return_status_t ret ; - cy_as_ll_request_response *req_p , *reply_p ; + cy_as_return_status_t ret; + cy_as_ll_request_response *req_p , *reply_p; - cy_as_device *dev_p ; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_get_descriptor called") ; + cy_as_log_debug_message(6, "cy_as_usb_get_descriptor called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; /* Create the request to send to the West Bridge device */ req_p = cy_as_ll_create_request(dev_p, - CY_RQT_GET_DESCRIPTOR, CY_RQT_USB_RQT_CONTEXT, 1) ; + CY_RQT_GET_DESCRIPTOR, CY_RQT_USB_RQT_CONTEXT, 1); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; cy_as_ll_request_response__set_word(req_p, 0, - (uint16_t)((uint8_t)type | (index << 8))) ; + (uint16_t)((uint8_t)type | (index << 8))); /* Add one for the length field */ reply_p = cy_as_ll_create_response(dev_p, - CY_AS_MAX_USB_DESCRIPTOR_SIZE + 1) ; + CY_AS_MAX_USB_DESCRIPTOR_SIZE + 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { ret = cy_as_ll_send_request_wait_reply( - dev_p, req_p, reply_p) ; + dev_p, req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; return my_handle_response_get_descriptor(dev_p, - req_p, reply_p, data) ; + req_p, reply_p, data); } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_GETDESCRIPTOR, data, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, - reply_p, cy_as_usb_func_callback) ; + reply_p, cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } cy_as_return_status_t cy_as_usb_set_physical_configuration(cy_as_device_handle handle, uint8_t config) { - cy_as_return_status_t ret ; - cy_as_device *dev_p ; + cy_as_return_status_t ret; + cy_as_device *dev_p; cy_as_log_debug_message(6, - "cy_as_usb_set_physical_configuration called") ; + "cy_as_usb_set_physical_configuration called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_usb_connected(dev_p)) - return CY_AS_ERROR_USB_CONNECTED ; + return CY_AS_ERROR_USB_CONNECTED; if (config < 1 || config > 12) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; - dev_p->usb_phy_config = config ; + dev_p->usb_phy_config = config; - return CY_AS_ERROR_SUCCESS ; + return CY_AS_ERROR_SUCCESS; } static cy_bool @@ -1928,9 +1928,9 @@ is_physical_valid(uint8_t config, cy_as_end_point_number_t ep) 0x0d, /* Config 10 - 1, 3, 4 */ 0x09, /* Config 11 - 1, 4 */ 0x01 /* Config 12 - 1 */ - } ; + }; - return (validmask[config - 1] & (1 << (ep - 1))) ? cy_true : cy_false ; + return (validmask[config - 1] & (1 << (ep - 1))) ? cy_true : cy_false; } /* @@ -1940,35 +1940,35 @@ cy_as_return_status_t cy_as_usb_set_end_point_config(cy_as_device_handle handle, cy_as_end_point_number_t ep, cy_as_usb_end_point_config *config_p) { - cy_as_return_status_t ret ; - cy_as_device *dev_p ; + cy_as_return_status_t ret; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_set_end_point_config called") ; + cy_as_log_debug_message(6, "cy_as_usb_set_end_point_config called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_usb_connected(dev_p)) - return CY_AS_ERROR_USB_CONNECTED ; + return CY_AS_ERROR_USB_CONNECTED; if (ep >= 16 || ep == 2 || ep == 4 || ep == 6 || ep == 8) - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; if (ep == 0) { /* Endpoint 0 must be 64 byte, dir IN/OUT, * and control type */ if (config_p->dir != cy_as_usb_in_out || config_p->type != cy_as_usb_control) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; } else if (ep == 1) { if ((dev_p->is_mtp_firmware == 1) && (dev_p->usb_config[1].enabled == cy_true)) { - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; } /* @@ -1977,15 +1977,15 @@ cy_as_usb_set_end_point_config(cy_as_device_handle handle, if ((config_p->type == cy_as_usb_control) || (config_p->type == cy_as_usb_iso) || (config_p->dir == cy_as_usb_in_out)) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; } else { if (config_p->dir == cy_as_usb_in_out || config_p->type == cy_as_usb_control) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; if (!is_physical_valid(dev_p->usb_phy_config, config_p->physical)) - return CY_AS_ERROR_INVALID_PHYSICAL_ENDPOINT ; + return CY_AS_ERROR_INVALID_PHYSICAL_ENDPOINT; /* * ISO endpoints must be on E_ps 3, 5, 7 or 9 as @@ -1994,25 +1994,25 @@ cy_as_usb_set_end_point_config(cy_as_device_handle handle, */ if (config_p->type == cy_as_usb_iso) { if (ep != 3 && ep != 5 && ep != 7 && ep != 9) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; if (ep == 3 && config_p->physical != 1) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; if (ep == 5 && config_p->physical != 2) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; if (ep == 7 && config_p->physical != 3) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; if (ep == 9 && config_p->physical != 4) - return CY_AS_ERROR_INVALID_CONFIGURATION ; + return CY_AS_ERROR_INVALID_CONFIGURATION; } } /* Store the configuration information until a * CyAsUsbCommitConfig is done */ - dev_p->usb_config[ep] = *config_p ; + dev_p->usb_config[ep] = *config_p; /* If the endpoint is enabled, enable DMA associated * with the endpoint */ @@ -2023,36 +2023,36 @@ cy_as_usb_set_end_point_config(cy_as_device_handle handle, */ cy_as_hal_assert((int)cy_as_usb_in == (int)cy_as_direction_in); cy_as_hal_assert((int)cy_as_usb_out == (int)cy_as_direction_out); - cy_as_hal_assert((int)cy_as_usb_in_out == (int)cy_as_direction_in_out) ; + cy_as_hal_assert((int)cy_as_usb_in_out == (int)cy_as_direction_in_out); return cy_as_dma_enable_end_point(dev_p, ep, - config_p->enabled, (cy_as_dma_direction)config_p->dir) ; + config_p->enabled, (cy_as_dma_direction)config_p->dir); } cy_as_return_status_t cy_as_usb_get_end_point_config(cy_as_device_handle handle, cy_as_end_point_number_t ep, cy_as_usb_end_point_config *config_p) { - cy_as_return_status_t ret ; + cy_as_return_status_t ret; - cy_as_device *dev_p ; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_get_end_point_config called") ; + cy_as_log_debug_message(6, "cy_as_usb_get_end_point_config called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (ep >= 16 || ep == 2 || ep == 4 || ep == 6 || ep == 8) - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; - *config_p = dev_p->usb_config[ep] ; + *config_p = dev_p->usb_config[ep]; - return CY_AS_ERROR_SUCCESS ; + return CY_AS_ERROR_SUCCESS; } /* @@ -2063,27 +2063,27 @@ cy_as_usb_commit_config(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - uint32_t i ; - cy_as_return_status_t ret ; - cy_as_ll_request_response *req_p , *reply_p ; - cy_as_device *dev_p ; - uint16_t data ; + uint32_t i; + cy_as_return_status_t ret; + cy_as_ll_request_response *req_p , *reply_p; + cy_as_device *dev_p; + uint16_t data; - cy_as_log_debug_message(6, "cy_as_usb_commit_config called") ; + cy_as_log_debug_message(6, "cy_as_usb_commit_config called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_usb_connected(dev_p)) - return CY_AS_ERROR_USB_CONNECTED ; + return CY_AS_ERROR_USB_CONNECTED; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; /* * this performs the mapping based on informatation that was @@ -2092,9 +2092,9 @@ cy_as_usb_commit_config(cy_as_device_handle handle, * setting the the 14 register values contained in usb_lepcfg * and usb_pepcfg */ - ret = cy_as_usb_map_logical2_physical(dev_p) ; + ret = cy_as_usb_map_logical2_physical(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; /* * now, package the information about the various logical and @@ -2102,17 +2102,17 @@ cy_as_usb_commit_config(cy_as_device_handle handle, * across to the west bridge device. */ req_p = cy_as_ll_create_request(dev_p, - CY_RQT_SET_USB_CONFIG_REGISTERS, CY_RQT_USB_RQT_CONTEXT, 8) ; + CY_RQT_SET_USB_CONFIG_REGISTERS, CY_RQT_USB_RQT_CONTEXT, 8); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; cy_as_hal_print_message("USB configuration: %d\n", - dev_p->usb_phy_config) ; + dev_p->usb_phy_config); cy_as_hal_print_message("EP1OUT: 0x%02x EP1IN: 0x%02x\n", - dev_p->usb_ep1cfg[0], dev_p->usb_ep1cfg[1]) ; + dev_p->usb_ep1cfg[0], dev_p->usb_ep1cfg[1]); cy_as_hal_print_message("PEP registers: 0x%02x 0x%02x 0x%02x 0x%02x\n", dev_p->usb_pepcfg[0], dev_p->usb_pepcfg[1], - dev_p->usb_pepcfg[2], dev_p->usb_pepcfg[3]) ; + dev_p->usb_pepcfg[2], dev_p->usb_pepcfg[3]); cy_as_hal_print_message("LEP registers: 0x%02x 0x%02x 0x%02x " "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n", @@ -2120,66 +2120,66 @@ cy_as_usb_commit_config(cy_as_device_handle handle, dev_p->usb_lepcfg[2], dev_p->usb_lepcfg[3], dev_p->usb_lepcfg[4], dev_p->usb_lepcfg[5], dev_p->usb_lepcfg[6], dev_p->usb_lepcfg[7], - dev_p->usb_lepcfg[8], dev_p->usb_lepcfg[9]) ; + dev_p->usb_lepcfg[8], dev_p->usb_lepcfg[9]); /* Write the EP1OUTCFG and EP1INCFG data in the first word. */ data = (uint16_t)((dev_p->usb_ep1cfg[0] << 8) | - dev_p->usb_ep1cfg[1]) ; - cy_as_ll_request_response__set_word(req_p, 0, data) ; + dev_p->usb_ep1cfg[1]); + cy_as_ll_request_response__set_word(req_p, 0, data); /* Write the PEP CFG data in the next 2 words */ - for (i = 0 ; i < 4 ; i += 2) { + for (i = 0; i < 4; i += 2) { data = (uint16_t)((dev_p->usb_pepcfg[i] << 8) | - dev_p->usb_pepcfg[i + 1]) ; + dev_p->usb_pepcfg[i + 1]); cy_as_ll_request_response__set_word(req_p, - 1 + i / 2, data) ; + 1 + i / 2, data); } /* Write the LEP CFG data in the next 5 words */ - for (i = 0 ; i < 10 ; i += 2) { + for (i = 0; i < 10; i += 2) { data = (uint16_t)((dev_p->usb_lepcfg[i] << 8) | - dev_p->usb_lepcfg[i + 1]) ; + dev_p->usb_lepcfg[i + 1]); cy_as_ll_request_response__set_word(req_p, - 3 + i / 2, data) ; + 3 + i / 2, data); } /* A single status word response type */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { ret = cy_as_ll_send_request_wait_reply(dev_p, - req_p, reply_p) ; + req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; ret = my_handle_response_no_data(dev_p, - req_p, reply_p) ; + req_p, reply_p); if (ret == CY_AS_ERROR_SUCCESS) - ret = cy_as_usb_setup_dma(dev_p) ; + ret = cy_as_usb_setup_dma(dev_p); - return ret ; + return ret; } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_COMMITCONFIG, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p, - cy_as_usb_func_callback) ; + cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } static void @@ -2187,11 +2187,11 @@ sync_request_callback(cy_as_device *dev_p, cy_as_end_point_number_t ep, void *buf_p, uint32_t size, cy_as_return_status_t err) { - (void)ep ; - (void)buf_p ; + (void)ep; + (void)buf_p; - dev_p->usb_error = err ; - dev_p->usb_actual_cnt = size ; + dev_p->usb_error = err; + dev_p->usb_actual_cnt = size; } static void @@ -2199,26 +2199,26 @@ async_read_request_callback(cy_as_device *dev_p, cy_as_end_point_number_t ep, void *buf_p, uint32_t size, cy_as_return_status_t err) { - cy_as_device_handle h ; + cy_as_device_handle h; cy_as_log_debug_message(6, - "async_read_request_callback called") ; + "async_read_request_callback called"); - h = (cy_as_device_handle)dev_p ; + h = (cy_as_device_handle)dev_p; if (ep == 0 && cy_as_device_is_ack_delayed(dev_p)) { - dev_p->usb_pending_buffer = buf_p ; - dev_p->usb_pending_size = size ; - dev_p->usb_error = err ; - cy_as_usb_ack_setup_packet(h, usb_ack_callback, 0) ; + dev_p->usb_pending_buffer = buf_p; + dev_p->usb_pending_size = size; + dev_p->usb_error = err; + cy_as_usb_ack_setup_packet(h, usb_ack_callback, 0); } else { - cy_as_usb_io_callback cb ; + cy_as_usb_io_callback cb; - cb = dev_p->usb_cb[ep] ; - dev_p->usb_cb[ep] = 0 ; - cy_as_device_clear_usb_async_pending(dev_p, ep) ; + cb = dev_p->usb_cb[ep]; + dev_p->usb_cb[ep] = 0; + cy_as_device_clear_usb_async_pending(dev_p, ep); if (cb) - cb(h, ep, size, buf_p, err) ; + cb(h, ep, size, buf_p, err); } } @@ -2227,29 +2227,29 @@ async_write_request_callback(cy_as_device *dev_p, cy_as_end_point_number_t ep, void *buf_p, uint32_t size, cy_as_return_status_t err) { - cy_as_device_handle h ; + cy_as_device_handle h; cy_as_log_debug_message(6, - "async_write_request_callback called") ; + "async_write_request_callback called"); - h = (cy_as_device_handle)dev_p ; + h = (cy_as_device_handle)dev_p; if (ep == 0 && cy_as_device_is_ack_delayed(dev_p)) { - dev_p->usb_pending_buffer = buf_p ; - dev_p->usb_pending_size = size ; - dev_p->usb_error = err ; + dev_p->usb_pending_buffer = buf_p; + dev_p->usb_pending_size = size; + dev_p->usb_error = err; /* The west bridge protocol generates ZLPs as required. */ - cy_as_usb_ack_setup_packet(h, usb_ack_callback, 0) ; + cy_as_usb_ack_setup_packet(h, usb_ack_callback, 0); } else { - cy_as_usb_io_callback cb ; + cy_as_usb_io_callback cb; - cb = dev_p->usb_cb[ep] ; - dev_p->usb_cb[ep] = 0 ; + cb = dev_p->usb_cb[ep]; + dev_p->usb_cb[ep] = 0; - cy_as_device_clear_usb_async_pending(dev_p, ep) ; + cy_as_device_clear_usb_async_pending(dev_p, ep); if (cb) - cb(h, ep, size, buf_p, err) ; + cb(h, ep, size, buf_p, err); } } @@ -2260,24 +2260,24 @@ my_turbo_rqt_callback(cy_as_device *dev_p, cy_as_ll_request_response *resp, cy_as_return_status_t stat) { - uint8_t code ; + uint8_t code; - (void)context ; - (void)stat ; + (void)context; + (void)stat; /* The Handlers are responsible for Deleting the rqt and resp when * they are finished */ - code = cy_as_ll_request_response__get_code(rqt) ; + code = cy_as_ll_request_response__get_code(rqt); switch (code) { case CY_RQT_TURBO_SWITCH_ENDPOINT: - cy_as_hal_assert(stat == CY_AS_ERROR_SUCCESS) ; - cy_as_ll_destroy_request(dev_p, rqt) ; - cy_as_ll_destroy_response(dev_p, resp) ; + cy_as_hal_assert(stat == CY_AS_ERROR_SUCCESS); + cy_as_ll_destroy_request(dev_p, rqt); + cy_as_ll_destroy_response(dev_p, resp); break; default: - cy_as_hal_assert(cy_false) ; - break ; + cy_as_hal_assert(cy_false); + break; } } @@ -2285,39 +2285,39 @@ my_turbo_rqt_callback(cy_as_device *dev_p, static cy_as_return_status_t my_send_turbo_switch(cy_as_device *dev_p, uint32_t size, cy_bool pktread) { - cy_as_return_status_t ret ; - cy_as_ll_request_response *req_p , *reply_p ; + cy_as_return_status_t ret; + cy_as_ll_request_response *req_p , *reply_p; /* Create the request to send to the West Bridge device */ req_p = cy_as_ll_create_request(dev_p, - CY_RQT_TURBO_SWITCH_ENDPOINT, CY_RQT_TUR_RQT_CONTEXT, 3) ; + CY_RQT_TURBO_SWITCH_ENDPOINT, CY_RQT_TUR_RQT_CONTEXT, 3); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; /* Reserve space for the reply, the reply data will * not exceed one word */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } cy_as_ll_request_response__set_word(req_p, 0, - (uint16_t)pktread) ; + (uint16_t)pktread); cy_as_ll_request_response__set_word(req_p, 1, - (uint16_t)((size >> 16) & 0xFFFF)) ; + (uint16_t)((size >> 16) & 0xFFFF)); cy_as_ll_request_response__set_word(req_p, 2, - (uint16_t)(size & 0xFFFF)) ; + (uint16_t)(size & 0xFFFF)); ret = cy_as_ll_send_request(dev_p, req_p, - reply_p, cy_false, my_turbo_rqt_callback) ; + reply_p, cy_false, my_turbo_rqt_callback); if (ret != CY_AS_ERROR_SUCCESS) { - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_request(dev_p, reply_p) ; - return ret ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_request(dev_p, reply_p); + return ret; } - return CY_AS_ERROR_SUCCESS ; + return CY_AS_ERROR_SUCCESS; } cy_as_return_status_t @@ -2325,62 +2325,62 @@ cy_as_usb_read_data(cy_as_device_handle handle, cy_as_end_point_number_t ep, cy_bool pktread, uint32_t dsize, uint32_t *dataread, void *data) { - cy_as_return_status_t ret ; - cy_as_device *dev_p ; + cy_as_return_status_t ret; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_read_data called") ; + cy_as_log_debug_message(6, "cy_as_usb_read_data called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; if (ep >= 16 || ep == 4 || ep == 6 || ep == 8) - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; /* EP2 is available for reading when MTP is active */ if (dev_p->mtp_count == 0 && ep == CY_AS_MTP_READ_ENDPOINT) - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; /* If the endpoint is disabled, we cannot * write data to the endpoint */ if (!dev_p->usb_config[ep].enabled) - return CY_AS_ERROR_ENDPOINT_DISABLED ; + return CY_AS_ERROR_ENDPOINT_DISABLED; if (dev_p->usb_config[ep].dir != cy_as_usb_out) - return CY_AS_ERROR_USB_BAD_DIRECTION ; + return CY_AS_ERROR_USB_BAD_DIRECTION; ret = cy_as_dma_queue_request(dev_p, ep, data, dsize, - pktread, cy_true, sync_request_callback) ; + pktread, cy_true, sync_request_callback); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (ep == CY_AS_MTP_READ_ENDPOINT) { - ret = my_send_turbo_switch(dev_p, dsize, pktread) ; + ret = my_send_turbo_switch(dev_p, dsize, pktread); if (ret != CY_AS_ERROR_SUCCESS) { - cy_as_dma_cancel(dev_p, ep, ret) ; - return ret ; + cy_as_dma_cancel(dev_p, ep, ret); + return ret; } - ret = cy_as_dma_drain_queue(dev_p, ep, cy_false) ; + ret = cy_as_dma_drain_queue(dev_p, ep, cy_false); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; } else { - ret = cy_as_dma_drain_queue(dev_p, ep, cy_true) ; + ret = cy_as_dma_drain_queue(dev_p, ep, cy_true); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; } - ret = dev_p->usb_error ; - *dataread = dev_p->usb_actual_cnt ; + ret = dev_p->usb_error; + *dataread = dev_p->usb_actual_cnt; - return ret ; + return ret; } cy_as_return_status_t @@ -2388,35 +2388,35 @@ cy_as_usb_read_data_async(cy_as_device_handle handle, cy_as_end_point_number_t ep, cy_bool pktread, uint32_t dsize, void *data, cy_as_usb_io_callback cb) { - cy_as_return_status_t ret ; - uint32_t mask ; - cy_as_device *dev_p ; + cy_as_return_status_t ret; + uint32_t mask; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_read_data_async called") ; + cy_as_log_debug_message(6, "cy_as_usb_read_data_async called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (ep >= 16 || ep == 4 || ep == 6 || ep == 8) - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; /* EP2 is available for reading when MTP is active */ if (dev_p->mtp_count == 0 && ep == CY_AS_MTP_READ_ENDPOINT) - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; /* If the endpoint is disabled, we cannot * write data to the endpoint */ if (!dev_p->usb_config[ep].enabled) - return CY_AS_ERROR_ENDPOINT_DISABLED ; + return CY_AS_ERROR_ENDPOINT_DISABLED; if (dev_p->usb_config[ep].dir != cy_as_usb_out && dev_p->usb_config[ep].dir != cy_as_usb_in_out) - return CY_AS_ERROR_USB_BAD_DIRECTION ; + return CY_AS_ERROR_USB_BAD_DIRECTION; /* * since async operations can be triggered by interrupt @@ -2424,153 +2424,153 @@ cy_as_usb_read_data_async(cy_as_device_handle handle, * operations going at one time and protect this test and * set operation from interrupts. */ - mask = cy_as_hal_disable_interrupts() ; + mask = cy_as_hal_disable_interrupts(); if (cy_as_device_is_usb_async_pending(dev_p, ep)) { - cy_as_hal_enable_interrupts(mask) ; - return CY_AS_ERROR_ASYNC_PENDING ; + cy_as_hal_enable_interrupts(mask); + return CY_AS_ERROR_ASYNC_PENDING; } - cy_as_device_set_usb_async_pending(dev_p, ep) ; + cy_as_device_set_usb_async_pending(dev_p, ep); /* * if this is for EP0, we set this bit to delay the * ACK response until after this read has completed. */ if (ep == 0) - cy_as_device_set_ack_delayed(dev_p) ; + cy_as_device_set_ack_delayed(dev_p); - cy_as_hal_enable_interrupts(mask) ; + cy_as_hal_enable_interrupts(mask); - cy_as_hal_assert(dev_p->usb_cb[ep] == 0) ; - dev_p->usb_cb[ep] = cb ; + cy_as_hal_assert(dev_p->usb_cb[ep] == 0); + dev_p->usb_cb[ep] = cb; ret = cy_as_dma_queue_request(dev_p, ep, data, dsize, - pktread, cy_true, async_read_request_callback) ; + pktread, cy_true, async_read_request_callback); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (ep == CY_AS_MTP_READ_ENDPOINT) { - ret = my_send_turbo_switch(dev_p, dsize, pktread) ; + ret = my_send_turbo_switch(dev_p, dsize, pktread); if (ret != CY_AS_ERROR_SUCCESS) { - cy_as_dma_cancel(dev_p, ep, ret) ; - return ret ; + cy_as_dma_cancel(dev_p, ep, ret); + return ret; } } else { /* Kick start the queue if it is not running */ - cy_as_dma_kick_start(dev_p, ep) ; + cy_as_dma_kick_start(dev_p, ep); } - return ret ; + return ret; } cy_as_return_status_t cy_as_usb_write_data(cy_as_device_handle handle, cy_as_end_point_number_t ep, uint32_t dsize, void *data) { - cy_as_return_status_t ret ; - cy_as_device *dev_p ; + cy_as_return_status_t ret; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_write_data called") ; + cy_as_log_debug_message(6, "cy_as_usb_write_data called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; if (ep >= 16 || ep == 2 || ep == 4 || ep == 8) - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; /* EP6 is available for writing when MTP is active */ if (dev_p->mtp_count == 0 && ep == CY_AS_MTP_WRITE_ENDPOINT) - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; /* If the endpoint is disabled, we cannot * write data to the endpoint */ if (!dev_p->usb_config[ep].enabled) - return CY_AS_ERROR_ENDPOINT_DISABLED ; + return CY_AS_ERROR_ENDPOINT_DISABLED; if (dev_p->usb_config[ep].dir != cy_as_usb_in && dev_p->usb_config[ep].dir != cy_as_usb_in_out) - return CY_AS_ERROR_USB_BAD_DIRECTION ; + return CY_AS_ERROR_USB_BAD_DIRECTION; /* Write on Turbo endpoint */ if (ep == CY_AS_MTP_WRITE_ENDPOINT) { - cy_as_ll_request_response *req_p, *reply_p ; + cy_as_ll_request_response *req_p, *reply_p; req_p = cy_as_ll_create_request(dev_p, CY_RQT_TURBO_SEND_RESP_DATA_TO_HOST, - CY_RQT_TUR_RQT_CONTEXT, 3) ; + CY_RQT_TUR_RQT_CONTEXT, 3); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; cy_as_ll_request_response__set_word(req_p, - 0, 0x0006) ; /* EP number to use. */ + 0, 0x0006); /* EP number to use. */ cy_as_ll_request_response__set_word(req_p, - 1, (uint16_t)((dsize >> 16) & 0xFFFF)) ; + 1, (uint16_t)((dsize >> 16) & 0xFFFF)); cy_as_ll_request_response__set_word(req_p, - 2, (uint16_t)(dsize & 0xFFFF)) ; + 2, (uint16_t)(dsize & 0xFFFF)); /* Reserve space for the reply, the reply data * will not exceed one word */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (dsize) { ret = cy_as_dma_queue_request(dev_p, ep, data, dsize, cy_false, - cy_false, sync_request_callback) ; + cy_false, sync_request_callback); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; } - ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p) ; + ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p); if (ret == CY_AS_ERROR_SUCCESS) { if (cy_as_ll_request_response__get_code(reply_p) != CY_RESP_SUCCESS_FAILURE) - ret = CY_AS_ERROR_INVALID_RESPONSE ; + ret = CY_AS_ERROR_INVALID_RESPONSE; else ret = cy_as_ll_request_response__get_word (reply_p, 0); } - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) { if (dsize) - cy_as_dma_cancel(dev_p, ep, ret) ; - return ret ; + cy_as_dma_cancel(dev_p, ep, ret); + return ret; } /* If this is a zero-byte write, firmware will * handle it. there is no need to do any work here. */ if (!dsize) - return CY_AS_ERROR_SUCCESS ; + return CY_AS_ERROR_SUCCESS; } else { ret = cy_as_dma_queue_request(dev_p, ep, data, dsize, - cy_false, cy_false, sync_request_callback) ; + cy_false, cy_false, sync_request_callback); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; } if (ep != CY_AS_MTP_WRITE_ENDPOINT) - ret = cy_as_dma_drain_queue(dev_p, ep, cy_true) ; + ret = cy_as_dma_drain_queue(dev_p, ep, cy_true); else - ret = cy_as_dma_drain_queue(dev_p, ep, cy_false) ; + ret = cy_as_dma_drain_queue(dev_p, ep, cy_false); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; - ret = dev_p->usb_error ; - return ret ; + ret = dev_p->usb_error; + return ret; } static void @@ -2581,43 +2581,43 @@ mtp_write_callback( cy_as_ll_request_response *resp, cy_as_return_status_t ret) { - cy_as_usb_io_callback cb ; - cy_as_device_handle h = (cy_as_device_handle)dev_p ; + cy_as_usb_io_callback cb; + cy_as_device_handle h = (cy_as_device_handle)dev_p; - cy_as_hal_assert(context == CY_RQT_TUR_RQT_CONTEXT) ; + cy_as_hal_assert(context == CY_RQT_TUR_RQT_CONTEXT); if (ret == CY_AS_ERROR_SUCCESS) { if (cy_as_ll_request_response__get_code(resp) != CY_RESP_SUCCESS_FAILURE) - ret = CY_AS_ERROR_INVALID_RESPONSE ; + ret = CY_AS_ERROR_INVALID_RESPONSE; else - ret = cy_as_ll_request_response__get_word(resp, 0) ; + ret = cy_as_ll_request_response__get_word(resp, 0); } /* If this was a zero byte transfer request, we can * call the callback from here. */ if ((cy_as_ll_request_response__get_word(rqt, 1) == 0) && (cy_as_ll_request_response__get_word(rqt, 2) == 0)) { - cb = dev_p->usb_cb[CY_AS_MTP_WRITE_ENDPOINT] ; - dev_p->usb_cb[CY_AS_MTP_WRITE_ENDPOINT] = 0 ; + cb = dev_p->usb_cb[CY_AS_MTP_WRITE_ENDPOINT]; + dev_p->usb_cb[CY_AS_MTP_WRITE_ENDPOINT] = 0; cy_as_device_clear_usb_async_pending(dev_p, - CY_AS_MTP_WRITE_ENDPOINT) ; + CY_AS_MTP_WRITE_ENDPOINT); if (cb) - cb(h, CY_AS_MTP_WRITE_ENDPOINT, 0, 0, ret) ; + cb(h, CY_AS_MTP_WRITE_ENDPOINT, 0, 0, ret); - goto destroy ; + goto destroy; } if (ret != CY_AS_ERROR_SUCCESS) { /* Firmware failed the request. Cancel the DMA transfer. */ - cy_as_dma_cancel(dev_p, 0x06, CY_AS_ERROR_CANCELED) ; - dev_p->usb_cb[0x06] = 0 ; - cy_as_device_clear_usb_async_pending(dev_p, 0x06) ; + cy_as_dma_cancel(dev_p, 0x06, CY_AS_ERROR_CANCELED); + dev_p->usb_cb[0x06] = 0; + cy_as_device_clear_usb_async_pending(dev_p, 0x06); } destroy: - cy_as_ll_destroy_response(dev_p, resp) ; - cy_as_ll_destroy_request(dev_p, rqt) ; + cy_as_ll_destroy_response(dev_p, resp); + cy_as_ll_destroy_request(dev_p, rqt); } cy_as_return_status_t @@ -2625,35 +2625,35 @@ cy_as_usb_write_data_async(cy_as_device_handle handle, cy_as_end_point_number_t ep, uint32_t dsize, void *data, cy_bool spacket, cy_as_usb_io_callback cb) { - uint32_t mask ; - cy_as_return_status_t ret ; - cy_as_device *dev_p ; + uint32_t mask; + cy_as_return_status_t ret; + cy_as_device *dev_p; - cy_as_log_debug_message(6, "cy_as_usb_write_data_async called") ; + cy_as_log_debug_message(6, "cy_as_usb_write_data_async called"); - dev_p = (cy_as_device *)handle ; + dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (ep >= 16 || ep == 2 || ep == 4 || ep == 8) - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; /* EP6 is available for writing when MTP is active */ if (dev_p->mtp_count == 0 && ep == CY_AS_MTP_WRITE_ENDPOINT) - return CY_AS_ERROR_INVALID_ENDPOINT ; + return CY_AS_ERROR_INVALID_ENDPOINT; /* If the endpoint is disabled, we cannot * write data to the endpoint */ if (!dev_p->usb_config[ep].enabled) - return CY_AS_ERROR_ENDPOINT_DISABLED ; + return CY_AS_ERROR_ENDPOINT_DISABLED; if (dev_p->usb_config[ep].dir != cy_as_usb_in && dev_p->usb_config[ep].dir != cy_as_usb_in_out) - return CY_AS_ERROR_USB_BAD_DIRECTION ; + return CY_AS_ERROR_USB_BAD_DIRECTION; /* * since async operations can be triggered by interrupt @@ -2661,81 +2661,81 @@ cy_as_usb_write_data_async(cy_as_device_handle handle, * async operations going at one time and * protect this test and set operation from interrupts. */ - mask = cy_as_hal_disable_interrupts() ; + mask = cy_as_hal_disable_interrupts(); if (cy_as_device_is_usb_async_pending(dev_p, ep)) { - cy_as_hal_enable_interrupts(mask) ; - return CY_AS_ERROR_ASYNC_PENDING ; + cy_as_hal_enable_interrupts(mask); + return CY_AS_ERROR_ASYNC_PENDING; } - cy_as_device_set_usb_async_pending(dev_p, ep) ; + cy_as_device_set_usb_async_pending(dev_p, ep); if (ep == 0) - cy_as_device_set_ack_delayed(dev_p) ; + cy_as_device_set_ack_delayed(dev_p); - cy_as_hal_enable_interrupts(mask) ; + cy_as_hal_enable_interrupts(mask); - cy_as_hal_assert(dev_p->usb_cb[ep] == 0) ; - dev_p->usb_cb[ep] = cb ; - dev_p->usb_spacket[ep] = spacket ; + cy_as_hal_assert(dev_p->usb_cb[ep] == 0); + dev_p->usb_cb[ep] = cb; + dev_p->usb_spacket[ep] = spacket; /* Write on Turbo endpoint */ if (ep == CY_AS_MTP_WRITE_ENDPOINT) { - cy_as_ll_request_response *req_p, *reply_p ; + cy_as_ll_request_response *req_p, *reply_p; req_p = cy_as_ll_create_request(dev_p, CY_RQT_TURBO_SEND_RESP_DATA_TO_HOST, - CY_RQT_TUR_RQT_CONTEXT, 3) ; + CY_RQT_TUR_RQT_CONTEXT, 3); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; cy_as_ll_request_response__set_word(req_p, 0, - 0x0006) ; /* EP number to use. */ + 0x0006); /* EP number to use. */ cy_as_ll_request_response__set_word(req_p, 1, - (uint16_t)((dsize >> 16) & 0xFFFF)) ; + (uint16_t)((dsize >> 16) & 0xFFFF)); cy_as_ll_request_response__set_word(req_p, 2, - (uint16_t)(dsize & 0xFFFF)) ; + (uint16_t)(dsize & 0xFFFF)); /* Reserve space for the reply, the reply data * will not exceed one word */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (dsize) { ret = cy_as_dma_queue_request(dev_p, ep, data, dsize, cy_false, cy_false, - async_write_request_callback) ; + async_write_request_callback); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; } ret = cy_as_ll_send_request(dev_p, req_p, reply_p, - cy_false, mtp_write_callback) ; + cy_false, mtp_write_callback); if (ret != CY_AS_ERROR_SUCCESS) { if (dsize) - cy_as_dma_cancel(dev_p, ep, ret) ; - return ret ; + cy_as_dma_cancel(dev_p, ep, ret); + return ret; } /* Firmware will handle a zero byte transfer * without any DMA transfers. */ if (!dsize) - return CY_AS_ERROR_SUCCESS ; + return CY_AS_ERROR_SUCCESS; } else { ret = cy_as_dma_queue_request(dev_p, ep, data, dsize, - cy_false, cy_false, async_write_request_callback) ; + cy_false, cy_false, async_write_request_callback); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; } /* Kick start the queue if it is not running */ if (ep != CY_AS_MTP_WRITE_ENDPOINT) - cy_as_dma_kick_start(dev_p, ep) ; + cy_as_dma_kick_start(dev_p, ep); - return CY_AS_ERROR_SUCCESS ; + return CY_AS_ERROR_SUCCESS; } static void @@ -2746,25 +2746,25 @@ my_usb_cancel_async_callback( cy_as_ll_request_response *resp, cy_as_return_status_t ret) { - uint8_t ep ; - (void)context ; + uint8_t ep; + (void)context; - ep = (uint8_t)cy_as_ll_request_response__get_word(rqt, 0) ; + ep = (uint8_t)cy_as_ll_request_response__get_word(rqt, 0); if (ret == CY_AS_ERROR_SUCCESS) { if (cy_as_ll_request_response__get_code(resp) != CY_RESP_SUCCESS_FAILURE) - ret = CY_AS_ERROR_INVALID_RESPONSE ; + ret = CY_AS_ERROR_INVALID_RESPONSE; else - ret = cy_as_ll_request_response__get_word(resp, 0) ; + ret = cy_as_ll_request_response__get_word(resp, 0); } - cy_as_ll_destroy_request(dev_p, rqt) ; - cy_as_ll_destroy_response(dev_p, resp) ; + cy_as_ll_destroy_request(dev_p, rqt); + cy_as_ll_destroy_response(dev_p, resp); if (ret == CY_AS_ERROR_SUCCESS) { - cy_as_dma_cancel(dev_p, ep, CY_AS_ERROR_CANCELED) ; - dev_p->usb_cb[ep] = 0 ; - cy_as_device_clear_usb_async_pending(dev_p, ep) ; + cy_as_dma_cancel(dev_p, ep, CY_AS_ERROR_CANCELED); + dev_p->usb_cb[ep] = 0; + cy_as_device_clear_usb_async_pending(dev_p, ep); } } @@ -2772,61 +2772,61 @@ cy_as_return_status_t cy_as_usb_cancel_async(cy_as_device_handle handle, cy_as_end_point_number_t ep) { - cy_as_return_status_t ret ; - cy_as_ll_request_response *req_p, *reply_p ; + cy_as_return_status_t ret; + cy_as_ll_request_response *req_p, *reply_p; - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; ep &= 0x7F; /* Remove the direction bit. */ if (!cy_as_device_is_usb_async_pending(dev_p, ep)) return CY_AS_ERROR_ASYNC_NOT_PENDING; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_suspend_mode(dev_p)) - return CY_AS_ERROR_IN_SUSPEND ; + return CY_AS_ERROR_IN_SUSPEND; if ((ep == CY_AS_MTP_WRITE_ENDPOINT) || (ep == CY_AS_MTP_READ_ENDPOINT)) { /* Need firmware support for the cancel operation. */ req_p = cy_as_ll_create_request(dev_p, CY_RQT_CANCEL_ASYNC_TRANSFER, - CY_RQT_TUR_RQT_CONTEXT, 1) ; + CY_RQT_TUR_RQT_CONTEXT, 1); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } cy_as_ll_request_response__set_word(req_p, 0, - (uint16_t)ep) ; + (uint16_t)ep); ret = cy_as_ll_send_request(dev_p, req_p, reply_p, - cy_false, my_usb_cancel_async_callback) ; + cy_false, my_usb_cancel_async_callback); if (ret != CY_AS_ERROR_SUCCESS) { - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; - return ret ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); + return ret; } } else { - ret = cy_as_dma_cancel(dev_p, ep, CY_AS_ERROR_CANCELED) ; + ret = cy_as_dma_cancel(dev_p, ep, CY_AS_ERROR_CANCELED); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; - dev_p->usb_cb[ep] = 0 ; - cy_as_device_clear_usb_async_pending(dev_p, ep) ; + dev_p->usb_cb[ep] = 0; + cy_as_device_clear_usb_async_pending(dev_p, ep); } - return CY_AS_ERROR_SUCCESS ; + return CY_AS_ERROR_SUCCESS; } static void @@ -2838,25 +2838,25 @@ cy_as_usb_ack_callback( cy_as_return_status_t ret) { cy_as_func_c_b_node *node = (cy_as_func_c_b_node *) - dev_p->func_cbs_usb->head_p ; + dev_p->func_cbs_usb->head_p; - (void)context ; + (void)context; if (ret == CY_AS_ERROR_SUCCESS) { if (cy_as_ll_request_response__get_code(resp) != CY_RESP_SUCCESS_FAILURE) - ret = CY_AS_ERROR_INVALID_RESPONSE ; + ret = CY_AS_ERROR_INVALID_RESPONSE; else - ret = cy_as_ll_request_response__get_word(resp, 0) ; + ret = cy_as_ll_request_response__get_word(resp, 0); } node->cb_p((cy_as_device_handle)dev_p, ret, - node->client_data, node->data_type, node->data) ; - cy_as_remove_c_b_node(dev_p->func_cbs_usb) ; + node->client_data, node->data_type, node->data); + cy_as_remove_c_b_node(dev_p->func_cbs_usb); - cy_as_ll_destroy_request(dev_p, rqt) ; - cy_as_ll_destroy_response(dev_p, resp) ; - cy_as_device_clear_ack_delayed(dev_p) ; + cy_as_ll_destroy_request(dev_p, rqt); + cy_as_ll_destroy_response(dev_p, resp); + cy_as_device_clear_ack_delayed(dev_p); } static cy_as_return_status_t @@ -2864,51 +2864,51 @@ cy_as_usb_ack_setup_packet(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_return_status_t ret ; - cy_as_ll_request_response *req_p ; - cy_as_ll_request_response *reply_p ; - cy_as_func_c_b_node *cbnode ; + cy_as_return_status_t ret; + cy_as_ll_request_response *req_p; + cy_as_ll_request_response *reply_p; + cy_as_func_c_b_node *cbnode; - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p) && cb == 0) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; - cy_as_hal_assert(cb != 0) ; + cy_as_hal_assert(cb != 0); cbnode = cy_as_create_func_c_b_node(cb, client); if (cbnode == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; req_p = cy_as_ll_create_request(dev_p, 0, - CY_RQT_USB_RQT_CONTEXT, 2) ; + CY_RQT_USB_RQT_CONTEXT, 2); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } cy_as_ll_init_request(req_p, CY_RQT_ACK_SETUP_PACKET, - CY_RQT_USB_RQT_CONTEXT, 1) ; - cy_as_ll_init_response(reply_p, 1) ; + CY_RQT_USB_RQT_CONTEXT, 1); + cy_as_ll_init_response(reply_p, 1); - req_p->flags |= CY_AS_REQUEST_RESPONSE_EX ; + req_p->flags |= CY_AS_REQUEST_RESPONSE_EX; - cy_as_insert_c_b_node(dev_p->func_cbs_usb, cbnode) ; + cy_as_insert_c_b_node(dev_p->func_cbs_usb, cbnode); ret = cy_as_ll_send_request(dev_p, req_p, reply_p, - cy_false, cy_as_usb_ack_callback) ; + cy_false, cy_as_usb_ack_callback); - return ret ; + return ret; } /* @@ -2921,18 +2921,18 @@ cy_as_usb_flush_logical_e_p( cy_as_device *dev_p, uint16_t ep) { - uint16_t addr, val, count ; + uint16_t addr, val, count; - addr = CY_AS_MEM_P0_EP2_DMA_REG + ep - 2 ; - val = cy_as_hal_read_register(dev_p->tag, addr) ; + addr = CY_AS_MEM_P0_EP2_DMA_REG + ep - 2; + val = cy_as_hal_read_register(dev_p->tag, addr); while (val) { - count = ((val & 0xFFF) + 1) / 2 ; + count = ((val & 0xFFF) + 1) / 2; while (count--) - val = cy_as_hal_read_register(dev_p->tag, ep) ; + val = cy_as_hal_read_register(dev_p->tag, ep); - cy_as_hal_write_register(dev_p->tag, addr, 0) ; - val = cy_as_hal_read_register(dev_p->tag, addr) ; + cy_as_hal_write_register(dev_p->tag, addr, 0); + val = cy_as_hal_read_register(dev_p->tag, addr); } } @@ -2945,111 +2945,111 @@ cy_as_usb_nak_stall_request(cy_as_device_handle handle, cy_as_function_callback fcb, uint32_t client) { - cy_as_return_status_t ret ; - cy_as_ll_request_response *req_p , *reply_p ; - uint16_t data ; + cy_as_return_status_t ret; + cy_as_ll_request_response *req_p , *reply_p; + uint16_t data; - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; if (cb) - cy_as_hal_assert(fcb == 0) ; + cy_as_hal_assert(fcb == 0); if (fcb) - cy_as_hal_assert(cb == 0) ; + cy_as_hal_assert(cb == 0); - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p) && cb == 0 && fcb == 0) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; req_p = cy_as_ll_create_request(dev_p, - request, CY_RQT_USB_RQT_CONTEXT, 2) ; + request, CY_RQT_USB_RQT_CONTEXT, 2); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; /* A single status word response type */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } /* Set the endpoint */ - data = (uint8_t)ep ; - cy_as_ll_request_response__set_word(req_p, 0, data) ; + data = (uint8_t)ep; + cy_as_ll_request_response__set_word(req_p, 0, data); /* Set stall state to stalled */ - cy_as_ll_request_response__set_word(req_p, 1, (uint8_t)state) ; + cy_as_ll_request_response__set_word(req_p, 1, (uint8_t)state); if (cb || fcb) { - void *cbnode ; - cy_as_c_b_queue *queue ; + void *cbnode; + cy_as_c_b_queue *queue; if (cb) { - cbnode = cy_as_create_usb_func_c_b_node(cb, client) ; - queue = dev_p->usb_func_cbs ; + cbnode = cy_as_create_usb_func_c_b_node(cb, client); + queue = dev_p->usb_func_cbs; } else { - cbnode = cy_as_create_func_c_b_node(fcb, client) ; - queue = dev_p->func_cbs_usb ; - req_p->flags |= CY_AS_REQUEST_RESPONSE_EX ; + cbnode = cy_as_create_func_c_b_node(fcb, client); + queue = dev_p->func_cbs_usb; + req_p->flags |= CY_AS_REQUEST_RESPONSE_EX; } if (cbnode == 0) { - ret = CY_AS_ERROR_OUT_OF_MEMORY ; - goto destroy ; + ret = CY_AS_ERROR_OUT_OF_MEMORY; + goto destroy; } else - cy_as_insert_c_b_node(queue, cbnode) ; + cy_as_insert_c_b_node(queue, cbnode); if (cy_as_device_is_setup_packet(dev_p)) { /* No Ack is needed on a stall request on EP0 */ if ((state == cy_true) && (ep == 0)) { - cy_as_device_set_ep0_stalled(dev_p) ; + cy_as_device_set_ep0_stalled(dev_p); } else { - cy_as_device_set_ack_delayed(dev_p) ; + cy_as_device_set_ack_delayed(dev_p); req_p->flags |= - CY_AS_REQUEST_RESPONSE_DELAY_ACK ; + CY_AS_REQUEST_RESPONSE_DELAY_ACK; } } ret = cy_as_ll_send_request(dev_p, req_p, - reply_p, cy_false, cy_as_usb_func_callback) ; + reply_p, cy_false, cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) { if (req_p->flags & CY_AS_REQUEST_RESPONSE_DELAY_ACK) - cy_as_device_rem_ack_delayed(dev_p) ; - cy_as_remove_c_b_tail_node(queue) ; + cy_as_device_rem_ack_delayed(dev_p); + cy_as_remove_c_b_tail_node(queue); - goto destroy ; + goto destroy; } } else { ret = cy_as_ll_send_request_wait_reply(dev_p, - req_p, reply_p) ; + req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; if (cy_as_ll_request_response__get_code(reply_p) != CY_RESP_SUCCESS_FAILURE) { - ret = CY_AS_ERROR_INVALID_RESPONSE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + goto destroy; } - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); if ((ret == CY_AS_ERROR_SUCCESS) && (request == CY_RQT_STALL_ENDPOINT)) { if ((ep > 1) && (state != 0) && (dev_p->usb_config[ep].dir == cy_as_usb_out)) - cy_as_usb_flush_logical_e_p(dev_p, ep) ; + cy_as_usb_flush_logical_e_p(dev_p, ep); } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); } - return ret ; + return ret; } static cy_as_return_status_t @@ -3058,26 +3058,26 @@ my_handle_response_get_stall(cy_as_device *dev_p, cy_as_ll_request_response *reply_p, cy_bool *state_p) { - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; - uint8_t code = cy_as_ll_request_response__get_code(reply_p) ; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; + uint8_t code = cy_as_ll_request_response__get_code(reply_p); if (code == CY_RESP_SUCCESS_FAILURE) { - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; - goto destroy ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); + goto destroy; } else if (code != CY_RESP_ENDPOINT_STALL) { - ret = CY_AS_ERROR_INVALID_RESPONSE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + goto destroy; } - *state_p = (cy_bool)cy_as_ll_request_response__get_word(reply_p, 0) ; - ret = CY_AS_ERROR_SUCCESS ; + *state_p = (cy_bool)cy_as_ll_request_response__get_word(reply_p, 0); + ret = CY_AS_ERROR_SUCCESS; destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } static cy_as_return_status_t @@ -3086,26 +3086,26 @@ my_handle_response_get_nak(cy_as_device *dev_p, cy_as_ll_request_response *reply_p, cy_bool *state_p) { - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; - uint8_t code = cy_as_ll_request_response__get_code(reply_p) ; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; + uint8_t code = cy_as_ll_request_response__get_code(reply_p); if (code == CY_RESP_SUCCESS_FAILURE) { - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; - goto destroy ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); + goto destroy; } else if (code != CY_RESP_ENDPOINT_NAK) { - ret = CY_AS_ERROR_INVALID_RESPONSE ; - goto destroy ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + goto destroy; } - *state_p = (cy_bool)cy_as_ll_request_response__get_word(reply_p, 0) ; - ret = CY_AS_ERROR_SUCCESS ; + *state_p = (cy_bool)cy_as_ll_request_response__get_word(reply_p, 0); + ret = CY_AS_ERROR_SUCCESS; destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } static cy_as_return_status_t @@ -3117,76 +3117,76 @@ cy_as_usb_get_nak_stall(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_return_status_t ret ; - cy_as_ll_request_response *req_p , *reply_p ; - uint16_t data ; + cy_as_return_status_t ret; + cy_as_ll_request_response *req_p , *reply_p; + uint16_t data; - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; - (void)response ; + (void)response; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p) && !cb) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; req_p = cy_as_ll_create_request(dev_p, request, - CY_RQT_USB_RQT_CONTEXT, 1) ; + CY_RQT_USB_RQT_CONTEXT, 1); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; /* Set the endpoint */ - data = (uint8_t)ep ; - cy_as_ll_request_response__set_word(req_p, 0, (uint16_t)ep) ; + data = (uint8_t)ep; + cy_as_ll_request_response__set_word(req_p, 0, (uint16_t)ep); /* A single status word response type */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { ret = cy_as_ll_send_request_wait_reply(dev_p, - req_p, reply_p) ; + req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; if (request == CY_RQT_GET_STALL) return my_handle_response_get_stall(dev_p, - req_p, reply_p, state_p) ; + req_p, reply_p, state_p); else return my_handle_response_get_nak(dev_p, - req_p, reply_p, state_p) ; + req_p, reply_p, state_p); } else { - cy_as_funct_c_b_type type ; + cy_as_funct_c_b_type type; if (request == CY_RQT_GET_STALL) - type = CY_FUNCT_CB_USB_GETSTALL ; + type = CY_FUNCT_CB_USB_GETSTALL; else - type = CY_FUNCT_CB_USB_GETNAK ; + type = CY_FUNCT_CB_USB_GETNAK; ret = cy_as_misc_send_request(dev_p, cb, client, type, state_p, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, - req_p, reply_p, cy_as_usb_func_callback) ; + req_p, reply_p, cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; - return ret ; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } cy_as_return_status_t @@ -3195,23 +3195,23 @@ cy_as_usb_set_nak(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; /* * we send the firmware the EP# with the appropriate direction * bit, regardless of what the user gave us. */ - ep &= 0x0f ; + ep &= 0x0f; if (dev_p->usb_config[ep].dir == cy_as_usb_in) - ep |= 0x80 ; + ep |= 0x80; if (dev_p->mtp_count > 0) - return CY_AS_ERROR_NOT_VALID_IN_MTP ; + return CY_AS_ERROR_NOT_VALID_IN_MTP; return cy_as_usb_nak_stall_request(handle, ep, - CY_RQT_ENDPOINT_SET_NAK, cy_true, 0, cb, client) ; + CY_RQT_ENDPOINT_SET_NAK, cy_true, 0, cb, client); } @@ -3221,23 +3221,23 @@ cy_as_usb_clear_nak(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; /* * we send the firmware the EP# with the appropriate * direction bit, regardless of what the user gave us. */ - ep &= 0x0f ; + ep &= 0x0f; if (dev_p->usb_config[ep].dir == cy_as_usb_in) - ep |= 0x80 ; + ep |= 0x80; if (dev_p->mtp_count > 0) - return CY_AS_ERROR_NOT_VALID_IN_MTP ; + return CY_AS_ERROR_NOT_VALID_IN_MTP; return cy_as_usb_nak_stall_request(handle, ep, - CY_RQT_ENDPOINT_SET_NAK, cy_false, 0, cb, client) ; + CY_RQT_ENDPOINT_SET_NAK, cy_false, 0, cb, client); } cy_as_return_status_t @@ -3247,24 +3247,24 @@ cy_as_usb_get_nak(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; /* * we send the firmware the EP# with the appropriate * direction bit, regardless of what the user gave us. */ - ep &= 0x0f ; + ep &= 0x0f; if (dev_p->usb_config[ep].dir == cy_as_usb_in) - ep |= 0x80 ; + ep |= 0x80; if (dev_p->mtp_count > 0) - return CY_AS_ERROR_NOT_VALID_IN_MTP ; + return CY_AS_ERROR_NOT_VALID_IN_MTP; return cy_as_usb_get_nak_stall(handle, ep, CY_RQT_GET_ENDPOINT_NAK, CY_RESP_ENDPOINT_NAK, - nak_p, cb, client) ; + nak_p, cb, client); } @@ -3274,23 +3274,23 @@ cy_as_usb_set_stall(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; /* * we send the firmware the EP# with the appropriate * direction bit, regardless of what the user gave us. */ - ep &= 0x0f ; + ep &= 0x0f; if (dev_p->usb_config[ep].dir == cy_as_usb_in) - ep |= 0x80 ; + ep |= 0x80; if (dev_p->mtp_turbo_active) - return CY_AS_ERROR_NOT_VALID_DURING_MTP ; + return CY_AS_ERROR_NOT_VALID_DURING_MTP; return cy_as_usb_nak_stall_request(handle, ep, - CY_RQT_STALL_ENDPOINT, cy_true, 0, cb, client) ; + CY_RQT_STALL_ENDPOINT, cy_true, 0, cb, client); } cy_as_return_status_t @@ -3299,23 +3299,23 @@ cy_as_usb_clear_stall(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; /* * we send the firmware the EP# with the appropriate * direction bit, regardless of what the user gave us. */ - ep &= 0x0f ; + ep &= 0x0f; if (dev_p->usb_config[ep].dir == cy_as_usb_in) - ep |= 0x80 ; + ep |= 0x80; if (dev_p->mtp_turbo_active) - return CY_AS_ERROR_NOT_VALID_DURING_MTP ; + return CY_AS_ERROR_NOT_VALID_DURING_MTP; return cy_as_usb_nak_stall_request(handle, ep, - CY_RQT_STALL_ENDPOINT, cy_false, 0, cb, client) ; + CY_RQT_STALL_ENDPOINT, cy_false, 0, cb, client); } cy_as_return_status_t @@ -3325,23 +3325,23 @@ cy_as_usb_get_stall(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; /* * we send the firmware the EP# with the appropriate * direction bit, regardless of what the user gave us. */ - ep &= 0x0f ; + ep &= 0x0f; if (dev_p->usb_config[ep].dir == cy_as_usb_in) - ep |= 0x80 ; + ep |= 0x80; if (dev_p->mtp_turbo_active) - return CY_AS_ERROR_NOT_VALID_DURING_MTP ; + return CY_AS_ERROR_NOT_VALID_DURING_MTP; return cy_as_usb_get_nak_stall(handle, ep, - CY_RQT_GET_STALL, CY_RESP_ENDPOINT_STALL, stall_p, cb, client) ; + CY_RQT_GET_STALL, CY_RESP_ENDPOINT_STALL, stall_p, cb, client); } cy_as_return_status_t @@ -3349,62 +3349,62 @@ cy_as_usb_signal_remote_wakeup(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_return_status_t ret ; - cy_as_ll_request_response *req_p , *reply_p ; + cy_as_return_status_t ret; + cy_as_ll_request_response *req_p , *reply_p; - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if (cy_as_device_is_in_callback(dev_p)) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; if (dev_p->usb_last_event != cy_as_event_usb_suspend) - return CY_AS_ERROR_NOT_IN_SUSPEND ; + return CY_AS_ERROR_NOT_IN_SUSPEND; req_p = cy_as_ll_create_request(dev_p, - CY_RQT_USB_REMOTE_WAKEUP, CY_RQT_USB_RQT_CONTEXT, 0) ; + CY_RQT_USB_REMOTE_WAKEUP, CY_RQT_USB_RQT_CONTEXT, 0); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; /* A single status word response type */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } if (cb == 0) { - ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p) ; + ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; if (cy_as_ll_request_response__get_code(reply_p) == CY_RESP_SUCCESS_FAILURE) - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); else - ret = CY_AS_ERROR_INVALID_RESPONSE ; + ret = CY_AS_ERROR_INVALID_RESPONSE; } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_SIGNALREMOTEWAKEUP, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, - reply_p, cy_as_usb_func_callback) ; + reply_p, cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; - return ret ; + goto destroy; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } cy_as_return_status_t @@ -3414,74 +3414,74 @@ cy_as_usb_set_m_s_report_threshold(cy_as_device_handle handle, cy_as_function_callback cb, uint32_t client) { - cy_as_return_status_t ret ; - cy_as_ll_request_response *req_p , *reply_p ; + cy_as_return_status_t ret; + cy_as_ll_request_response *req_p , *reply_p; - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; if ((cb == 0) && (cy_as_device_is_in_callback(dev_p))) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; /* Check if the firmware version supports this feature. */ if ((dev_p->media_supported[0]) && (dev_p->media_supported[0] == (1 << cy_as_media_nand))) - return CY_AS_ERROR_NOT_SUPPORTED ; + return CY_AS_ERROR_NOT_SUPPORTED; req_p = cy_as_ll_create_request(dev_p, CY_RQT_USB_STORAGE_MONITOR, - CY_RQT_USB_RQT_CONTEXT, 4) ; + CY_RQT_USB_RQT_CONTEXT, 4); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; /* A single status word response type */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } /* Set the read and write count parameters into * the request structure. */ cy_as_ll_request_response__set_word(req_p, 0, - (uint16_t)((wr_sectors >> 16) & 0xFFFF)) ; + (uint16_t)((wr_sectors >> 16) & 0xFFFF)); cy_as_ll_request_response__set_word(req_p, 1, - (uint16_t)(wr_sectors & 0xFFFF)) ; + (uint16_t)(wr_sectors & 0xFFFF)); cy_as_ll_request_response__set_word(req_p, 2, - (uint16_t)((rd_sectors >> 16) & 0xFFFF)) ; + (uint16_t)((rd_sectors >> 16) & 0xFFFF)); cy_as_ll_request_response__set_word(req_p, 3, - (uint16_t)(rd_sectors & 0xFFFF)) ; + (uint16_t)(rd_sectors & 0xFFFF)); if (cb == 0) { - ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p) ; + ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; if (cy_as_ll_request_response__get_code(reply_p) == CY_RESP_SUCCESS_FAILURE) - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); else - ret = CY_AS_ERROR_INVALID_RESPONSE ; + ret = CY_AS_ERROR_INVALID_RESPONSE; } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_USB_SET_MSREPORT_THRESHOLD, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, - req_p, reply_p, cy_as_usb_func_callback) ; + req_p, reply_p, cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; - return ret ; + goto destroy; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } cy_as_return_status_t @@ -3493,76 +3493,76 @@ cy_as_usb_select_m_s_partitions( cy_as_function_callback cb, uint32_t client) { - cy_as_return_status_t ret ; - cy_as_ll_request_response *req_p , *reply_p ; - uint16_t val ; + cy_as_return_status_t ret; + cy_as_ll_request_response *req_p , *reply_p; + uint16_t val; - cy_as_device *dev_p = (cy_as_device *)handle ; + cy_as_device *dev_p = (cy_as_device *)handle; if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) - return CY_AS_ERROR_INVALID_HANDLE ; + return CY_AS_ERROR_INVALID_HANDLE; - ret = is_usb_active(dev_p) ; + ret = is_usb_active(dev_p); if (ret != CY_AS_ERROR_SUCCESS) - return ret ; + return ret; /* This API has to be made before SetEnumConfig is called. */ if (dev_p->usb_config[0].enabled) - return CY_AS_ERROR_INVALID_CALL_SEQUENCE ; + return CY_AS_ERROR_INVALID_CALL_SEQUENCE; if ((cb == 0) && (cy_as_device_is_in_callback(dev_p))) - return CY_AS_ERROR_INVALID_IN_CALLBACK ; + return CY_AS_ERROR_INVALID_IN_CALLBACK; req_p = cy_as_ll_create_request(dev_p, CY_RQT_MS_PARTITION_SELECT, - CY_RQT_USB_RQT_CONTEXT, 2) ; + CY_RQT_USB_RQT_CONTEXT, 2); if (req_p == 0) - return CY_AS_ERROR_OUT_OF_MEMORY ; + return CY_AS_ERROR_OUT_OF_MEMORY; /* A single status word response type */ - reply_p = cy_as_ll_create_response(dev_p, 1) ; + reply_p = cy_as_ll_create_response(dev_p, 1); if (reply_p == 0) { - cy_as_ll_destroy_request(dev_p, req_p) ; - return CY_AS_ERROR_OUT_OF_MEMORY ; + cy_as_ll_destroy_request(dev_p, req_p); + return CY_AS_ERROR_OUT_OF_MEMORY; } /* Set the read and write count parameters into * the request structure. */ cy_as_ll_request_response__set_word(req_p, 0, - (uint16_t)((bus << 8) | device)) ; + (uint16_t)((bus << 8) | device)); - val = 0 ; + val = 0; if ((type == cy_as_usb_m_s_unit0) || (type == cy_as_usb_m_s_both)) - val |= 1 ; + val |= 1; if ((type == cy_as_usb_m_s_unit1) || (type == cy_as_usb_m_s_both)) - val |= (1 << 8) ; + val |= (1 << 8); - cy_as_ll_request_response__set_word(req_p, 1, val) ; + cy_as_ll_request_response__set_word(req_p, 1, val); if (cb == 0) { - ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p) ; + ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; + goto destroy; if (cy_as_ll_request_response__get_code(reply_p) == CY_RESP_SUCCESS_FAILURE) - ret = cy_as_ll_request_response__get_word(reply_p, 0) ; + ret = cy_as_ll_request_response__get_word(reply_p, 0); else - ret = CY_AS_ERROR_INVALID_RESPONSE ; + ret = CY_AS_ERROR_INVALID_RESPONSE; } else { ret = cy_as_misc_send_request(dev_p, cb, client, CY_FUNCT_CB_NODATA, 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p, - cy_as_usb_func_callback) ; + cy_as_usb_func_callback); if (ret != CY_AS_ERROR_SUCCESS) - goto destroy ; - return ret ; + goto destroy; + return ret; } destroy: - cy_as_ll_destroy_request(dev_p, req_p) ; - cy_as_ll_destroy_response(dev_p, reply_p) ; + cy_as_ll_destroy_request(dev_p, req_p); + cy_as_ll_destroy_response(dev_p, reply_p); - return ret ; + return ret; } static void @@ -3574,113 +3574,113 @@ cy_as_usb_func_callback( cy_as_return_status_t stat) { cy_as_usb_func_c_b_node* node = (cy_as_usb_func_c_b_node *) - dev_p->usb_func_cbs->head_p ; + dev_p->usb_func_cbs->head_p; cy_as_func_c_b_node* fnode = (cy_as_func_c_b_node *) - dev_p->func_cbs_usb->head_p ; - cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ; + dev_p->func_cbs_usb->head_p; + cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS; - cy_as_device_handle h = (cy_as_device_handle)dev_p ; + cy_as_device_handle h = (cy_as_device_handle)dev_p; cy_bool delayed_ack = (rqt->flags & CY_AS_REQUEST_RESPONSE_DELAY_ACK) == CY_AS_REQUEST_RESPONSE_DELAY_ACK; cy_bool ex_request = (rqt->flags & CY_AS_REQUEST_RESPONSE_EX) - == CY_AS_REQUEST_RESPONSE_EX ; + == CY_AS_REQUEST_RESPONSE_EX; cy_bool ms_request = (rqt->flags & CY_AS_REQUEST_RESPONSE_MS) - == CY_AS_REQUEST_RESPONSE_MS ; - uint8_t code ; - uint8_t ep, state ; + == CY_AS_REQUEST_RESPONSE_MS; + uint8_t code; + uint8_t ep, state; if (!ex_request && !ms_request) { - cy_as_hal_assert(dev_p->usb_func_cbs->count != 0) ; + cy_as_hal_assert(dev_p->usb_func_cbs->count != 0); cy_as_hal_assert(dev_p->usb_func_cbs->type == - CYAS_USB_FUNC_CB) ; + CYAS_USB_FUNC_CB); } else { - cy_as_hal_assert(dev_p->func_cbs_usb->count != 0) ; - cy_as_hal_assert(dev_p->func_cbs_usb->type == CYAS_FUNC_CB) ; + cy_as_hal_assert(dev_p->func_cbs_usb->count != 0); + cy_as_hal_assert(dev_p->func_cbs_usb->type == CYAS_FUNC_CB); } - (void)context ; + (void)context; /* The Handlers are responsible for Deleting the rqt and resp when * they are finished */ - code = cy_as_ll_request_response__get_code(rqt) ; + code = cy_as_ll_request_response__get_code(rqt); switch (code) { case CY_RQT_START_USB: - ret = my_handle_response_usb_start(dev_p, rqt, resp, stat) ; - break ; + ret = my_handle_response_usb_start(dev_p, rqt, resp, stat); + break; case CY_RQT_STOP_USB: - ret = my_handle_response_usb_stop(dev_p, rqt, resp, stat) ; - break ; + ret = my_handle_response_usb_stop(dev_p, rqt, resp, stat); + break; case CY_RQT_SET_CONNECT_STATE: if (!cy_as_ll_request_response__get_word(rqt, 0)) ret = my_handle_response_disconnect( - dev_p, rqt, resp, stat) ; + dev_p, rqt, resp, stat); else ret = my_handle_response_connect( - dev_p, rqt, resp, stat) ; - break ; + dev_p, rqt, resp, stat); + break; case CY_RQT_GET_CONNECT_STATE: - break ; + break; case CY_RQT_SET_USB_CONFIG: - ret = my_handle_response_set_enum_config(dev_p, rqt, resp) ; - break ; + ret = my_handle_response_set_enum_config(dev_p, rqt, resp); + break; case CY_RQT_GET_USB_CONFIG: - cy_as_hal_assert(fnode->data != 0) ; + cy_as_hal_assert(fnode->data != 0); ret = my_handle_response_get_enum_config(dev_p, - rqt, resp, fnode->data) ; - break ; + rqt, resp, fnode->data); + break; case CY_RQT_STALL_ENDPOINT: - ep = (uint8_t)cy_as_ll_request_response__get_word(rqt, 0) ; - state = (uint8_t)cy_as_ll_request_response__get_word(rqt, 1) ; - ret = my_handle_response_no_data(dev_p, rqt, resp) ; + ep = (uint8_t)cy_as_ll_request_response__get_word(rqt, 0); + state = (uint8_t)cy_as_ll_request_response__get_word(rqt, 1); + ret = my_handle_response_no_data(dev_p, rqt, resp); if ((ret == CY_AS_ERROR_SUCCESS) && (ep > 1) && (state != 0) && (dev_p->usb_config[ep].dir == cy_as_usb_out)) - cy_as_usb_flush_logical_e_p(dev_p, ep) ; - break ; + cy_as_usb_flush_logical_e_p(dev_p, ep); + break; case CY_RQT_GET_STALL: - cy_as_hal_assert(fnode->data != 0) ; + cy_as_hal_assert(fnode->data != 0); ret = my_handle_response_get_stall(dev_p, - rqt, resp, (cy_bool *)fnode->data) ; - break ; + rqt, resp, (cy_bool *)fnode->data); + break; case CY_RQT_SET_DESCRIPTOR: - ret = my_handle_response_no_data(dev_p, rqt, resp) ; - break ; + ret = my_handle_response_no_data(dev_p, rqt, resp); + break; case CY_RQT_GET_DESCRIPTOR: - cy_as_hal_assert(fnode->data != 0) ; + cy_as_hal_assert(fnode->data != 0); ret = my_handle_response_get_descriptor(dev_p, - rqt, resp, (cy_as_get_descriptor_data *)fnode->data) ; + rqt, resp, (cy_as_get_descriptor_data *)fnode->data); break; case CY_RQT_SET_USB_CONFIG_REGISTERS: - ret = my_handle_response_no_data(dev_p, rqt, resp) ; + ret = my_handle_response_no_data(dev_p, rqt, resp); if (ret == CY_AS_ERROR_SUCCESS) - ret = cy_as_usb_setup_dma(dev_p) ; - break ; + ret = cy_as_usb_setup_dma(dev_p); + break; case CY_RQT_ENDPOINT_SET_NAK: - ret = my_handle_response_no_data(dev_p, rqt, resp) ; - break ; + ret = my_handle_response_no_data(dev_p, rqt, resp); + break; case CY_RQT_GET_ENDPOINT_NAK: - cy_as_hal_assert(fnode->data != 0) ; + cy_as_hal_assert(fnode->data != 0); ret = my_handle_response_get_nak(dev_p, - rqt, resp, (cy_bool *)fnode->data) ; - break ; + rqt, resp, (cy_bool *)fnode->data); + break; case CY_RQT_ACK_SETUP_PACKET: - break ; + break; case CY_RQT_USB_REMOTE_WAKEUP: - ret = my_handle_response_no_data(dev_p, rqt, resp) ; - break ; + ret = my_handle_response_no_data(dev_p, rqt, resp); + break; case CY_RQT_CLEAR_DESCRIPTORS: - ret = my_handle_response_no_data(dev_p, rqt, resp) ; - break ; + ret = my_handle_response_no_data(dev_p, rqt, resp); + break; case CY_RQT_USB_STORAGE_MONITOR: - ret = my_handle_response_no_data(dev_p, rqt, resp) ; - break ; + ret = my_handle_response_no_data(dev_p, rqt, resp); + break; case CY_RQT_MS_PARTITION_SELECT: - ret = my_handle_response_no_data(dev_p, rqt, resp) ; - break ; + ret = my_handle_response_no_data(dev_p, rqt, resp); + break; default: - ret = CY_AS_ERROR_INVALID_RESPONSE ; - cy_as_hal_assert(cy_false) ; - break ; + ret = CY_AS_ERROR_INVALID_RESPONSE; + cy_as_hal_assert(cy_false); + break; } /* @@ -3689,28 +3689,28 @@ cy_as_usb_func_callback( * code based on the response from firmware. */ if (stat == CY_AS_ERROR_SUCCESS) - stat = ret ; + stat = ret; if (ex_request || ms_request) { fnode->cb_p((cy_as_device_handle)dev_p, stat, - fnode->client_data, fnode->data_type, fnode->data) ; - cy_as_remove_c_b_node(dev_p->func_cbs_usb) ; + fnode->client_data, fnode->data_type, fnode->data); + cy_as_remove_c_b_node(dev_p->func_cbs_usb); } else { node->cb_p((cy_as_device_handle)dev_p, stat, - node->client_data) ; - cy_as_remove_c_b_node(dev_p->usb_func_cbs) ; + node->client_data); + cy_as_remove_c_b_node(dev_p->usb_func_cbs); } if (delayed_ack) { - cy_as_hal_assert(cy_as_device_is_ack_delayed(dev_p)) ; - cy_as_device_rem_ack_delayed(dev_p) ; + cy_as_hal_assert(cy_as_device_is_ack_delayed(dev_p)); + cy_as_device_rem_ack_delayed(dev_p); /* * send the ACK if required. */ if (!cy_as_device_is_ack_delayed(dev_p)) cy_as_usb_ack_setup_packet(h, - usb_ack_callback, 0) ; + usb_ack_callback, 0); } } -- cgit v1.2.3