mirror of
https://github.com/libretro/RetroArch
synced 2025-01-30 03:32:46 +00:00
9bc5a15c2d
== DETAILS Whereas the last commit had a hack (that disabled the wiimote driver in the process), this has.. well, a *different* hack that allows pads to register in any order. Note that due to the initialization routines, the gamepad will still likely always get slot 0. Not sure if this can be overridden via config or not. == TESTING Tested locally with GC adapter
140 lines
3.9 KiB
C
140 lines
3.9 KiB
C
/* RetroArch - A frontend for libretro.
|
|
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
|
|
* Copyright (C) 2011-2017 - Daniel De Matteis
|
|
*
|
|
* RetroArch is free software: you can redistribute it and/or modify it under the terms
|
|
* of the GNU General Public License as published by the Free Software Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with RetroArch.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "hid_device_driver.h"
|
|
|
|
hid_driver_instance_t hid_instance = {0};
|
|
|
|
hid_device_t *hid_device_list[] = {
|
|
&wiiu_gca_hid_device,
|
|
&ds3_hid_device,
|
|
&ds4_hid_device,
|
|
NULL /* must be last entry in list */
|
|
};
|
|
|
|
hid_device_t *hid_device_driver_lookup(uint16_t vendor_id, uint16_t product_id) {
|
|
int i = 0;
|
|
|
|
for(i = 0; hid_device_list[i] != NULL; i++) {
|
|
if(hid_device_list[i]->detect(vendor_id, product_id))
|
|
return hid_device_list[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
joypad_connection_t *hid_pad_register(void *pad_handle, pad_connection_interface_t *iface)
|
|
{
|
|
int slot;
|
|
joypad_connection_t *result;
|
|
|
|
if(!pad_handle)
|
|
return NULL;
|
|
|
|
slot = pad_connection_find_vacant_pad(hid_instance.pad_list);
|
|
if(slot < 0)
|
|
return NULL;
|
|
|
|
result = &(hid_instance.pad_list[slot]);
|
|
result->iface = iface;
|
|
result->data = iface->init(pad_handle, slot, hid_instance.os_driver);
|
|
result->connected = true;
|
|
input_pad_connect(slot, hid_instance.pad_driver);
|
|
|
|
return result;
|
|
}
|
|
|
|
static bool init_pad_list(hid_driver_instance_t *instance, unsigned slots)
|
|
{
|
|
if(!instance || slots > MAX_USERS)
|
|
return false;
|
|
|
|
if(instance->pad_list)
|
|
return true;
|
|
|
|
RARCH_LOG("[hid]: initializing pad list...\n");
|
|
instance->pad_list = pad_connection_init(slots);
|
|
if(!instance->pad_list)
|
|
return false;
|
|
|
|
instance->max_slot = slots;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Fill in instance with data from initialized hid subsystem.
|
|
*
|
|
* @argument instance the hid_driver_instance_t struct to fill in
|
|
* @argument hid_driver the HID driver to initialize
|
|
* @argument pad_driver the gamepad driver to handle HID pads detected by the HID driver.
|
|
*
|
|
* @returns true if init is successful, false otherwise.
|
|
*/
|
|
bool hid_init(hid_driver_instance_t *instance,
|
|
hid_driver_t *hid_driver,
|
|
input_device_driver_t *pad_driver,
|
|
unsigned slots)
|
|
{
|
|
RARCH_LOG("[hid]: initializing instance with %d pad slots\n", slots);
|
|
if(!instance || !hid_driver || !pad_driver || slots > MAX_USERS)
|
|
return false;
|
|
|
|
RARCH_LOG("[hid]: initializing HID subsystem driver...\n");
|
|
instance->os_driver_data = hid_driver->init();
|
|
if(!instance->os_driver_data)
|
|
return false;
|
|
|
|
if(!init_pad_list(instance, slots))
|
|
{
|
|
hid_driver->free(instance->os_driver_data);
|
|
instance->os_driver_data = NULL;
|
|
return false;
|
|
}
|
|
|
|
instance->os_driver = hid_driver;
|
|
instance->pad_driver = pad_driver;
|
|
|
|
RARCH_LOG("[hid]: instance initialization complete.\n");
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Tear down the HID system set up by hid_init()
|
|
*
|
|
* @argument instance the hid_driver_instance_t to tear down.
|
|
*/
|
|
void hid_deinit(hid_driver_instance_t *instance)
|
|
{
|
|
if(!instance)
|
|
return;
|
|
|
|
RARCH_LOG("[hid]: destroying instance\n");
|
|
|
|
if(instance->os_driver && instance->os_driver_data)
|
|
{
|
|
RARCH_LOG("[hid]: tearing down HID subsystem driver...\n");
|
|
instance->os_driver->free(instance->os_driver_data);
|
|
}
|
|
|
|
RARCH_LOG("[hid]: destroying pad data...\n");
|
|
pad_connection_destroy(instance->pad_list);
|
|
|
|
RARCH_LOG("[hid]: wiping instance data...\n");
|
|
memset(instance, 0, sizeof(hid_driver_instance_t));
|
|
}
|