+ return 0;
+}
+
+/*
+ * Unbind act_mask on binds with type bind_type
+ * - if dev_id_ < 0, affects all devices
+ * else only affects dev_id_
+ * - if act_mask == -1, unbind all keys
+ * else only actions in mask
+ */
+void in_unbind_all(int dev_id_, int act_mask, int bind_type)
+{
+ int dev_id = 0, dev_last = IN_MAX_DEVS - 1;
+ int i, count;
+ in_dev_t *dev;
+
+ if (dev_id_ >= 0)
+ dev_id = dev_last = dev_id_;
+
+ if (bind_type >= IN_BINDTYPE_COUNT)
+ return;
+
+ for (; dev_id <= dev_last; dev_id++) {
+ dev = &in_devices[dev_id];
+ count = dev->key_count;
+
+ if (dev->binds == NULL)
+ continue;
+
+ if (act_mask != -1) {
+ for (i = 0; i < count; i++)
+ dev->binds[IN_BIND_OFFS(i, bind_type)] &= ~act_mask;
+ }
+ else
+ memset(dev->binds, 0, sizeof(dev->binds[0]) * count * IN_BINDTYPE_COUNT);
+ }
+}
+
+/* returns device id, or -1 on error */
+int in_config_parse_dev(const char *name)
+{
+ int drv_id = -1, i;
+
+ for (i = 0; i < in_driver_count; i++) {
+ int len = strlen(in_drivers[i].prefix);
+ if (strncmp(name, in_drivers[i].prefix, len) == 0) {
+ drv_id = i;
+ break;
+ }
+ }
+
+ if (drv_id < 0) {
+ lprintf("input: missing driver for %s\n", name);
+ return -1;
+ }
+
+ for (i = 0; i < in_dev_count; i++)
+ {
+ if (in_devices[i].name == NULL)
+ continue;
+ if (strcmp(in_devices[i].name, name) == 0)
+ return i;
+ }
+
+ if (i >= IN_MAX_DEVS)
+ {
+ /* try to find unused device */
+ for (i = 0; i < IN_MAX_DEVS; i++)
+ if (in_devices[i].name == NULL) break;
+ if (i >= IN_MAX_DEVS) {
+ lprintf("input: too many devices, can't add %s\n", name);
+ return -1;
+ }
+ }
+
+ memset(&in_devices[i], 0, sizeof(in_devices[i]));
+
+ in_devices[i].name = strdup(name);
+ if (in_devices[i].name == NULL)
+ return -1;
+
+ in_devices[i].key_names = DRV(drv_id).get_key_names(&in_devices[i].key_count);
+ in_devices[i].drv_id = drv_id;
+
+ if (i + 1 > in_dev_count)
+ in_dev_count = i + 1;
+
+ return i;
+}
+
+int in_config_bind_key(int dev_id, const char *key, int acts, int bind_type)
+{
+ in_dev_t *dev;
+ int i, offs, kc;
+
+ dev = get_dev(dev_id);
+ if (dev == NULL || bind_type >= IN_BINDTYPE_COUNT)
+ return -1;
+
+ /* maybe a raw code? */
+ if (key[0] == '\\' && key[1] == 'x') {
+ char *p = NULL;
+ kc = (int)strtoul(key + 2, &p, 16);
+ if (p == NULL || *p != 0)
+ kc = -1;
+ }
+ else {
+ /* device specific key name */
+ if (dev->binds == NULL) {
+ dev->binds = in_alloc_binds(dev->drv_id, dev->key_count);
+ if (dev->binds == NULL)
+ return -1;
+ }
+
+ kc = -1;
+ if (dev->key_names != NULL) {
+ for (i = 0; i < dev->key_count; i++) {
+ const char *k = dev->key_names[i];
+ if (k != NULL && strcasecmp(k, key) == 0) {
+ kc = i;
+ break;
+ }
+ }
+ }
+
+ if (kc < 0)
+ kc = DRV(dev->drv_id).get_key_code(key);
+ if (kc < 0 && strlen(key) == 1) {
+ /* assume scancode */
+ kc = key[0];
+ }
+ }
+
+ if (kc < 0 || kc >= dev->key_count) {
+ lprintf("input: bad key: %s\n", key);
+ return -1;
+ }
+
+ if (bind_type == IN_BINDTYPE_NONE) {
+ for (i = 0; i < IN_BINDTYPE_COUNT; i++)
+ dev->binds[IN_BIND_OFFS(kc, i)] = 0;
+ return 0;
+ }
+
+ offs = IN_BIND_OFFS(kc, bind_type);
+ if (dev->binds[offs] == -1)
+ dev->binds[offs] = 0;
+ dev->binds[offs] |= acts;
+ return 0;
+}
+
+void in_clean_binds(void)
+{
+ int i;
+
+ for (i = 0; i < IN_MAX_DEVS; i++) {
+ int ret, count, *binds, *def_binds;
+ in_dev_t *dev = &in_devices[i];
+
+ if (dev->binds == NULL || dev->drv_data == NULL)
+ continue;
+
+ count = dev->key_count;
+ binds = dev->binds;
+ def_binds = binds + count * IN_BINDTYPE_COUNT;
+
+ ret = DRV(dev->drv_id).clean_binds(dev->drv_data, binds, def_binds);
+ if (ret == 0) {
+ /* no useable binds */
+ free(dev->binds);
+ dev->binds = NULL;
+ }
+ }
+}
+
+void in_debug_dump(void)
+{
+ int i;
+
+ lprintf("# drv probed binds name\n");
+ for (i = 0; i < IN_MAX_DEVS; i++) {
+ in_dev_t *d = &in_devices[i];
+ if (!d->probed && d->name == NULL && d->binds == NULL)
+ continue;
+ lprintf("%d %3d %6c %5c %s\n", i, d->drv_id, d->probed ? 'y' : 'n',
+ d->binds ? 'y' : 'n', d->name);
+ }
+}
+
+/* stubs for drivers that choose not to implement something */
+
+static void in_def_free(void *drv_data) {}
+static int in_def_clean_binds(void *drv_data, int *b, int *db) { return 1; }
+static int in_def_get_config(void *drv_data, int what, int *val) { return -1; }
+static int in_def_set_config(void *drv_data, int what, int val) { return -1; }
+static int in_def_update_analog(void *drv_data, int axis_id, int *result) { return -1; }
+static int in_def_update_keycode(void *drv_data, int *is_down) { return 0; }
+static int in_def_menu_translate(void *drv_data, int keycode) { return 0; }
+static int in_def_get_key_code(const char *key_name) { return -1; }
+static const char *in_def_get_key_name(int keycode) { return NULL; }
+
+#define CHECK_ADD_STUB(d, f) \
+ if (d.f == NULL) d.f = in_def_##f
+
+/* to be called by drivers */
+int in_register_driver(const in_drv_t *drv, const struct in_default_bind *defbinds)
+{
+ int count_new = in_driver_count + 1;
+ in_drv_t *new_drivers;
+
+ new_drivers = realloc(in_drivers, count_new * sizeof(in_drivers[0]));
+ if (new_drivers == NULL) {
+ lprintf("input: in_register_driver OOM\n");
+ return -1;
+ }
+
+ memcpy(&new_drivers[in_driver_count], drv, sizeof(new_drivers[0]));
+
+ CHECK_ADD_STUB(new_drivers[in_driver_count], free);
+ CHECK_ADD_STUB(new_drivers[in_driver_count], clean_binds);
+ CHECK_ADD_STUB(new_drivers[in_driver_count], get_config);
+ CHECK_ADD_STUB(new_drivers[in_driver_count], set_config);
+ CHECK_ADD_STUB(new_drivers[in_driver_count], update_analog);
+ CHECK_ADD_STUB(new_drivers[in_driver_count], update_keycode);
+ CHECK_ADD_STUB(new_drivers[in_driver_count], menu_translate);
+ CHECK_ADD_STUB(new_drivers[in_driver_count], get_key_code);
+ CHECK_ADD_STUB(new_drivers[in_driver_count], get_key_name);
+ if (defbinds != NULL)
+ new_drivers[in_driver_count].defbinds = defbinds;
+ in_drivers = new_drivers;
+ in_driver_count = count_new;
+
+ return 0;