psx_gpu: do enhaced sprites with triangles
[pcsx_rearmed.git] / frontend / common / input.c
1 /*
2  * (C) GraÅžvydas "notaz" Ignotas, 2008-2011
3  *
4  * This work is licensed under the terms of any of these licenses
5  * (at your option):
6  *  - GNU GPL, version 2 or later.
7  *  - GNU LGPL, version 2.1 or later.
8  * See the COPYING file in the top-level directory.
9  */
10
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14
15 #include "input.h"
16 #include "plat.h"
17 #include "lprintf.h"
18
19 #ifdef IN_GP2X
20 #error needs update: in_gp2x_init in_gp2x_update
21 #include "../gp2x/in_gp2x.h"
22 #endif
23 #ifdef IN_VK
24 #error needs update: in_vk_init in_vk_update
25 #include "../win32/in_vk.h"
26 #endif
27
28 typedef struct
29 {
30         int drv_id;
31         int drv_fd_hnd;
32         void *drv_data;
33         char *name;
34         int key_count;
35         int *binds;     /* total = key_count * bindtypes * 2 */
36         const char * const *key_names;
37         unsigned int probed:1;
38         unsigned int does_combos:1;
39 } in_dev_t;
40
41 static in_drv_t *in_drivers;
42 static in_dev_t in_devices[IN_MAX_DEVS];
43 static int in_driver_count = 0;
44 static int in_dev_count = 0;            /* probed + bind devices */
45 static int in_have_async_devs = 0;
46 static int in_probe_dev_id;
47 static int menu_key_state = 0;
48 static int menu_last_used_dev = 0;
49
50 #define DRV(id) in_drivers[id]
51
52
53 static int *in_alloc_binds(int drv_id, int key_count)
54 {
55         const struct in_default_bind *defbinds;
56         int *binds;
57         int i;
58
59         binds = calloc(key_count * IN_BINDTYPE_COUNT * 2, sizeof(binds[0]));
60         if (binds == NULL)
61                 return NULL;
62
63         defbinds = DRV(drv_id).defbinds;
64         if (defbinds != NULL) {
65                 for (i = 0; ; i++) {
66                         if (defbinds[i].bit == 0 && defbinds[i].code == 0)
67                                 break;
68                         binds[IN_BIND_OFFS(defbinds[i].code, defbinds[i].btype)] =
69                                 1 << defbinds[i].bit;
70                 }
71
72                 /* always have a copy of defbinds */
73                 memcpy(binds + key_count * IN_BINDTYPE_COUNT, binds,
74                         sizeof(binds[0]) * key_count * IN_BINDTYPE_COUNT);
75         }
76
77         return binds;
78 }
79
80 static void in_unprobe(in_dev_t *dev)
81 {
82         if (dev->probed)
83                 DRV(dev->drv_id).free(dev->drv_data);
84         dev->probed = 0;
85         dev->drv_data = NULL;
86 }
87
88 static void in_free(in_dev_t *dev)
89 {
90         in_unprobe(dev);
91         free(dev->name);
92         dev->name = NULL;
93         free(dev->binds);
94         dev->binds = NULL;
95 }
96
97 /* to be called by drivers
98  * async devices must set drv_fd_hnd to -1 */
99 void in_register(const char *nname, int drv_fd_hnd, void *drv_data,
100                 int key_count, const char * const *key_names, int combos)
101 {
102         int i, ret, dupe_count = 0, *binds;
103         char name[256], *name_end, *tmp;
104
105         strncpy(name, nname, sizeof(name));
106         name[sizeof(name)-12] = 0;
107         name_end = name + strlen(name);
108
109         for (i = 0; i < in_dev_count; i++)
110         {
111                 if (in_devices[i].name == NULL)
112                         continue;
113                 if (strcmp(in_devices[i].name, name) == 0)
114                 {
115                         if (in_devices[i].probed) {
116                                 dupe_count++;
117                                 sprintf(name_end, " [%d]", dupe_count);
118                                 continue;
119                         }
120                         goto update;
121                 }
122         }
123
124         if (i >= IN_MAX_DEVS)
125         {
126                 /* try to find unused device */
127                 for (i = 0; i < IN_MAX_DEVS; i++)
128                         if (!in_devices[i].probed) break;
129                 if (i >= IN_MAX_DEVS) {
130                         lprintf("input: too many devices, can't add %s\n", name);
131                         return;
132                 }
133                 in_free(&in_devices[i]);
134         }
135
136         tmp = strdup(name);
137         if (tmp == NULL)
138                 return;
139
140         binds = in_alloc_binds(in_probe_dev_id, key_count);
141         if (binds == NULL) {
142                 free(tmp);
143                 return;
144         }
145
146         in_devices[i].name = tmp;
147         in_devices[i].binds = binds;
148         in_devices[i].key_count = key_count;
149         if (i + 1 > in_dev_count)
150                 in_dev_count = i + 1;
151
152         lprintf("input: new device #%d \"%s\"\n", i, name);
153 update:
154         in_devices[i].probed = 1;
155         in_devices[i].does_combos = combos;
156         in_devices[i].drv_id = in_probe_dev_id;
157         in_devices[i].drv_fd_hnd = drv_fd_hnd;
158         in_devices[i].key_names = key_names;
159         in_devices[i].drv_data = drv_data;
160
161         if (in_devices[i].binds != NULL) {
162                 ret = DRV(in_probe_dev_id).clean_binds(drv_data, in_devices[i].binds,
163                         in_devices[i].binds + key_count * IN_BINDTYPE_COUNT);
164                 if (ret == 0) {
165                         /* no useable binds */
166                         free(in_devices[i].binds);
167                         in_devices[i].binds = NULL;
168                 }
169         }
170 }
171
172 /* key combo handling, to be called by drivers that support it.
173  * Only care about IN_BINDTYPE_EMU */
174 void in_combos_find(const int *binds, int last_key, int *combo_keys, int *combo_acts)
175 {
176         int act, u;
177
178         *combo_keys = *combo_acts = 0;
179         for (act = 0; act < sizeof(binds[0]) * 8; act++)
180         {
181                 int keyc = 0;
182                 for (u = 0; u <= last_key; u++)
183                         if (binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)] & (1 << act))
184                                 keyc++;
185
186                 if (keyc > 1)
187                 {
188                         // loop again and mark those keys and actions as combo
189                         for (u = 0; u <= last_key; u++)
190                         {
191                                 if (binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)] & (1 << act)) {
192                                         *combo_keys |= 1 << u;
193                                         *combo_acts |= 1 << act;
194                                 }
195                         }
196                 }
197         }
198 }
199
200 int in_combos_do(int keys, const int *binds, int last_key, int combo_keys, int combo_acts)
201 {
202         int i, ret = 0;
203
204         for (i = 0; i <= last_key; i++)
205         {
206                 int acts, acts_c, u;
207
208                 if (!(keys & (1 << i)))
209                         continue;
210
211                 acts = binds[IN_BIND_OFFS(i, IN_BINDTYPE_EMU)];
212                 if (!acts)
213                         continue;
214
215                 if (!(combo_keys & (1 << i))) {
216                         ret |= acts;
217                         continue;
218                 }
219
220                 acts_c = acts & combo_acts;
221                 u = last_key;
222                 if (acts_c) {
223                         // let's try to find the other one
224                         for (u = i + 1; u <= last_key; u++)
225                                 if ( (keys & (1 << u)) && (binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)] & acts_c) ) {
226                                         ret |= acts_c & binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)];
227                                         keys &= ~((1 << i) | (1 << u));
228                                         break;
229                                 }
230                 }
231                 // add non-combo actions if combo ones were not found
232                 if (u >= last_key)
233                         ret |= acts & ~combo_acts;
234         }
235
236         return ret;
237 }
238
239 void in_probe(void)
240 {
241         int i;
242
243         in_have_async_devs = 0;
244         menu_key_state = 0;
245         menu_last_used_dev = 0;
246
247         for (i = 0; i < in_dev_count; i++)
248                 in_unprobe(&in_devices[i]);
249
250         for (i = 0; i < in_driver_count; i++) {
251                 in_probe_dev_id = i;
252                 in_drivers[i].probe();
253         }
254
255         /* get rid of devs without binds and probes */
256         for (i = 0; i < in_dev_count; i++) {
257                 if (!in_devices[i].probed && in_devices[i].binds == NULL) {
258                         in_dev_count--;
259                         if (i < in_dev_count) {
260                                 free(in_devices[i].name);
261                                 memmove(&in_devices[i], &in_devices[i+1],
262                                         (in_dev_count - i) * sizeof(in_devices[0]));
263                         }
264
265                         continue;
266                 }
267
268                 if (in_devices[i].probed && in_devices[i].drv_fd_hnd == -1)
269                         in_have_async_devs = 1;
270         }
271
272         if (in_have_async_devs)
273                 lprintf("input: async-only devices detected..\n");
274
275         in_debug_dump();
276 }
277
278 /* async update */
279 int in_update(int *result)
280 {
281         int i, ret = 0;
282
283         for (i = 0; i < in_dev_count; i++) {
284                 in_dev_t *dev = &in_devices[i];
285                 if (dev->probed && dev->binds != NULL)
286                         ret |= DRV(dev->drv_id).update(dev->drv_data, dev->binds, result);
287         }
288
289         return ret;
290 }
291
292 static in_dev_t *get_dev(int dev_id)
293 {
294         if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
295                 return NULL;
296
297         return &in_devices[dev_id];
298 }
299
300 int in_update_analog(int dev_id, int axis_id, int *result)
301 {
302         in_dev_t *dev = get_dev(dev_id);
303
304         if (dev == NULL || !dev->probed)
305                 return -1;
306
307         return DRV(dev->drv_id).update_analog(dev->drv_data, axis_id, result);
308 }
309
310 static int in_update_kc_async(int *dev_id_out, int *is_down_out, int timeout_ms)
311 {
312         int i, is_down, result;
313         unsigned int ticks;
314
315         ticks = plat_get_ticks_ms();
316
317         while (1)
318         {
319                 for (i = 0; i < in_dev_count; i++) {
320                         in_dev_t *d = &in_devices[i];
321                         if (!d->probed)
322                                 continue;
323
324                         result = DRV(d->drv_id).update_keycode(d->drv_data, &is_down);
325                         if (result == -1)
326                                 continue;
327
328                         if (dev_id_out)
329                                 *dev_id_out = i;
330                         if (is_down_out)
331                                 *is_down_out = is_down;
332                         return result;
333                 }
334
335                 if (timeout_ms >= 0 && (int)(plat_get_ticks_ms() - ticks) > timeout_ms)
336                         break;
337
338                 plat_sleep_ms(10);
339         }
340
341         return -1;
342 }
343
344 /* 
345  * wait for a press, always return some keycode or -1 on timeout or error
346  */
347 int in_update_keycode(int *dev_id_out, int *is_down_out, char *charcode, int timeout_ms)
348 {
349         int result = -1, dev_id = 0, is_down, result_menu;
350         int fds_hnds[IN_MAX_DEVS];
351         int i, ret, count = 0;
352         in_drv_t *drv = NULL;
353         unsigned int ticks;
354
355         if (in_have_async_devs) {
356                 result = in_update_kc_async(&dev_id, &is_down, timeout_ms);
357                 if (result == -1)
358                         return -1;
359                 drv = &DRV(in_devices[dev_id].drv_id);
360                 goto finish;
361         }
362
363         ticks = plat_get_ticks_ms();
364
365         for (i = 0; i < in_dev_count; i++) {
366                 if (in_devices[i].probed)
367                         fds_hnds[count++] = in_devices[i].drv_fd_hnd;
368         }
369
370         if (count == 0) {
371                 /* don't deadlock, fail */
372                 lprintf("input: failed to find devices to read\n");
373                 exit(1);
374         }
375
376         while (1)
377         {
378                 ret = plat_wait_event(fds_hnds, count, timeout_ms);
379                 if (ret < 0)
380                         break;
381
382                 for (i = 0; i < in_dev_count; i++) {
383                         if (in_devices[i].drv_fd_hnd == ret) {
384                                 dev_id = i;
385                                 break;
386                         }
387                 }
388
389                 drv = &DRV(in_devices[dev_id].drv_id);
390                 result = drv->update_keycode(in_devices[dev_id].drv_data, &is_down);
391                 if (result >= 0)
392                         break;
393
394                 if (result == -2) {
395                         lprintf("input: \"%s\" errored out, removing.\n", in_devices[dev_id].name);
396                         in_unprobe(&in_devices[dev_id]);
397                         break;
398                 }
399
400                 if (timeout_ms >= 0) {
401                         unsigned int ticks2 = plat_get_ticks_ms();
402                         timeout_ms -= ticks2 - ticks;
403                         ticks = ticks2;
404                         if (timeout_ms <= 0)
405                                 break;
406                 }
407         }
408
409         if (result < 0)
410                 return -1;
411 finish:
412         /* keep track of menu key state, to allow mixing
413          * in_update_keycode() and in_menu_wait_any() calls */
414         result_menu = drv->menu_translate(in_devices[dev_id].drv_data, result, charcode);
415         if (result_menu != 0) {
416                 if (is_down)
417                         menu_key_state |=  result_menu;
418                 else
419                         menu_key_state &= ~result_menu;
420         }
421
422         if (dev_id_out != NULL)
423                 *dev_id_out = dev_id;
424         if (is_down_out != NULL)
425                 *is_down_out = is_down;
426         return result;
427 }
428
429 /* same as above, only return bitfield of PBTN_*  */
430 int in_menu_wait_any(char *charcode, int timeout_ms)
431 {
432         int keys_old = menu_key_state;
433
434         while (1)
435         {
436                 int code, is_down = 0, dev_id = 0;
437
438                 code = in_update_keycode(&dev_id, &is_down, charcode, timeout_ms);
439                 if (code < 0)
440                         break;
441
442                 if (keys_old != menu_key_state) {
443                         menu_last_used_dev = dev_id;
444                         break;
445                 }
446         }
447
448         return menu_key_state;
449 }
450
451 /* wait for menu input, do autorepeat */
452 int in_menu_wait(int interesting, char *charcode, int autorep_delay_ms)
453 {
454         static int inp_prev = 0;
455         static int repeats = 0;
456         int ret, release = 0, wait = 450;
457
458         if (repeats)
459                 wait = autorep_delay_ms;
460
461         ret = in_menu_wait_any(charcode, wait);
462         if (ret == inp_prev)
463                 repeats++;
464
465         while (!(ret & interesting)) {
466                 ret = in_menu_wait_any(charcode, -1);
467                 release = 1;
468         }
469
470         if (release || ret != inp_prev)
471                 repeats = 0;
472
473         inp_prev = ret;
474
475         /* we don't need diagonals in menus */
476         if ((ret & PBTN_UP)   && (ret & PBTN_LEFT))  ret &= ~PBTN_LEFT;
477         if ((ret & PBTN_UP)   && (ret & PBTN_RIGHT)) ret &= ~PBTN_RIGHT;
478         if ((ret & PBTN_DOWN) && (ret & PBTN_LEFT))  ret &= ~PBTN_LEFT;
479         if ((ret & PBTN_DOWN) && (ret & PBTN_RIGHT)) ret &= ~PBTN_RIGHT;
480
481         return ret;
482 }
483
484 const int *in_get_dev_binds(int dev_id)
485 {
486         in_dev_t *dev = get_dev(dev_id);
487
488         return dev ? dev->binds : NULL;
489 }
490
491 const int *in_get_dev_def_binds(int dev_id)
492 {
493         in_dev_t *dev = get_dev(dev_id);
494         if (dev == NULL)
495                 return NULL;
496
497         return dev->binds + dev->key_count * IN_BINDTYPE_COUNT;
498 }
499
500 int in_get_config(int dev_id, int what, void *val)
501 {
502         int *ival = val;
503         in_dev_t *dev;
504
505         dev = get_dev(dev_id);
506         if (dev == NULL || val == NULL)
507                 return -1;
508
509         switch (what) {
510         case IN_CFG_BIND_COUNT:
511                 *ival = dev->key_count;
512                 break;
513         case IN_CFG_DOES_COMBOS:
514                 *ival = dev->does_combos;
515                 break;
516         case IN_CFG_BLOCKING:
517         case IN_CFG_KEY_NAMES:
518                 return -1; /* not implemented */
519         default:
520                 return DRV(dev->drv_id).get_config(dev->drv_data, what, ival);
521         }
522
523         return 0;
524 }
525
526 static int in_set_blocking(int is_blocking)
527 {
528         int i, ret;
529
530         /* have_async_devs means we will have to do all reads async anyway.. */
531         if (!in_have_async_devs) {
532                 for (i = 0; i < in_dev_count; i++) {
533                         if (in_devices[i].probed)
534                                 DRV(in_devices[i].drv_id).set_config(in_devices[i].drv_data,
535                                                                      IN_CFG_BLOCKING, is_blocking);
536                 }
537         }
538
539         menu_key_state = 0;
540
541         /* flush events */
542         do {
543                 ret = in_update_keycode(NULL, NULL, NULL, 0);
544         } while (ret >= 0);
545
546         return 0;
547 }
548
549 int in_set_config(int dev_id, int what, const void *val, int size)
550 {
551         const char * const *names;
552         const int *ival = val;
553         in_dev_t *dev;
554         int count;
555
556         if (what == IN_CFG_BLOCKING)
557                 return in_set_blocking(*ival);
558
559         dev = get_dev(dev_id);
560         if (dev == NULL)
561                 return -1;
562
563         switch (what) {
564         case IN_CFG_KEY_NAMES:
565                 names = val;
566                 count = size / sizeof(names[0]);
567
568                 if (count < dev->key_count) {
569                         lprintf("input: set_key_names: not enough keys\n");
570                         return -1;
571                 }
572
573                 dev->key_names = names;
574                 return 0;
575         case IN_CFG_DEFAULT_DEV:
576                 /* just set last used dev, for now */
577                 menu_last_used_dev = dev_id;
578                 return 0;
579         default:
580                 break;
581         }
582
583         if (dev->probed)
584                 return DRV(dev->drv_id).set_config(dev->drv_data, what, *ival);
585
586         return -1;
587 }
588
589 const char *in_get_dev_name(int dev_id, int must_be_active, int skip_pfix)
590 {
591         const char *name, *tmp;
592         in_dev_t *dev;
593
594         dev = get_dev(dev_id);
595         if (dev == NULL)
596                 return NULL;
597
598         if (must_be_active && !dev->probed)
599                 return NULL;
600
601         name = dev->name;
602         if (name == NULL || !skip_pfix)
603                 return name;
604
605         /* skip prefix */
606         tmp = strchr(name, ':');
607         if (tmp != NULL)
608                 name = tmp + 1;
609
610         return name;
611 }
612
613 int in_name_to_id(const char *dev_name)
614 {
615         int i;
616
617         for (i = 0; i < in_dev_count; i++)
618                 if (strcmp(dev_name, in_devices[i].name) == 0)
619                         break;
620
621         if (i >= in_dev_count) {
622                 lprintf("input: in_name_to_id: no such device: %s\n", dev_name);
623                 return -1;
624         }
625
626         return i;
627 }
628
629 /* never returns NULL */
630 const char *in_get_key_name(int dev_id, int keycode)
631 {
632         const char *name = NULL;
633         static char xname[16];
634         in_drv_t *drv;
635         in_dev_t *dev;
636
637         if (dev_id < 0)         /* want last used dev? */
638                 dev_id = menu_last_used_dev;
639
640         dev = get_dev(dev_id);
641         if (dev == NULL)
642                 return "Unkn0";
643
644         drv = &DRV(dev->drv_id);
645         if (keycode < 0)        /* want name for menu key? */
646                 keycode = drv->menu_translate(dev->drv_data, keycode, NULL);
647
648         if (dev->key_names != NULL && 0 <= keycode && keycode < dev->key_count)
649                 name = dev->key_names[keycode];
650         if (name != NULL)
651                 return name;
652
653         if (drv->get_key_name != NULL)
654                 name = drv->get_key_name(keycode);
655         if (name != NULL)
656                 return name;
657
658         /* assume scancode */
659         if ((keycode >= '0' && keycode <= '9') || (keycode >= 'a' && keycode <= 'z')
660                         || (keycode >= 'A' && keycode <= 'Z'))
661                 sprintf(xname, "%c", keycode);
662         else
663                 sprintf(xname, "\\x%02X", keycode);
664         return xname;
665 }
666
667 int in_get_key_code(int dev_id, const char *key_name)
668 {
669         in_dev_t *dev;
670         int i;
671
672         if (dev_id < 0)         /* want last used dev? */
673                 dev_id = menu_last_used_dev;
674
675         dev = get_dev(dev_id);
676         if (dev == NULL)
677                 return -1;
678
679         if (dev->key_names == NULL)
680                 return -1;
681
682         for (i = 0; i < dev->key_count; i++)
683                 if (dev->key_names[i] && strcasecmp(dev->key_names[i], key_name) == 0)
684                         return i;
685
686         return -1;
687 }
688
689 int in_bind_key(int dev_id, int keycode, int mask, int bind_type, int force_unbind)
690 {
691         int ret, count;
692         in_dev_t *dev;
693
694         dev = get_dev(dev_id);
695         if (dev == NULL || bind_type >= IN_BINDTYPE_COUNT)
696                 return -1;
697
698         count = dev->key_count;
699
700         if (dev->binds == NULL) {
701                 if (force_unbind)
702                         return 0;
703                 dev->binds = in_alloc_binds(dev->drv_id, count);
704                 if (dev->binds == NULL)
705                         return -1;
706         }
707
708         if (keycode < 0 || keycode >= count)
709                 return -1;
710         
711         if (force_unbind)
712                 dev->binds[IN_BIND_OFFS(keycode, bind_type)] &= ~mask;
713         else
714                 dev->binds[IN_BIND_OFFS(keycode, bind_type)] ^=  mask;
715         
716         ret = DRV(dev->drv_id).clean_binds(dev->drv_data, dev->binds,
717                                 dev->binds + count * IN_BINDTYPE_COUNT);
718         if (ret == 0) {
719                 free(dev->binds);
720                 dev->binds = NULL;
721         }
722
723         return 0;
724 }
725
726 /*
727  * Unbind act_mask on binds with type bind_type
728  * - if dev_id_ < 0, affects all devices
729  *   else only affects dev_id_
730  * - if act_mask == -1, unbind all keys
731  *   else only actions in mask
732  */
733 void in_unbind_all(int dev_id_, int act_mask, int bind_type)
734 {
735         int dev_id = 0, dev_last = IN_MAX_DEVS - 1;
736         int i, count;
737         in_dev_t *dev;
738
739         if (dev_id_ >= 0)
740                 dev_id = dev_last = dev_id_;
741
742         if (bind_type >= IN_BINDTYPE_COUNT)
743                 return;
744
745         for (; dev_id <= dev_last; dev_id++) {
746                 dev = &in_devices[dev_id];
747                 count = dev->key_count;
748
749                 if (dev->binds == NULL)
750                         continue;
751
752                 if (act_mask != -1) {
753                         for (i = 0; i < count; i++)
754                                 dev->binds[IN_BIND_OFFS(i, bind_type)] &= ~act_mask;
755                 }
756                 else
757                         memset(dev->binds, 0, sizeof(dev->binds[0]) * count * IN_BINDTYPE_COUNT);
758         }
759 }
760
761 /* returns device id, or -1 on error */
762 int in_config_parse_dev(const char *name)
763 {
764         int drv_id = -1, i;
765
766         for (i = 0; i < in_driver_count; i++) {
767                 int len = strlen(in_drivers[i].prefix);
768                 if (strncmp(name, in_drivers[i].prefix, len) == 0) {
769                         drv_id = i;
770                         break;
771                 }
772         }
773
774         if (drv_id < 0) {
775                 lprintf("input: missing driver for %s\n", name);
776                 return -1;
777         }
778
779         for (i = 0; i < in_dev_count; i++)
780         {
781                 if (in_devices[i].name == NULL)
782                         continue;
783                 if (strcmp(in_devices[i].name, name) == 0)
784                         return i;
785         }
786
787         if (i >= IN_MAX_DEVS)
788         {
789                 /* try to find unused device */
790                 for (i = 0; i < IN_MAX_DEVS; i++)
791                         if (in_devices[i].name == NULL) break;
792                 if (i >= IN_MAX_DEVS) {
793                         lprintf("input: too many devices, can't add %s\n", name);
794                         return -1;
795                 }
796         }
797
798         memset(&in_devices[i], 0, sizeof(in_devices[i]));
799
800         in_devices[i].name = strdup(name);
801         if (in_devices[i].name == NULL)
802                 return -1;
803
804         in_devices[i].key_names = DRV(drv_id).get_key_names(&in_devices[i].key_count);
805         in_devices[i].drv_id = drv_id;
806
807         if (i + 1 > in_dev_count)
808                 in_dev_count = i + 1;
809
810         return i;
811 }
812
813 int in_config_bind_key(int dev_id, const char *key, int acts, int bind_type)
814 {
815         in_dev_t *dev;
816         int i, offs, kc;
817
818         dev = get_dev(dev_id);
819         if (dev == NULL || bind_type >= IN_BINDTYPE_COUNT)
820                 return -1;
821
822         /* maybe a raw code? */
823         if (key[0] == '\\' && key[1] == 'x') {
824                 char *p = NULL;
825                 kc = (int)strtoul(key + 2, &p, 16);
826                 if (p == NULL || *p != 0)
827                         kc = -1;
828         }
829         else {
830                 /* device specific key name */
831                 if (dev->binds == NULL) {
832                         dev->binds = in_alloc_binds(dev->drv_id, dev->key_count);
833                         if (dev->binds == NULL)
834                                 return -1;
835                 }
836
837                 kc = -1;
838                 if (dev->key_names != NULL) {
839                         for (i = 0; i < dev->key_count; i++) {
840                                 const char *k = dev->key_names[i];
841                                 if (k != NULL && strcasecmp(k, key) == 0) {
842                                         kc = i;
843                                         break;
844                                 }
845                         }
846                 }
847
848                 if (kc < 0)
849                         kc = DRV(dev->drv_id).get_key_code(key);
850                 if (kc < 0 && strlen(key) == 1) {
851                         /* assume scancode */
852                         kc = key[0];
853                 }
854         }
855
856         if (kc < 0 || kc >= dev->key_count) {
857                 lprintf("input: bad key: %s\n", key);
858                 return -1;
859         }
860
861         if (bind_type == IN_BINDTYPE_NONE) {
862                 for (i = 0; i < IN_BINDTYPE_COUNT; i++)
863                         dev->binds[IN_BIND_OFFS(kc, i)] = 0;
864                 return 0;
865         }
866
867         offs = IN_BIND_OFFS(kc, bind_type);
868         if (dev->binds[offs] == -1)
869                 dev->binds[offs] = 0;
870         dev->binds[offs] |= acts;
871         return 0;
872 }
873
874 void in_clean_binds(void)
875 {
876         int i;
877
878         for (i = 0; i < IN_MAX_DEVS; i++) {
879                 int ret, count, *binds, *def_binds;
880                 in_dev_t *dev = &in_devices[i];
881
882                 if (dev->binds == NULL || dev->drv_data == NULL)
883                         continue;
884
885                 count = dev->key_count;
886                 binds = dev->binds;
887                 def_binds = binds + count * IN_BINDTYPE_COUNT;
888
889                 ret = DRV(dev->drv_id).clean_binds(dev->drv_data, binds, def_binds);
890                 if (ret == 0) {
891                         /* no useable binds */
892                         free(dev->binds);
893                         dev->binds = NULL;
894                 }
895         }
896 }
897
898 void in_debug_dump(void)
899 {
900         int i;
901
902         lprintf("# drv probed binds name\n");
903         for (i = 0; i < IN_MAX_DEVS; i++) {
904                 in_dev_t *d = &in_devices[i];
905                 if (!d->probed && d->name == NULL && d->binds == NULL)
906                         continue;
907                 lprintf("%d %3d %6c %5c %s\n", i, d->drv_id, d->probed ? 'y' : 'n',
908                         d->binds ? 'y' : 'n', d->name);
909         }
910 }
911
912 /* stubs for drivers that choose not to implement something */
913
914 static void in_def_free(void *drv_data) {}
915 static int  in_def_clean_binds(void *drv_data, int *b, int *db) { return 1; }
916 static int  in_def_get_config(void *drv_data, int what, int *val) { return -1; }
917 static int  in_def_set_config(void *drv_data, int what, int val) { return -1; }
918 static int  in_def_update_analog(void *drv_data, int axis_id, int *result) { return -1; }
919 static int  in_def_update_keycode(void *drv_data, int *is_down) { return 0; }
920 static int  in_def_menu_translate(void *drv_data, int keycode, char *ccode) { return 0; }
921 static int  in_def_get_key_code(const char *key_name) { return -1; }
922 static const char *in_def_get_key_name(int keycode) { return NULL; }
923
924 #define CHECK_ADD_STUB(d, f) \
925         if (d.f == NULL) d.f = in_def_##f
926
927 /* to be called by drivers */
928 int in_register_driver(const in_drv_t *drv, const struct in_default_bind *defbinds)
929 {
930         int count_new = in_driver_count + 1;
931         in_drv_t *new_drivers;
932
933         new_drivers = realloc(in_drivers, count_new * sizeof(in_drivers[0]));
934         if (new_drivers == NULL) {
935                 lprintf("input: in_register_driver OOM\n");
936                 return -1;
937         }
938
939         memcpy(&new_drivers[in_driver_count], drv, sizeof(new_drivers[0]));
940
941         CHECK_ADD_STUB(new_drivers[in_driver_count], free);
942         CHECK_ADD_STUB(new_drivers[in_driver_count], clean_binds);
943         CHECK_ADD_STUB(new_drivers[in_driver_count], get_config);
944         CHECK_ADD_STUB(new_drivers[in_driver_count], set_config);
945         CHECK_ADD_STUB(new_drivers[in_driver_count], update_analog);
946         CHECK_ADD_STUB(new_drivers[in_driver_count], update_keycode);
947         CHECK_ADD_STUB(new_drivers[in_driver_count], menu_translate);
948         CHECK_ADD_STUB(new_drivers[in_driver_count], get_key_code);
949         CHECK_ADD_STUB(new_drivers[in_driver_count], get_key_name);
950         if (defbinds != NULL)
951                 new_drivers[in_driver_count].defbinds = defbinds;
952         in_drivers = new_drivers;
953         in_driver_count = count_new;
954
955         return 0;
956 }
957
958 void in_init(void)
959 {
960         in_drivers = NULL;
961         memset(in_devices, 0, sizeof(in_devices));
962         in_driver_count = 0;
963         in_dev_count = 0;
964 }
965
966 #if 0
967 int main(void)
968 {
969         int ret;
970
971         in_init();
972         in_probe();
973
974         in_set_blocking(1);
975
976 #if 1
977         while (1) {
978                 int dev = 0, down;
979                 ret = in_update_keycode(&dev, &down);
980                 lprintf("#%i: %i %i (%s)\n", dev, down, ret, in_get_key_name(dev, ret));
981         }
982 #else
983         while (1) {
984                 ret = in_menu_wait_any();
985                 lprintf("%08x\n", ret);
986         }
987 #endif
988
989         return 0;
990 }
991 #endif