int main(int argc, char **argv)
{
int dev_cnt;
if(argc>1 && (strcmp(argv[1], "-d")==0) )
demonize(argv[0]);
while(1)
{
db_open();
dev_cnt = 0;
receive_history = true;
frame_id = 0;
printf("Wait for cm160 device to be connected\n");
while((dev_cnt = scan_usb()) == 0)
sleep(2);
printf("Found %d compatible device%s\n", dev_cnt, dev_cnt>1?"s":"");
// Only 1 device supported
if(!(g_devices[0].hdev = usb_open(g_devices[0].usb_dev)))
{
fprintf(stderr, "failed to open device\n");
db_close();
break;
}
handle_device(0);
usb_close(g_devices[0].hdev);
db_close();
}
return 0;
}
int str2devinfo(const char *dev_id_const, struct bladerf_devinfo *d)
{
char *dev_id, *token, *arg, *val, *saveptr;
int status, arg_status;
assert(d);
/* Prep our device info before we begin manpulating it, defaulting to
* a "wildcard" device indentification */
bladerf_init_devinfo(d);
/* No device indentifier -- pick anything we can find */
if ( dev_id_const == NULL || strlen(dev_id_const) == 0) {
return 0;
}
/* Copy the string so we can butcher it a bit while parsing */
dev_id = strdup(dev_id_const);
if (!dev_id) {
return BLADERF_ERR_MEM;
}
/* Extract backend */
token = strtok_r(dev_id, ":", &saveptr);
/* We require a valid backend -- args only is not supported */
if (token) {
status = handle_backend(token, d);
/* Loop over remainder of string, gathering up args */
arg_status = 1;
while (arg_status == 1 && status == 0) {
arg_status = next_arg(&saveptr, &arg, &val);
if (arg_status == 1) {
/* Handle argument if we can */
if (!strcasecmp("device", arg)) {
status = handle_device(d, val);
} else if (!strcasecmp("instance", arg)) {
status = handle_instance(d, val);
} else if (!strcasecmp("serial", arg)) {
status = handle_serial(d, val);
} else {
arg_status = BLADERF_ERR_INVAL;
}
}
};
if (arg_status < 0) {
status = arg_status;
}
} else {
status = BLADERF_ERR_INVAL;
}
free(dev_id);
return status;
}
void device_callback(struct am_device_notification_callback_info *info, void *arg) {
switch (info->msg) {
case ADNCI_MSG_CONNECTED:
handle_device(info->dev);
default:
break;
}
}
static void discoverControllers(void *data)
{
/* Get an array of all available devices. */
int deviceCount;
unsigned i;
screen_event_t *event;
qnx_input_t *qnx = (qnx_input_t*)data;
(void)event;
screen_get_context_property_iv(screen_ctx,
SCREEN_PROPERTY_DEVICE_COUNT, &deviceCount);
screen_device_t* devices_found = (screen_device_t*)
calloc(deviceCount, sizeof(screen_device_t));
screen_get_context_property_pv(screen_ctx,
SCREEN_PROPERTY_DEVICES, (void**)devices_found);
/* Scan the list for gamepad and joystick devices. */
for(i = 0; i < qnx->pads_connected; ++i)
initController(qnx, &qnx->devices[i]);
qnx->pads_connected = 0;
for (i = 0; i < deviceCount; i++)
{
int type;
screen_get_device_property_iv(
devices_found[i], SCREEN_PROPERTY_TYPE, &type);
if (
type == SCREEN_EVENT_GAMEPAD ||
type == SCREEN_EVENT_JOYSTICK ||
type == SCREEN_EVENT_KEYBOARD)
{
qnx->devices[qnx->pads_connected].handle = devices_found[i];
qnx->devices[qnx->pads_connected].index = qnx->pads_connected;
handle_device(qnx, &qnx->devices[qnx->pads_connected]);
if (qnx->pads_connected == MAX_PADS)
break;
}
}
free(devices_found);
}
static void scan_devices(context_t *ctx)
{
struct udev *udev;
struct udev_enumerate *enm;
struct udev_list_entry *list, *entry;
struct udev_device *dev;
const char *syspath;
if (!ctx || !(udev = ctx->udev))
return;
enm = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enm, "input");
udev_enumerate_scan_devices(enm);
list = udev_enumerate_get_list_entry(enm);
udev_list_entry_foreach(entry, list) {
syspath = udev_list_entry_get_name(entry);
if ((dev = udev_device_new_from_syspath(udev, syspath))) {
handle_device(ctx, dev);
udev_device_unref(dev);
}
}
static void handle_screen_event(void *data, bps_event_t *event)
{
int type;
qnx_input_t *qnx = (qnx_input_t*)data;
screen_event_t screen_event = screen_event_get_event(event);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &type);
switch(type)
{
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_RELEASE:
case SCREEN_EVENT_MTOUCH_MOVE:
process_touch_event(data, screen_event, type);
break;
case SCREEN_EVENT_KEYBOARD:
process_keyboard_event(data, screen_event, type);
break;
#ifdef HAVE_BB10
case SCREEN_EVENT_GAMEPAD:
case SCREEN_EVENT_JOYSTICK:
process_gamepad_event(data, screen_event, type);
break;
case SCREEN_EVENT_DEVICE:
{
/* A device was attached or removed. */
screen_device_t device;
int attached, type, i;
screen_get_event_property_pv(screen_event,
SCREEN_PROPERTY_DEVICE, (void**)&device);
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_ATTACHED, &attached);
if (attached)
screen_get_device_property_iv(device,
SCREEN_PROPERTY_TYPE, &type);
if (attached && (
type == SCREEN_EVENT_GAMEPAD ||
type == SCREEN_EVENT_JOYSTICK ||
type == SCREEN_EVENT_KEYBOARD)
)
{
for (i = 0; i < MAX_PADS; ++i)
{
if (!qnx->devices[i].handle)
{
qnx->devices[i].handle = device;
handle_device(data, &qnx->devices[i]);
break;
}
}
}
else
{
for (i = 0; i < MAX_PADS; ++i)
{
if (device == qnx->devices[i].handle)
{
RARCH_LOG("Device %s: Disconnected.\n",
qnx->devices[i].id);
initController(data, &qnx->devices[i]);
break;
}
}
}
}
break;
#endif
default:
break;
}
}
int main (int argc, char **argv)
{
GOptionContext *context;
GError *error = NULL;
libusb_device **list;
ssize_t num_devices, i;
context = g_option_context_new ("- Manage Sixaxis PS3 controllers");
g_option_context_add_main_entries (context, options, NULL);
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) {
g_warning ("Couldn't parse command-line options: %s", error->message);
return 1;
}
/* Check that the passed bdaddr is correct */
if (option_master != NULL && strcmp (option_master, "auto") != 0) {
//FIXME check bdaddr
}
libusb_init (NULL);
/* Find device(s) */
num_devices = libusb_get_device_list (NULL, &list);
if (num_devices < 0) {
g_warning ("libusb_get_device_list failed");
return 1;
}
for (i = 0; i < num_devices; i++) {
struct libusb_config_descriptor *cfg;
libusb_device *dev = list[i];
struct libusb_device_descriptor desc;
guint8 j;
if (libusb_get_device_descriptor (dev, &desc) < 0) {
g_warning ("libusb_get_device_descriptor failed");
continue;
}
/* Here we check for the supported devices */
if (desc.idVendor != VENDOR || desc.idProduct != PRODUCT)
continue;
/* Look for the interface number that interests us */
for (j = 0; j < desc.bNumConfigurations; j++) {
struct libusb_config_descriptor *config;
guint8 k;
libusb_get_config_descriptor (dev, j, &config);
for (k = 0; k < config->bNumInterfaces; k++) {
const struct libusb_interface *itf = &config->interface[k];
int l;
for (l = 0; l < itf->num_altsetting ; l++) {
struct libusb_interface_descriptor alt;
alt = itf->altsetting[l];
if (alt.bInterfaceClass == 3) {
handle_device (dev, cfg, l, &alt);
}
}
}
}
}
return 0;
}
