source: mainline/uspace/srv/hid/input/input.c@ 2b95d13

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 2b95d13 was 2b95d13, checked in by Jakub Jermar <jakub@…>, 12 years ago

Merge mainline changes.
  • Property mode set to 100644
File size: 15.6 KB
Line 
1/*
2 * Copyright (c) 2006 Josef Cejka
3 * Copyright (c) 2011 Jiri Svoboda
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/**
31 * @addtogroup inputgen generic
32 * @brief HelenOS input server.
33 * @ingroup input
34 * @{
35 */
36/** @file
37 */
38
39#include <adt/list.h>
40#include <stdbool.h>
41#include <fibril_synch.h>
42#include <ipc/services.h>
43#include <ipc/input.h>
44#include <sysinfo.h>
45#include <stdio.h>
46#include <unistd.h>
47#include <stdlib.h>
48#include <stdio.h>
49#include <ns.h>
50#include <async.h>
51#include <errno.h>
52#include <adt/fifo.h>
53#include <io/console.h>
54#include <io/keycode.h>
55#include <loc.h>
56#include "layout.h"
57#include "kbd.h"
58#include "kbd_port.h"
59#include "kbd_ctl.h"
60#include "mouse.h"
61#include "mouse_proto.h"
62#include "input.h"
63
64#define NUM_LAYOUTS 4
65
66static layout_ops_t *layout[NUM_LAYOUTS] = {
67 &us_qwerty_ops,
68 &us_dvorak_ops,
69 &cz_ops,
70 &ar_ops
71};
72
73static void kbd_devs_yield(void);
74static void kbd_devs_reclaim(void);
75
76async_sess_t *client_sess = NULL;
77
78/** List of keyboard devices */
79static list_t kbd_devs;
80
81/** List of mouse devices */
82static list_t mouse_devs;
83
84bool irc_service = false;
85async_sess_t *irc_sess = NULL;
86
87static FIBRIL_MUTEX_INITIALIZE(discovery_lock);
88
89void kbd_push_data(kbd_dev_t *kdev, sysarg_t data)
90{
91 (*kdev->ctl_ops->parse)(data);
92}
93
94void mouse_push_data(mouse_dev_t *mdev, sysarg_t data)
95{
96 (*mdev->proto_ops->parse)(data);
97}
98
99void kbd_push_event(kbd_dev_t *kdev, int type, unsigned int key)
100{
101 kbd_event_t ev;
102 unsigned int mod_mask;
103
104 switch (key) {
105 case KC_LCTRL: mod_mask = KM_LCTRL; break;
106 case KC_RCTRL: mod_mask = KM_RCTRL; break;
107 case KC_LSHIFT: mod_mask = KM_LSHIFT; break;
108 case KC_RSHIFT: mod_mask = KM_RSHIFT; break;
109 case KC_LALT: mod_mask = KM_LALT; break;
110 case KC_RALT: mod_mask = KM_RALT; break;
111 default: mod_mask = 0; break;
112 }
113
114 if (mod_mask != 0) {
115 if (type == KEY_PRESS)
116 kdev->mods = kdev->mods | mod_mask;
117 else
118 kdev->mods = kdev->mods & ~mod_mask;
119 }
120
121 switch (key) {
122 case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
123 case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
124 case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
125 default: mod_mask = 0; break;
126 }
127
128 if (mod_mask != 0) {
129 if (type == KEY_PRESS) {
130 /*
131 * Only change lock state on transition from released
132 * to pressed. This prevents autorepeat from messing
133 * up the lock state.
134 */
135 kdev->mods = kdev->mods ^ (mod_mask & ~kdev->lock_keys);
136 kdev->lock_keys = kdev->lock_keys | mod_mask;
137
138 /* Update keyboard lock indicator lights. */
139 (*kdev->ctl_ops->set_ind)(kdev, kdev->mods);
140 } else {
141 kdev->lock_keys = kdev->lock_keys & ~mod_mask;
142 }
143 }
144
145 if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
146 key == KC_F1) {
147 layout_destroy(kdev->active_layout);
148 kdev->active_layout = layout_create(layout[0]);
149 return;
150 }
151
152 if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
153 key == KC_F2) {
154 layout_destroy(kdev->active_layout);
155 kdev->active_layout = layout_create(layout[1]);
156 return;
157 }
158
159 if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
160 key == KC_F3) {
161 layout_destroy(kdev->active_layout);
162 kdev->active_layout = layout_create(layout[2]);
163 return;
164 }
165
166 if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
167 key == KC_F4) {
168 layout_destroy(kdev->active_layout);
169 kdev->active_layout = layout_create(layout[3]);
170 return;
171 }
172
173 ev.type = type;
174 ev.key = key;
175 ev.mods = kdev->mods;
176
177 ev.c = layout_parse_ev(kdev->active_layout, &ev);
178
179 async_exch_t *exch = async_exchange_begin(client_sess);
180 async_msg_4(exch, INPUT_EVENT_KEY, ev.type, ev.key, ev.mods, ev.c);
181 async_exchange_end(exch);
182}
183
184/** Mouse pointer has moved. */
185void mouse_push_event_move(mouse_dev_t *mdev, int dx, int dy, int dz)
186{
187 async_exch_t *exch = async_exchange_begin(client_sess);
188 if (dx || dy)
189 async_msg_2(exch, INPUT_EVENT_MOVE, dx, dy);
190 if (dz) {
191 // TODO: Implement proper wheel support
192 keycode_t code = dz > 0 ? KC_UP : KC_DOWN;
193 for (int i = 0; i < 3; ++i) {
194 async_msg_4(exch, INPUT_EVENT_KEY, KEY_PRESS, code, 0, 0);
195 }
196 async_msg_4(exch, INPUT_EVENT_KEY, KEY_RELEASE, code, 0, 0);
197 }
198 async_exchange_end(exch);
199}
200
201/** Mouse pointer has moved in absolute mode. */
202void mouse_push_event_abs_move(mouse_dev_t *mdev, unsigned int x, unsigned int y,
203 unsigned int max_x, unsigned int max_y)
204{
205 if (max_x && max_y) {
206 async_exch_t *exch = async_exchange_begin(client_sess);
207 async_msg_4(exch, INPUT_EVENT_ABS_MOVE, x, y, max_x, max_y);
208 async_exchange_end(exch);
209 }
210}
211
212/** Mouse button has been pressed. */
213void mouse_push_event_button(mouse_dev_t *mdev, int bnum, int press)
214{
215 async_exch_t *exch = async_exchange_begin(client_sess);
216 async_msg_2(exch, INPUT_EVENT_BUTTON, bnum, press);
217 async_exchange_end(exch);
218}
219
220static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
221{
222 async_answer_0(iid, EOK);
223
224 while (true) {
225 ipc_call_t call;
226 ipc_callid_t callid = async_get_call(&call);
227
228 if (!IPC_GET_IMETHOD(call)) {
229 if (client_sess != NULL) {
230 async_hangup(client_sess);
231 client_sess = NULL;
232 }
233
234 async_answer_0(callid, EOK);
235 return;
236 }
237
238 async_sess_t *sess =
239 async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
240 if (sess != NULL) {
241 if (client_sess == NULL) {
242 client_sess = sess;
243 async_answer_0(callid, EOK);
244 } else
245 async_answer_0(callid, ELIMIT);
246 } else {
247 switch (IPC_GET_IMETHOD(call)) {
248 case INPUT_YIELD:
249 kbd_devs_yield();
250 async_answer_0(callid, EOK);
251 break;
252 case INPUT_RECLAIM:
253 kbd_devs_reclaim();
254 async_answer_0(callid, EOK);
255 break;
256 default:
257 async_answer_0(callid, EINVAL);
258 }
259 }
260 }
261}
262
263static kbd_dev_t *kbd_dev_new(void)
264{
265 kbd_dev_t *kdev = calloc(1, sizeof(kbd_dev_t));
266 if (kdev == NULL) {
267 printf("%s: Error allocating keyboard device. "
268 "Out of memory.\n", NAME);
269 return NULL;
270 }
271
272 link_initialize(&kdev->kbd_devs);
273
274 kdev->mods = KM_NUM_LOCK;
275 kdev->lock_keys = 0;
276 kdev->active_layout = layout_create(layout[0]);
277
278 return kdev;
279}
280
281static mouse_dev_t *mouse_dev_new(void)
282{
283 mouse_dev_t *mdev = calloc(1, sizeof(mouse_dev_t));
284 if (mdev == NULL) {
285 printf("%s: Error allocating keyboard device. "
286 "Out of memory.\n", NAME);
287 return NULL;
288 }
289
290 link_initialize(&mdev->mouse_devs);
291
292 return mdev;
293}
294
295/** Add new legacy keyboard device. */
296static void kbd_add_dev(kbd_port_ops_t *port, kbd_ctl_ops_t *ctl)
297{
298 kbd_dev_t *kdev = kbd_dev_new();
299 if (kdev == NULL)
300 return;
301
302 kdev->port_ops = port;
303 kdev->ctl_ops = ctl;
304 kdev->svc_id = 0;
305
306 /* Initialize port driver. */
307 if ((*kdev->port_ops->init)(kdev) != 0)
308 goto fail;
309
310 /* Initialize controller driver. */
311 if ((*kdev->ctl_ops->init)(kdev) != 0) {
312 /* XXX Uninit port */
313 goto fail;
314 }
315
316 list_append(&kdev->kbd_devs, &kbd_devs);
317 return;
318
319fail:
320 free(kdev);
321}
322
323/** Add new legacy mouse device. */
324static void mouse_add_dev(mouse_port_ops_t *port, mouse_proto_ops_t *proto)
325{
326 mouse_dev_t *mdev = mouse_dev_new();
327 if (mdev == NULL)
328 return;
329
330 mdev->port_ops = port;
331 mdev->proto_ops = proto;
332 mdev->svc_id = 0;
333
334 /* Initialize port driver. */
335 if ((*mdev->port_ops->init)(mdev) != 0)
336 goto fail;
337
338 /* Initialize protocol driver. */
339 if ((*mdev->proto_ops->init)(mdev) != 0) {
340 /* XXX Uninit port */
341 goto fail;
342 }
343
344 list_append(&mdev->mouse_devs, &mouse_devs);
345 return;
346
347fail:
348 free(mdev);
349}
350
351/** Add new kbdev device.
352 *
353 * @param service_id Service ID of the keyboard device
354 *
355 */
356static int kbd_add_kbdev(service_id_t service_id, kbd_dev_t **kdevp)
357{
358 kbd_dev_t *kdev = kbd_dev_new();
359 if (kdev == NULL)
360 return -1;
361
362 kdev->svc_id = service_id;
363 kdev->port_ops = NULL;
364 kdev->ctl_ops = &kbdev_ctl;
365
366 int rc = loc_service_get_name(service_id, &kdev->svc_name);
367 if (rc != EOK) {
368 kdev->svc_name = NULL;
369 goto fail;
370 }
371
372 /* Initialize controller driver. */
373 if ((*kdev->ctl_ops->init)(kdev) != 0) {
374 goto fail;
375 }
376
377 list_append(&kdev->kbd_devs, &kbd_devs);
378 *kdevp = kdev;
379 return EOK;
380
381fail:
382 if (kdev->svc_name != NULL)
383 free(kdev->svc_name);
384 free(kdev);
385 return -1;
386}
387
388/** Add new mousedev device.
389 *
390 * @param service_id Service ID of the mouse device
391 *
392 */
393static int mouse_add_mousedev(service_id_t service_id, mouse_dev_t **mdevp)
394{
395 mouse_dev_t *mdev = mouse_dev_new();
396 if (mdev == NULL)
397 return -1;
398
399 mdev->svc_id = service_id;
400 mdev->port_ops = NULL;
401 mdev->proto_ops = &mousedev_proto;
402
403 int rc = loc_service_get_name(service_id, &mdev->svc_name);
404 if (rc != EOK) {
405 mdev->svc_name = NULL;
406 goto fail;
407 }
408
409 /* Initialize controller driver. */
410 if ((*mdev->proto_ops->init)(mdev) != 0) {
411 goto fail;
412 }
413
414 list_append(&mdev->mouse_devs, &mouse_devs);
415 *mdevp = mdev;
416 return EOK;
417
418fail:
419 free(mdev);
420 return -1;
421}
422
423/** Add legacy drivers/devices. */
424static void kbd_add_legacy_devs(void)
425{
426 /*
427 * Need to add these drivers based on config unless we can probe
428 * them automatically.
429 */
430#if defined(UARCH_arm32) && defined(MACHINE_gta02)
431 kbd_add_dev(&chardev_port, &stty_ctl);
432#endif
433#if defined(UARCH_arm32) && defined(MACHINE_integratorcp)
434 kbd_add_dev(&pl050_port, &pc_ctl);
435#endif
436#if defined(MACHINE_ski)
437 kbd_add_dev(&ski_port, &stty_ctl);
438#endif
439#if defined(MACHINE_msim)
440 kbd_add_dev(&msim_port, &stty_ctl);
441#endif
442#if defined(UARCH_ppc32)
443 kbd_add_dev(&adb_port, &apple_ctl);
444#endif
445#if defined(UARCH_sparc64) && defined(PROCESSOR_sun4v)
446 kbd_add_dev(&niagara_port, &stty_ctl);
447#endif
448#if defined(UARCH_sparc64) && defined(MACHINE_generic)
449 kbd_add_dev(&ns16550_port, &sun_ctl);
450#endif
451 /* Silence warning on abs32le about kbd_add_dev() being unused */
452 (void) kbd_add_dev;
453}
454
455/** Add legacy drivers/devices. */
456static void mouse_add_legacy_devs(void)
457{
458 /*
459 * Need to add these drivers based on config unless we can probe
460 * them automatically.
461 */
462#if defined(UARCH_ppc32)
463 mouse_add_dev(&adb_mouse_port, &adb_proto);
464#endif
465 /* Silence warning on abs32le about mouse_add_dev() being unused */
466 (void) mouse_add_dev;
467}
468
469static void kbd_devs_yield(void)
470{
471 /* For each keyboard device */
472 list_foreach(kbd_devs, kdev_link) {
473 kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t,
474 kbd_devs);
475
476 /* Yield port */
477 if (kdev->port_ops != NULL)
478 (*kdev->port_ops->yield)();
479 }
480}
481
482static void kbd_devs_reclaim(void)
483{
484 /* For each keyboard device */
485 list_foreach(kbd_devs, kdev_link) {
486 kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t,
487 kbd_devs);
488
489 /* Reclaim port */
490 if (kdev->port_ops != NULL)
491 (*kdev->port_ops->reclaim)();
492 }
493}
494
495static int dev_check_new_kbdevs(void)
496{
497 category_id_t keyboard_cat;
498 service_id_t *svcs;
499 size_t count, i;
500 bool already_known;
501 int rc;
502
503 rc = loc_category_get_id("keyboard", &keyboard_cat, IPC_FLAG_BLOCKING);
504 if (rc != EOK) {
505 printf("%s: Failed resolving category 'keyboard'.\n", NAME);
506 return ENOENT;
507 }
508
509 /*
510 * Check for new keyboard devices
511 */
512 rc = loc_category_get_svcs(keyboard_cat, &svcs, &count);
513 if (rc != EOK) {
514 printf("%s: Failed getting list of keyboard devices.\n",
515 NAME);
516 return EIO;
517 }
518
519 for (i = 0; i < count; i++) {
520 already_known = false;
521
522 /* Determine whether we already know this device. */
523 list_foreach(kbd_devs, kdev_link) {
524 kbd_dev_t *kdev = list_get_instance(kdev_link,
525 kbd_dev_t, kbd_devs);
526 if (kdev->svc_id == svcs[i]) {
527 already_known = true;
528 break;
529 }
530 }
531
532 if (!already_known) {
533 kbd_dev_t *kdev;
534 if (kbd_add_kbdev(svcs[i], &kdev) == EOK) {
535 printf("%s: Connected keyboard device '%s'\n",
536 NAME, kdev->svc_name);
537 }
538 }
539 }
540
541 free(svcs);
542
543 /* XXX Handle device removal */
544
545 return EOK;
546}
547
548static int dev_check_new_mousedevs(void)
549{
550 category_id_t mouse_cat;
551 service_id_t *svcs;
552 size_t count, i;
553 bool already_known;
554 int rc;
555
556 rc = loc_category_get_id("mouse", &mouse_cat, IPC_FLAG_BLOCKING);
557 if (rc != EOK) {
558 printf("%s: Failed resolving category 'mouse'.\n", NAME);
559 return ENOENT;
560 }
561
562 /*
563 * Check for new mouse devices
564 */
565 rc = loc_category_get_svcs(mouse_cat, &svcs, &count);
566 if (rc != EOK) {
567 printf("%s: Failed getting list of mouse devices.\n",
568 NAME);
569 return EIO;
570 }
571
572 for (i = 0; i < count; i++) {
573 already_known = false;
574
575 /* Determine whether we already know this device. */
576 list_foreach(mouse_devs, mdev_link) {
577 mouse_dev_t *mdev = list_get_instance(mdev_link,
578 mouse_dev_t, mouse_devs);
579 if (mdev->svc_id == svcs[i]) {
580 already_known = true;
581 break;
582 }
583 }
584
585 if (!already_known) {
586 mouse_dev_t *mdev;
587 if (mouse_add_mousedev(svcs[i], &mdev) == EOK) {
588 printf("%s: Connected mouse device '%s'\n",
589 NAME, mdev->svc_name);
590 }
591 }
592 }
593
594 free(svcs);
595
596 /* XXX Handle device removal */
597
598 return EOK;
599}
600
601static int dev_check_new(void)
602{
603 int rc;
604
605 fibril_mutex_lock(&discovery_lock);
606
607 rc = dev_check_new_kbdevs();
608 if (rc != EOK) {
609 fibril_mutex_unlock(&discovery_lock);
610 return rc;
611 }
612
613 rc = dev_check_new_mousedevs();
614 if (rc != EOK) {
615 fibril_mutex_unlock(&discovery_lock);
616 return rc;
617 }
618
619 fibril_mutex_unlock(&discovery_lock);
620
621 return EOK;
622}
623
624static void cat_change_cb(void)
625{
626 dev_check_new();
627}
628
629/** Start listening for new devices. */
630static int input_start_dev_discovery(void)
631{
632 int rc;
633
634 rc = loc_register_cat_change_cb(cat_change_cb);
635 if (rc != EOK) {
636 printf("%s: Failed registering callback for device discovery. "
637 "(%d)\n", NAME, rc);
638 return rc;
639 }
640
641 return dev_check_new();
642}
643
644static void usage(char *name)
645{
646 printf("Usage: %s <service_name>\n", name);
647}
648
649int main(int argc, char **argv)
650{
651 if (argc < 2) {
652 usage(argv[0]);
653 return 1;
654 }
655
656 printf("%s: HelenOS input service\n", NAME);
657
658 sysarg_t obio;
659
660 list_initialize(&kbd_devs);
661 list_initialize(&mouse_devs);
662
663 if ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))
664 irc_service = true;
665
666 if (irc_service) {
667 while (irc_sess == NULL)
668 irc_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
669 SERVICE_IRC, 0, 0);
670 }
671
672 /* Add legacy keyboard devices. */
673 kbd_add_legacy_devs();
674
675 /* Add legacy mouse devices. */
676 mouse_add_legacy_devs();
677
678 /* Register driver */
679 async_set_client_connection(client_connection);
680 int rc = loc_server_register(NAME);
681 if (rc != EOK) {
682 printf("%s: Unable to register server\n", NAME);
683 return rc;
684 }
685
686 service_id_t service_id;
687 rc = loc_service_register(argv[1], &service_id);
688 if (rc != EOK) {
689 printf("%s: Unable to register service %s\n", NAME, argv[1]);
690 return rc;
691 }
692
693 /* Start looking for new input devices */
694 input_start_dev_discovery();
695
696 printf("%s: Accepting connections\n", NAME);
697 task_retval(0);
698 async_manager();
699
700 /* Not reached. */
701 return 0;
702}
703
704/**
705 * @}
706 */
Note: See TracBrowser for help on using the repository browser.