From 5bf829339d8f0c0d74c78e653275bfed3b7a0ab1 Mon Sep 17 00:00:00 2001 From: twinaphex Date: Mon, 27 May 2019 14:32:40 +0200 Subject: [PATCH] (HID) Uniquely name symbols --- input/common/hid/device_ds3.c | 46 ++++++------ input/common/hid/device_null.c | 77 ++++++++++---------- input/common/hid/device_wiiu_gca.c | 53 +++++++------- input/common/input_common.c | 11 +-- input/drivers_hid/wiiu_hid.c | 110 ++++++++++++++++------------- input/drivers_hid/wiiusb_hid.c | 6 +- 6 files changed, 159 insertions(+), 144 deletions(-) diff --git a/input/common/hid/device_ds3.c b/input/common/hid/device_ds3.c index 4b26cd5634..cb3b01b736 100644 --- a/input/common/hid/device_ds3.c +++ b/input/common/hid/device_ds3.c @@ -30,7 +30,7 @@ typedef struct ds3_instance { uint8_t data[64]; } ds3_instance_t; -static uint8_t activation_packet[] = { +static uint8_t ds3_activation_packet[] = { #if defined(IOS) 0x53, 0xF4, #elif defined(HAVE_WIIUSB_HID) @@ -51,7 +51,7 @@ static uint8_t activation_packet[] = { #define MOTOR1_OFFSET 4 #define MOTOR2_OFFSET 6 -static uint8_t control_packet[] = { +static uint8_t ds3_control_packet[] = { 0x52, 0x01, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -65,25 +65,23 @@ static uint8_t control_packet[] = { 0x00, 0x00, 0x00 }; -static int control_packet_size = sizeof(control_packet); - extern pad_connection_interface_t ds3_pad_connection; -static void update_pad_state(ds3_instance_t *instance); -static void update_analog_state(ds3_instance_t *instance); +static void ds3_update_pad_state(ds3_instance_t *instance); +static void ds3_update_analog_state(ds3_instance_t *instance); -static int32_t send_activation_packet(ds3_instance_t *instance) +static int32_t ds3_send_activation_packet(ds3_instance_t *instance) { int32_t result; #if defined(WIIU) result = HID_SET_REPORT(instance->handle, HID_REPORT_FEATURE, DS3_ACTIVATION_REPORT_ID, - activation_packet, - sizeof(activation_packet)); + ds3_activation_packet, + sizeof(ds3_activation_packet)); #else HID_SEND_CONTROL(instance->handle, - activation_packet, sizeof(activation_packet)); + ds3_activation_packet, sizeof(ds3_activation_packet)); #endif return result; @@ -99,11 +97,11 @@ static uint32_t set_protocol(ds3_instance_t *instance, int protocol) return result; } -static int32_t send_control_packet(ds3_instance_t *instance) +static int32_t ds3_send_control_packet(ds3_instance_t *instance) { - uint8_t packet_buffer[control_packet_size]; + uint8_t packet_buffer[sizeof(ds3_control_packet)]; int32_t result = 0; - memcpy(packet_buffer, control_packet, control_packet_size); + memcpy(packet_buffer, ds3_control_packet, sizeof(ds3_control_packet)); packet_buffer[LED_OFFSET] = 0; if(instance->pad) { @@ -121,11 +119,11 @@ static int32_t send_control_packet(ds3_instance_t *instance) HID_REPORT_OUTPUT, DS3_RUMBLE_REPORT_ID, packet_buffer+PACKET_OFFSET, - control_packet_size-PACKET_OFFSET); + sizeof(ds3_control_packet)-PACKET_OFFSET); #else HID_SEND_CONTROL(instance->handle, packet_buffer+PACKET_OFFSET, - control_packet_size-PACKET_OFFSET); + sizeof(ds3_control_packet)-PACKET_OFFSET); #endif /* WIIU */ return result; } @@ -148,11 +146,11 @@ static void *ds3_init(void *handle) set_protocol(instance, 1); RARCH_LOG("[ds3]: sending control packet\n"); - if(send_control_packet(instance) < 0) + if(ds3_send_control_packet(instance) < 0) errors++; RARCH_LOG("[ds3]: sending activation packet\n"); - if(send_activation_packet(instance) < 0) + if(ds3_send_activation_packet(instance) < 0) errors++; if(errors) @@ -246,23 +244,23 @@ static void ds3_packet_handler(void *data, uint8_t *packet, uint16_t size) if(instance->pad && !instance->led_set) { - send_control_packet(instance); + ds3_send_control_packet(instance); instance->led_set = true; } - if(size > control_packet_size) + if(size > sizeof(ds3_control_packet)) { RARCH_ERR("[ds3]: Expecting packet to be %d but was %d\n", - control_packet_size, size); + sizeof(ds3_control_packet), size); return; } memcpy(instance->data, packet, size); - update_pad_state(instance); - update_analog_state(instance); + ds3_update_pad_state(instance); + ds3_update_analog_state(instance); } -static void update_analog_state(ds3_instance_t *instance) +static void ds3_update_analog_state(ds3_instance_t *instance) { int pad_axis; int16_t interpolated; @@ -277,7 +275,7 @@ static void update_analog_state(ds3_instance_t *instance) } } -static void update_pad_state(ds3_instance_t *instance) +static void ds3_update_pad_state(ds3_instance_t *instance) { uint32_t i, pressed_keys; diff --git a/input/common/hid/device_null.c b/input/common/hid/device_null.c index f5676c87b7..2417dcedb7 100644 --- a/input/common/hid/device_null.c +++ b/input/common/hid/device_null.c @@ -16,7 +16,7 @@ #include "hid_device_driver.h" -extern pad_connection_interface_t null_pad_connection; +extern pad_connection_interface_t hid_null_pad_connection; /* * This is the instance data structure for the pad you are implementing. @@ -24,7 +24,8 @@ extern pad_connection_interface_t null_pad_connection; * sense for the pad you're writing for. The pointer to this structure * will be passed in as a void pointer to the methods you implement below. */ -typedef struct null_instance { +typedef struct hid_null_instance +{ void *handle; /* a handle to the HID subsystem adapter */ joypad_connection_t *pad; /* a pointer to the joypad connection you assign in init() */ @@ -33,7 +34,7 @@ typedef struct null_instance { uint16_t motors[2]; /* rumble strength, if appropriate */ uint8_t data[64]; /* a buffer large enough to hold the device's max rx packet */ -} null_instance_t; +} hid_null_instance_t; /** * Use the HID_ macros (see input/include/hid_driver.h) to send data packets @@ -49,15 +50,14 @@ typedef struct null_instance { */ static void *null_init(void *handle) { - null_instance_t *instance; - instance = (null_instance_t *)calloc(1, sizeof(null_instance_t)); - if(!instance) + hid_null_instance_t *instance = (hid_null_instance_t *)calloc(1, sizeof(hid_null_instance_t)); + if (!instance) goto error; - memset(instance, 0, sizeof(null_instance_t)); + memset(instance, 0, sizeof(hid_null_instance_t)); instance->handle = handle; - instance->pad = hid_pad_register(instance, &null_pad_connection); - if(!instance->pad) + instance->pad = hid_pad_register(instance, &hid_null_pad_connection); + if (!instance->pad) goto error; RARCH_LOG("[null]: init complete.\n"); @@ -65,7 +65,7 @@ static void *null_init(void *handle) error: RARCH_ERR("[null]: init failed.\n"); - if(instance) + if (instance) free(instance); return NULL; @@ -77,9 +77,10 @@ static void *null_init(void *handle) */ static void null_free(void *data) { - null_instance_t *instance = (null_instance_t *)data; + hid_null_instance_t *instance = (hid_null_instance_t *)data; - if(instance) { + if (instance) + { hid_pad_deregister(instance->pad); free(instance); } @@ -92,9 +93,9 @@ static void null_free(void *data) */ static void null_handle_packet(void *data, uint8_t *buffer, size_t size) { - null_instance_t *instance = (null_instance_t *)data; + hid_null_instance_t *instance = (hid_null_instance_t *)data; - if(instance && instance->pad) + if (instance && instance->pad) instance->pad->iface->packet_handler(instance->pad->data, buffer, size); } @@ -123,11 +124,11 @@ hid_device_t null_hid_device = { * But if you need to track multiple pads attached to the same HID device * (see: Wii U GC adapter), you can allocate that memory here. */ -static void *null_pad_init(void *data, uint32_t slot, hid_driver_t *driver) +static void *hid_null_pad_init(void *data, uint32_t slot, hid_driver_t *driver) { - null_instance_t *instance = (null_instance_t *)data; + hid_null_instance_t *instance = (hid_null_instance_t *)data; - if(!instance) + if (!instance) return NULL; instance->slot = slot; @@ -135,9 +136,9 @@ static void *null_pad_init(void *data, uint32_t slot, hid_driver_t *driver) } /** - * If you allocate any memory in null_pad_init() above, de-allocate it here. + * If you allocate any memory in hid_null_pad_init() above, de-allocate it here. */ -static void null_pad_deinit(void *data) +static void hid_null_pad_deinit(void *data) { } @@ -145,10 +146,10 @@ static void null_pad_deinit(void *data) * Translate the button data from the pad into the input_bits_t format * that RetroArch can use. */ -static void null_get_buttons(void *data, input_bits_t *state) +static void hid_null_get_buttons(void *data, input_bits_t *state) { - null_instance_t *instance = (null_instance_t *)data; - if(!instance) + hid_null_instance_t *instance = (hid_null_instance_t *)data; + if (!instance) return; /* TODO: get buttons */ @@ -157,10 +158,10 @@ static void null_get_buttons(void *data, input_bits_t *state) /** * Handle a single packet for the pad. */ -static void null_packet_handler(void *data, uint8_t *packet, uint16_t size) +static void hid_null_packet_handler(void *data, uint8_t *packet, uint16_t size) { - null_instance_t *instance = (null_instance_t *)data; - if(!instance) + hid_null_instance_t *instance = (hid_null_instance_t *)data; + if (!instance) return; RARCH_LOG_BUFFER(packet, size); @@ -169,7 +170,7 @@ static void null_packet_handler(void *data, uint8_t *packet, uint16_t size) /** * If the pad doesn't support rumble, then this can just be a no-op. */ -static void null_set_rumble(void *data, enum retro_rumble_effect effect, uint16_t strength) +static void hid_null_set_rumble(void *data, enum retro_rumble_effect effect, uint16_t strength) { } @@ -182,7 +183,7 @@ static void null_set_rumble(void *data, enum retro_rumble_effect effect, uint16_ * - (-32768,-32768) is top-left * - (32767,32767) is bottom-right */ -static int16_t null_get_axis(void *data, unsigned axis) +static int16_t hid_null_get_axis(void *data, unsigned axis) { return 0; } @@ -191,7 +192,7 @@ static int16_t null_get_axis(void *data, unsigned axis) * The name the pad will show up as in the UI, also used to auto-assign * buttons in input/input_autodetect_builtin.c */ -static const char *null_get_name(void *data) +static const char *hid_null_get_name(void *data) { return "Null HID Pad"; } @@ -199,7 +200,7 @@ static const char *null_get_name(void *data) /** * Read the state of a single button. */ -static bool null_button(void *data, uint16_t joykey) +static bool hid_null_button(void *data, uint16_t joykey) { return false; } @@ -207,13 +208,13 @@ static bool null_button(void *data, uint16_t joykey) /** * Fill in the joypad interface */ -pad_connection_interface_t null_pad_connection = { - null_pad_init, - null_pad_deinit, - null_packet_handler, - null_set_rumble, - null_get_buttons, - null_get_axis, - null_get_name, - null_button +pad_connection_interface_t hid_null_pad_connection = { + hid_null_pad_init, + hid_null_pad_deinit, + hid_null_packet_handler, + hid_null_set_rumble, + hid_null_get_buttons, + hid_null_get_axis, + hid_null_get_name, + hid_null_button }; diff --git a/input/common/hid/device_wiiu_gca.c b/input/common/hid/device_wiiu_gca.c index b5198367b5..fd2d2fad6b 100644 --- a/input/common/hid/device_wiiu_gca.c +++ b/input/common/hid/device_wiiu_gca.c @@ -27,12 +27,13 @@ static uint8_t activation_packet[] = { 0x13 }; #define GCA_PORT_CONNECTED 0x10 #define GCA_WAVEBIRD_CONNECTED 0x22 -typedef struct wiiu_gca_instance { - void *handle; - bool online; - uint8_t device_state[37]; - joypad_connection_t *pads[4]; -} wiiu_gca_instance_t; +typedef struct hid_wiiu_gca_instance +{ + void *handle; + bool online; + uint8_t device_state[37]; + joypad_connection_t *pads[4]; +} hid_wiiu_gca_instance_t; typedef struct gca_pad_data { @@ -44,17 +45,18 @@ typedef struct gca_pad_data int16_t analog_state[3][2]; // analog state } gca_pad_t; -static void update_pad_state(wiiu_gca_instance_t *instance); -static void unregister_pad(wiiu_gca_instance_t *instance, int port); +static void wiiu_gca_update_pad_state(hid_wiiu_gca_instance_t *instance); +static void wiiu_gca_unregister_pad(hid_wiiu_gca_instance_t *instance, int port); extern pad_connection_interface_t wiiu_gca_pad_connection; static void *wiiu_gca_init(void *handle) { RARCH_LOG("[gca]: allocating driver instance...\n"); - wiiu_gca_instance_t *instance = calloc(1, sizeof(wiiu_gca_instance_t)); - if(instance == NULL) goto error; - memset(instance, 0, sizeof(wiiu_gca_instance_t)); + hid_wiiu_gca_instance_t *instance = calloc(1, sizeof(hid_wiiu_gca_instance_t)); + if(instance == NULL) + return NULL; + memset(instance, 0, sizeof(hid_wiiu_gca_instance_t)); instance->handle = handle; hid_instance.os_driver->send_control(handle, activation_packet, sizeof(activation_packet)); @@ -71,15 +73,17 @@ static void *wiiu_gca_init(void *handle) return NULL; } -static void wiiu_gca_free(void *data) { - wiiu_gca_instance_t *instance = (wiiu_gca_instance_t *)data; +static void wiiu_gca_free(void *data) +{ + hid_wiiu_gca_instance_t *instance = (hid_wiiu_gca_instance_t *)data; int i; - if(instance) { + if(instance) + { instance->online = false; - for(i = 0; i < 4; i++) - unregister_pad(instance, i); + for (i = 0; i < 4; i++) + wiiu_gca_unregister_pad(instance, i); free(instance); } @@ -87,7 +91,7 @@ static void wiiu_gca_free(void *data) { static void wiiu_gca_handle_packet(void *data, uint8_t *buffer, size_t size) { - wiiu_gca_instance_t *instance = (wiiu_gca_instance_t *)data; + hid_wiiu_gca_instance_t *instance = (hid_wiiu_gca_instance_t *)data; if(!instance || !instance->online) { RARCH_WARN("[gca]: instance null or not ready yet.\n"); @@ -102,10 +106,10 @@ static void wiiu_gca_handle_packet(void *data, uint8_t *buffer, size_t size) } memcpy(instance->device_state, buffer, size); - update_pad_state(instance); + wiiu_gca_update_pad_state(instance); } -static void update_pad_state(wiiu_gca_instance_t *instance) +static void wiiu_gca_update_pad_state(hid_wiiu_gca_instance_t *instance) { int i, port; unsigned char port_connected; @@ -114,8 +118,9 @@ static void update_pad_state(wiiu_gca_instance_t *instance) return; joypad_connection_t *pad; + /* process each pad */ - for(i = 1; i < 37; i += 9) + for (i = 1; i < 37; i += 9) { port = i / 9; pad = instance->pads[port]; @@ -140,13 +145,13 @@ static void update_pad_state(wiiu_gca_instance_t *instance) } else { if(pad != NULL) { RARCH_LOG("[gca]: Gamepad at port %d disconnected.\n", port+1); - unregister_pad(instance, port); + wiiu_gca_unregister_pad(instance, port); } } } } -static void unregister_pad(wiiu_gca_instance_t *instance, int slot) +static void wiiu_gca_unregister_pad(hid_wiiu_gca_instance_t *instance, int slot) { if(!instance || slot < 0 || slot >= 4 || instance->pads[slot] == NULL) return; @@ -238,7 +243,7 @@ static void update_buttons(gca_pad_t *pad) pressed_keys = pad->data[1] | (pad->data[2] << 8); pad->buttons = 0; - for(i = 0; i < 12; i++) + for (i = 0; i < 12; i++) pad->buttons |= (pressed_keys & (1 << i)) ? (1 << button_mapping[i]) : 0; } @@ -261,7 +266,7 @@ static void update_analog_state(gca_pad_t *pad) /* GameCube analog axis are 8-bit unsigned, where 128/128 is center. * So, we subtract 128 to get a signed, 0-based value and then mulitply * by 256 to get the 16-bit range RetroArch expects. */ - for(pad_axis = 0; pad_axis < 4; pad_axis++) + for (pad_axis = 0; pad_axis < 4; pad_axis++) { axis = pad_axis % 2 ? 0 : 1; stick = pad_axis / 2; diff --git a/input/common/input_common.c b/input/common/input_common.c index aadc93275b..ae6956af31 100644 --- a/input/common/input_common.c +++ b/input/common/input_common.c @@ -16,7 +16,8 @@ #include "../include/gamepad.h" -enum pad_axes { +enum gamepad_pad_axes +{ AXIS_LEFT_ANALOG_X, AXIS_LEFT_ANALOG_Y, AXIS_RIGHT_ANALOG_X, @@ -24,11 +25,11 @@ enum pad_axes { AXIS_INVALID }; -static int16_t clamp_axis(int16_t value, bool is_negative) +static int16_t gamepad_clamp_axis(int16_t value, bool is_negative) { - if(is_negative && value > 0) + if (is_negative && value > 0) return 0; - if(!is_negative && value < 0) + if (!is_negative && value < 0) return 0; return value; @@ -72,5 +73,5 @@ int16_t gamepad_get_axis_value(int16_t state[3][2], axis_data *data) break; } - return clamp_axis(value, data->is_negative); + return gamepad_clamp_axis(value, data->is_negative); } diff --git a/input/drivers_hid/wiiu_hid.c b/input/drivers_hid/wiiu_hid.c index 16fbd9354a..78ce42e30e 100644 --- a/input/drivers_hid/wiiu_hid.c +++ b/input/drivers_hid/wiiu_hid.c @@ -33,11 +33,11 @@ static bool wiiu_hid_joypad_query(void *data, unsigned slot) static joypad_connection_t *get_pad(wiiu_hid_t *hid, unsigned slot) { - if(!wiiu_hid_joypad_query(hid, slot)) + if (!wiiu_hid_joypad_query(hid, slot)) return NULL; joypad_connection_t *result = HID_PAD_CONNECTION_PTR(slot); - if(!result || !result->connected || !result->iface || !result->data) + if (!result || !result->connected || !result->iface || !result->data) return NULL; return result; @@ -47,7 +47,7 @@ static const char *wiiu_hid_joypad_name(void *data, unsigned slot) { joypad_connection_t *pad = get_pad((wiiu_hid_t *)data, slot); - if(!pad) + if (!pad) return NULL; return pad->iface->get_name(pad->data); @@ -57,7 +57,7 @@ static void wiiu_hid_joypad_get_buttons(void *data, unsigned slot, input_bits_t { joypad_connection_t *pad = get_pad((wiiu_hid_t *)data, slot); - if(pad) + if (pad) pad->iface->get_buttons(pad->data, state); } @@ -65,7 +65,7 @@ static bool wiiu_hid_joypad_button(void *data, unsigned slot, uint16_t joykey) { joypad_connection_t *pad = get_pad((wiiu_hid_t *)data, slot); - if(!pad) + if (!pad) return false; return pad->iface->button(pad->data, joykey); @@ -76,7 +76,7 @@ static bool wiiu_hid_joypad_rumble(void *data, unsigned slot, { joypad_connection_t *pad = get_pad((wiiu_hid_t *)data, slot); - if(!pad) + if (!pad) return false; pad->iface->set_rumble(pad->data, effect, strength); @@ -87,7 +87,7 @@ static int16_t wiiu_hid_joypad_axis(void *data, unsigned slot, uint32_t joyaxis) { joypad_connection_t *pad = get_pad((wiiu_hid_t *)data, slot); - if(!pad) + if (!pad) return 0; return pad->iface->get_axis(pad->data, joyaxis); @@ -148,7 +148,7 @@ static void wiiu_hid_free(const void *data) static void wiiu_hid_poll(void *data) { wiiu_hid_t *hid = (wiiu_hid_t *)data; - if(hid == NULL) + if (!hid) return; synchronized_process_adapters(hid); @@ -159,7 +159,8 @@ static void wiiu_hid_send_control(void *data, uint8_t *buf, size_t size) wiiu_adapter_t *adapter = (wiiu_adapter_t *)data; int32_t result; - if (!adapter) { + if (!adapter) + { RARCH_ERR("[hid]: send_control: bad adapter.\n"); return; } @@ -172,7 +173,7 @@ static void wiiu_hid_send_control(void *data, uint8_t *buf, size_t size) * to write a single byte was 0xffe2ff97, which works out to -30 and -105. * I have no idea what these mean. */ result = HIDWrite(adapter->handle, adapter->tx_buffer, adapter->tx_size, NULL, NULL); - if(result < 0) + if (result < 0) { int16_t r1 = (result & 0x0000FFFF); int16_t r2 = ((result & 0xFFFF0000) >> 16); @@ -227,14 +228,14 @@ static int32_t wiiu_hid_read(void *data, void *buffer, size_t size) wiiu_adapter_t *adapter = (wiiu_adapter_t *)data; int32_t result; - if(!adapter) + if (!adapter) return -1; - if(size > adapter->rx_size) + if (size > adapter->rx_size) return -1; result = HIDRead(adapter->handle, buffer, size, NULL, NULL); - if(result < 0) + if (result < 0) report_hid_error("read failed", adapter, result); return result; @@ -293,7 +294,8 @@ static void stop_polling_thread(wiiu_hid_t *hid) return; /* Unregister our HID client so we don't get any new events. */ - if(hid->client) { + if (hid->client) + { HIDDelClient(hid->client); hid->client = NULL; } @@ -329,7 +331,8 @@ static void log_device(HIDDevice *device) static uint8_t try_init_driver(wiiu_adapter_t *adapter) { adapter->driver_handle = adapter->driver->init(adapter); - if(adapter->driver_handle == NULL) { + if (adapter->driver_handle == NULL) + { RARCH_ERR("[hid]: Failed to initialize driver: %s\n", adapter->driver->name); return ADAPTER_STATE_DONE; @@ -345,7 +348,8 @@ static void synchronized_process_adapters(wiiu_hid_t *hid) bool keep_prev = false; OSFastMutex_Lock(&(adapters.lock)); - for(adapter = adapters.list; adapter != NULL; adapter = adapter_next) + + for (adapter = adapters.list; adapter != NULL; adapter = adapter_next) { adapter_next = adapter->next; @@ -360,7 +364,7 @@ static void synchronized_process_adapters(wiiu_hid_t *hid) break; case ADAPTER_STATE_GC: /* remove from the list */ - if(prev == NULL) + if (!prev) adapters.list = adapter->next; else prev->next = adapter->next; @@ -400,9 +404,9 @@ static wiiu_adapter_t *synchronized_lookup_adapter(uint32_t handle) OSFastMutex_Lock(&(adapters.lock)); wiiu_adapter_t *iterator; - for(iterator = adapters.list; iterator != NULL; iterator = iterator->next) + for (iterator = adapters.list; iterator != NULL; iterator = iterator->next) { - if(iterator->handle == handle) + if (iterator->handle == handle) break; } OSFastMutex_Unlock(&(adapters.lock)); @@ -423,17 +427,20 @@ static int32_t wiiu_attach_callback(HIDClient *client, { wiiu_attach_event *event = NULL; - if(attach) { + if (attach) + { RARCH_LOG("[hid]: Device attach event generated.\n"); log_device(device); - } else { + } + else + { RARCH_LOG("[hid]: Device detach event generated.\n"); } if (device) event = new_attach_event(device); - if(!event) + if (!event) goto error; event->type = attach; @@ -453,7 +460,7 @@ static void wiiu_hid_detach(wiiu_hid_t *hid, wiiu_attach_event *event) /* this will signal the read loop to stop for this adapter * the read loop method will update this to ADAPTER_STATE_GC * so the adapter poll method can clean it up. */ - if(adapter) + if (adapter) adapter->connected = false; } @@ -461,7 +468,7 @@ static void wiiu_hid_attach(wiiu_hid_t *hid, wiiu_attach_event *event) { wiiu_adapter_t *adapter = new_adapter(event); - if(!adapter) + if (!adapter) { RARCH_ERR("[hid]: Failed to allocate adapter.\n"); goto error; @@ -483,21 +490,23 @@ static void wiiu_hid_read_loop_callback(uint32_t handle, int32_t error, uint8_t *buffer, uint32_t buffer_size, void *userdata) { wiiu_adapter_t *adapter = (wiiu_adapter_t *)userdata; - if(!adapter) + if (!adapter) { RARCH_ERR("read_loop_callback: bad userdata\n"); return; } - if(error < 0) + if (error < 0) { report_hid_error("async read failed", adapter, error); } - if(adapter->state == ADAPTER_STATE_READING) { + if (adapter->state == ADAPTER_STATE_READING) + { adapter->state = ADAPTER_STATE_READY; - if(error == 0) { + if (error == 0) + { adapter->driver->handle_packet(adapter->driver_handle, buffer, buffer_size); } @@ -506,7 +515,7 @@ static void wiiu_hid_read_loop_callback(uint32_t handle, int32_t error, static void report_hid_error(const char *msg, wiiu_adapter_t *adapter, int32_t error) { - if(error >= 0) + if (error >= 0) return; int16_t hid_error_code = error & 0xffff; @@ -573,13 +582,13 @@ static void wiiu_hid_polling_thread_cleanup(OSThread *thread, void *stack) do { incomplete = 0; - for(adapter = adapters.list; adapter != NULL; adapter = adapter->next) + for (adapter = adapters.list; adapter != NULL; adapter = adapter->next) { - if(adapter->state == ADAPTER_STATE_READING) + if (adapter->state == ADAPTER_STATE_READING) incomplete++; } - if(incomplete == 0) + if (incomplete == 0) { RARCH_LOG("All in-flight reads complete.\n"); while(adapters.list != NULL) @@ -591,10 +600,10 @@ static void wiiu_hid_polling_thread_cleanup(OSThread *thread, void *stack) } } - if(incomplete) + if (incomplete) usleep(5000); - if(++retries >= 1000) + if (++retries >= 1000) { RARCH_WARN("[hid]: timed out waiting for in-flight read to finish.\n"); incomplete = 0; @@ -606,13 +615,13 @@ static void wiiu_handle_attach_events(wiiu_hid_t *hid, wiiu_attach_event *list) { wiiu_attach_event *event, *event_next = NULL; - if(!hid || !list) + if (!hid || !list) return; - for(event = list; event != NULL; event = event_next) + for (event = list; event != NULL; event = event_next) { event_next = event->next; - if(event->type == HID_DEVICE_ATTACH) + if (event->type == HID_DEVICE_ATTACH) wiiu_hid_attach(hid, event); else wiiu_hid_detach(hid, event); @@ -622,7 +631,8 @@ static void wiiu_handle_attach_events(wiiu_hid_t *hid, wiiu_attach_event *list) static void wiiu_poll_adapter(wiiu_adapter_t *adapter) { - if(!adapter->connected) { + if (!adapter->connected) + { adapter->state = ADAPTER_STATE_DONE; return; } @@ -637,12 +647,12 @@ static void wiiu_poll_adapters(wiiu_hid_t *hid) wiiu_adapter_t *it; OSFastMutex_Lock(&(adapters.lock)); - for(it = adapters.list; it != NULL; it = it->next) + for (it = adapters.list; it != NULL; it = it->next) { - if(it->state == ADAPTER_STATE_READY) + if (it->state == ADAPTER_STATE_READY) wiiu_poll_adapter(it); - if(it->state == ADAPTER_STATE_DONE) + if (it->state == ADAPTER_STATE_DONE) it->state = ADAPTER_STATE_GC; } @@ -696,7 +706,7 @@ static wiiu_hid_t *new_hid(void) static void delete_hid(wiiu_hid_t *hid) { RARCH_LOG("[hid]: delete_hid()\n"); - if(hid) + if (hid) free(hid); } @@ -709,7 +719,7 @@ static HIDClient *new_hidclient(void) static void delete_hidclient(HIDClient *client) { RARCH_LOG("[hid]: delete_hidclient()\n"); - if(client) + if (client) free(client); } @@ -741,17 +751,17 @@ static void delete_adapter(wiiu_adapter_t *adapter) if (!adapter) return; - if(adapter->rx_buffer) + if (adapter->rx_buffer) { free(adapter->rx_buffer); adapter->rx_buffer = NULL; } - if(adapter->tx_buffer) + if (adapter->tx_buffer) { free(adapter->tx_buffer); adapter->tx_buffer = NULL; } - if(adapter->driver && adapter->driver_handle) { + if (adapter->driver && adapter->driver_handle) { adapter->driver->free(adapter->driver_handle); adapter->driver_handle = NULL; adapter->driver = NULL; @@ -763,14 +773,14 @@ static void delete_adapter(wiiu_adapter_t *adapter) static wiiu_attach_event *new_attach_event(HIDDevice *device) { hid_device_t *driver = hid_device_driver_lookup(device->vid, device->pid); - if(!driver) + if (!driver) { RARCH_ERR("[hid]: Failed to locate driver for device vid=%04x pid=%04x\n", device->vid, device->pid); return NULL; } wiiu_attach_event *event = alloc_zeroed(4, sizeof(wiiu_attach_event)); - if(!event) + if (!event) return NULL; event->driver = driver; @@ -790,14 +800,14 @@ static wiiu_attach_event *new_attach_event(HIDDevice *device) static void delete_attach_event(wiiu_attach_event *event) { - if(event) + if (event) free(event); } void *alloc_zeroed(size_t alignment, size_t size) { void *result = memalign(alignment, size); - if(result) + if (result) memset(result, 0, size); return result; diff --git a/input/drivers_hid/wiiusb_hid.c b/input/drivers_hid/wiiusb_hid.c index 9f4fea629a..ce6f6c234d 100644 --- a/input/drivers_hid/wiiusb_hid.c +++ b/input/drivers_hid/wiiusb_hid.c @@ -167,7 +167,7 @@ static void wiiusb_get_description(usb_device_entry *device, { const usb_interfacedesc *inter = &config->interfaces[i]; - for(k = 0; k < (int)inter->bNumEndpoints; k++) + for (k = 0; k < (int)inter->bNumEndpoints; k++) { const usb_endpointdesc *epdesc = &inter->endpoints[k]; bool is_int = (epdesc->bmAttributes & 0x03) == USB_ENDPOINT_INTERRUPT; @@ -368,7 +368,7 @@ static bool wiiusb_hid_new_device(wiiusb_hid_t *hid, int32_t id) { struct wiiusb_adapter *temp; - if(!hid) + if (!hid) return false; /* false, so we do not proceed to add it */ temp = hid->adapters_head; @@ -536,7 +536,7 @@ static int16_t wiiusb_hid_joypad_axis(void *data, if (val >= 0) val = 0; } - else if(AXIS_POS_GET(joyaxis) < 4) + else if (AXIS_POS_GET(joyaxis) < 4) { val = pad_connection_get_axis(&hid->connections[port], port, AXIS_POS_GET(joyaxis));