(HID) Uniquely name symbols

This commit is contained in:
twinaphex 2019-05-27 14:32:40 +02:00
parent 277b5c9462
commit 5bf829339d
6 changed files with 159 additions and 144 deletions

View File

@ -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;

View File

@ -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
};

View File

@ -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;

View File

@ -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);
}

View File

@ -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;

View File

@ -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));