source: mainline/uspace/srv/hid/input/generic/input.c@ 711e7fe5

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 711e7fe5 was 711e7fe5, checked in by Prutkov Alex <prutkov.alex@…>, 14 years ago

Added printf module
  • Property mode set to 100755
File size: 15.5 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 <bool.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 <input.h>
57#include <kbd.h>
58#include <kbd_port.h>
59#include <kbd_ctl.h>
60#include <mouse_proto.h>
61#include <layout.h>
62#include <mouse.h>
63
64#define NUM_LAYOUTS 3
65
66static layout_ops_t *layout[NUM_LAYOUTS] = {
67 &us_qwerty_ops,
68 &us_dvorak_ops,
69 &cz_ops
70};
71
72static void kbd_devs_yield(void);
73static void kbd_devs_reclaim(void);
74
75async_sess_t *client_sess = NULL;
76
77/** List of keyboard devices */
78static list_t kbd_devs;
79
80/** List of mouse devices */
81static list_t mouse_devs;
82
83bool irc_service = false;
84async_sess_t *irc_sess = NULL;
85
86static FIBRIL_MUTEX_INITIALIZE(discovery_lock);
87
88void kbd_push_data(kbd_dev_t *kdev, sysarg_t data)
89{
90 (*kdev->ctl_ops->parse)(data);
91}
92
93void mouse_push_data(mouse_dev_t *mdev, sysarg_t data)
94{
95 (*mdev->proto_ops->parse)(data);
96}
97
98void kbd_push_event(kbd_dev_t *kdev, int type, unsigned int key)
99{
100 kbd_event_t ev;
101 unsigned int mod_mask;
102
103 switch (key) {
104 case KC_LCTRL: mod_mask = KM_LCTRL; break;
105 case KC_RCTRL: mod_mask = KM_RCTRL; break;
106 case KC_LSHIFT: mod_mask = KM_LSHIFT; break;
107 case KC_RSHIFT: mod_mask = KM_RSHIFT; break;
108 case KC_LALT: mod_mask = KM_LALT; break;
109 case KC_RALT: mod_mask = KM_RALT; break;
110 default: mod_mask = 0; break;
111 }
112
113 if (mod_mask != 0) {
114 if (type == KEY_PRESS)
115 kdev->mods = kdev->mods | mod_mask;
116 else
117 kdev->mods = kdev->mods & ~mod_mask;
118 }
119
120 switch (key) {
121 case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
122 case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
123 case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
124 default: mod_mask = 0; break;
125 }
126
127 if (mod_mask != 0) {
128 if (type == KEY_PRESS) {
129 /*
130 * Only change lock state on transition from released
131 * to pressed. This prevents autorepeat from messing
132 * up the lock state.
133 */
134 kdev->mods = kdev->mods ^ (mod_mask & ~kdev->lock_keys);
135 kdev->lock_keys = kdev->lock_keys | mod_mask;
136
137 /* Update keyboard lock indicator lights. */
138 (*kdev->ctl_ops->set_ind)(kdev, kdev->mods);
139 } else {
140 kdev->lock_keys = kdev->lock_keys & ~mod_mask;
141 }
142 }
143
144 if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
145 key == KC_F1) {
146 layout_destroy(kdev->active_layout);
147 kdev->active_layout = layout_create(layout[0]);
148 return;
149 }
150
151 if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
152 key == KC_F2) {
153 layout_destroy(kdev->active_layout);
154 kdev->active_layout = layout_create(layout[1]);
155 return;
156 }
157
158 if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
159 key == KC_F3) {
160 layout_destroy(kdev->active_layout);
161 kdev->active_layout = layout_create(layout[2]);
162 return;
163 }
164
165 ev.type = type;
166 ev.key = key;
167 ev.mods = kdev->mods;
168
169 ev.c = layout_parse_ev(kdev->active_layout, &ev);
170
171 async_exch_t *exch = async_exchange_begin(client_sess);
172 async_msg_4(exch, INPUT_EVENT_KEY, ev.type, ev.key, ev.mods, ev.c);
173 async_exchange_end(exch);
174}
175
176/** Mouse pointer has moved. */
177void mouse_push_event_move(mouse_dev_t *mdev, int dx, int dy, int dz)
178{
179 async_exch_t *exch = async_exchange_begin(client_sess);
180 if (dx || dy)
181 async_msg_2(exch, INPUT_EVENT_MOVE, dx, dy);
182 if (dz) {
183 // TODO: Implement proper wheel support
184 keycode_t code = dz > 0 ? KC_UP : KC_DOWN;
185 for (int i = 0; i < 3; ++i) {
186 async_msg_4(exch, INPUT_EVENT_KEY, KEY_PRESS, code, 0, 0);
187 }
188 async_msg_4(exch, INPUT_EVENT_KEY, KEY_RELEASE, code, 0, 0);
189 }
190 async_exchange_end(exch);
191}
192
193/** Mouse button has been pressed. */
194void mouse_push_event_button(mouse_dev_t *mdev, int bnum, int press)
195{
196 async_exch_t *exch = async_exchange_begin(client_sess);
197 async_msg_2(exch, INPUT_EVENT_BUTTON, bnum, press);
198 async_exchange_end(exch);
199}
200
201static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
202{
203 async_answer_0(iid, EOK);
204
205 while (true) {
206 ipc_call_t call;
207 ipc_callid_t callid = async_get_call(&call);
208
209 if (!IPC_GET_IMETHOD(call)) {
210 if (client_sess != NULL) {
211 async_hangup(client_sess);
212 client_sess = NULL;
213 }
214
215 async_answer_0(callid, EOK);
216 return;
217 }
218
219 async_sess_t *sess =
220 async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
221 if (sess != NULL) {
222 if (client_sess == NULL) {
223 client_sess = sess;
224 async_answer_0(callid, EOK);
225 } else
226 async_answer_0(callid, ELIMIT);
227 } else {
228 switch (IPC_GET_IMETHOD(call)) {
229 case INPUT_YIELD:
230 kbd_devs_yield();
231 async_answer_0(callid, EOK);
232 break;
233 case INPUT_RECLAIM:
234 kbd_devs_reclaim();
235 async_answer_0(callid, EOK);
236 break;
237 default:
238 async_answer_0(callid, EINVAL);
239 }
240 }
241 }
242}
243
244static kbd_dev_t *kbd_dev_new(void)
245{
246 kbd_dev_t *kdev = calloc(1, sizeof(kbd_dev_t));
247 if (kdev == NULL) {
248 printf("%s: Error allocating keyboard device. "
249 "Out of memory.\n", NAME);
250 return NULL;
251 }
252
253 link_initialize(&kdev->kbd_devs);
254
255 kdev->mods = KM_NUM_LOCK;
256 kdev->lock_keys = 0;
257 kdev->active_layout = layout_create(layout[0]);
258
259 return kdev;
260}
261
262static mouse_dev_t *mouse_dev_new(void)
263{
264 mouse_dev_t *mdev = calloc(1, sizeof(mouse_dev_t));
265 if (mdev == NULL) {
266 printf("%s: Error allocating keyboard device. "
267 "Out of memory.\n", NAME);
268 return NULL;
269 }
270
271 link_initialize(&mdev->mouse_devs);
272
273 return mdev;
274}
275
276/** Add new legacy keyboard device. */
277static void kbd_add_dev(kbd_port_ops_t *port, kbd_ctl_ops_t *ctl)
278{
279 kbd_dev_t *kdev = kbd_dev_new();
280 if (kdev == NULL)
281 return;
282
283 kdev->port_ops = port;
284 kdev->ctl_ops = ctl;
285 kdev->svc_id = 0;
286
287 /* Initialize port driver. */
288 if ((*kdev->port_ops->init)(kdev) != 0)
289 goto fail;
290
291 /* Initialize controller driver. */
292 if ((*kdev->ctl_ops->init)(kdev) != 0) {
293 /* XXX Uninit port */
294 goto fail;
295 }
296
297 list_append(&kdev->kbd_devs, &kbd_devs);
298 return;
299
300fail:
301 free(kdev);
302}
303
304/** Add new legacy mouse device. */
305static void mouse_add_dev(mouse_port_ops_t *port, mouse_proto_ops_t *proto)
306{
307 mouse_dev_t *mdev = mouse_dev_new();
308 if (mdev == NULL)
309 return;
310
311 mdev->port_ops = port;
312 mdev->proto_ops = proto;
313 mdev->svc_id = 0;
314
315 /* Initialize port driver. */
316 if ((*mdev->port_ops->init)(mdev) != 0)
317 goto fail;
318
319 /* Initialize protocol driver. */
320 if ((*mdev->proto_ops->init)(mdev) != 0) {
321 /* XXX Uninit port */
322 goto fail;
323 }
324
325 list_append(&mdev->mouse_devs, &mouse_devs);
326 return;
327
328fail:
329 free(mdev);
330}
331
332/** Add new kbdev device.
333 *
334 * @param service_id Service ID of the keyboard device
335 *
336 */
337static int kbd_add_kbdev(service_id_t service_id, kbd_dev_t **kdevp)
338{
339 kbd_dev_t *kdev = kbd_dev_new();
340 if (kdev == NULL)
341 return -1;
342
343 kdev->svc_id = service_id;
344 kdev->port_ops = NULL;
345 kdev->ctl_ops = &kbdev_ctl;
346
347 int rc = loc_service_get_name(service_id, &kdev->svc_name);
348 if (rc != EOK) {
349 kdev->svc_name = NULL;
350 goto fail;
351 }
352
353 /* Initialize controller driver. */
354 if ((*kdev->ctl_ops->init)(kdev) != 0) {
355 goto fail;
356 }
357
358 list_append(&kdev->kbd_devs, &kbd_devs);
359 *kdevp = kdev;
360 return EOK;
361
362fail:
363 if (kdev->svc_name != NULL)
364 free(kdev->svc_name);
365 free(kdev);
366 return -1;
367}
368
369/** Add new mousedev device.
370 *
371 * @param service_id Service ID of the mouse device
372 *
373 */
374static int mouse_add_mousedev(service_id_t service_id, mouse_dev_t **mdevp)
375{
376 mouse_dev_t *mdev = mouse_dev_new();
377 if (mdev == NULL)
378 return -1;
379
380 mdev->svc_id = service_id;
381 mdev->port_ops = NULL;
382 mdev->proto_ops = &mousedev_proto;
383
384 int rc = loc_service_get_name(service_id, &mdev->svc_name);
385 if (rc != EOK) {
386 mdev->svc_name = NULL;
387 goto fail;
388 }
389
390 /* Initialize controller driver. */
391 if ((*mdev->proto_ops->init)(mdev) != 0) {
392 goto fail;
393 }
394
395 list_append(&mdev->mouse_devs, &mouse_devs);
396 *mdevp = mdev;
397 return EOK;
398
399fail:
400 free(mdev);
401 return -1;
402}
403
404/** Add legacy drivers/devices. */
405static void kbd_add_legacy_devs(void)
406{
407 /*
408 * Need to add these drivers based on config unless we can probe
409 * them automatically.
410 */
411#if defined(UARCH_arm32) && defined(MACHINE_gta02)
412 kbd_add_dev(&chardev_port, &stty_ctl);
413#endif
414#if defined(UARCH_arm32) && defined(MACHINE_testarm) && defined(CONFIG_FB)
415 kbd_add_dev(&gxemul_port, &gxe_fb_ctl);
416#endif
417#if defined(UARCH_arm32) && defined(MACHINE_testarm) && !defined(CONFIG_FB)
418 kbd_add_dev(&gxemul_port, &stty_ctl);
419#endif
420#if defined(UARCH_arm32) && defined(MACHINE_integratorcp)
421 kbd_add_dev(&pl050_port, &pc_ctl);
422#endif
423#if defined(MACHINE_ski)
424 kbd_add_dev(&ski_port, &stty_ctl);
425#endif
426#if defined(MACHINE_msim)
427 kbd_add_dev(&msim_port, &stty_ctl);
428#endif
429#if (defined(MACHINE_lgxemul) || defined(MACHINE_bgxemul)) && defined(CONFIG_FB)
430 kbd_add_dev(&gxemul_port, &gxe_fb_ctl);
431#endif
432#if defined(MACHINE_lgxemul) || defined(MACHINE_bgxemul) && !defined(CONFIG_FB)
433 kbd_add_dev(&gxemul_port, &stty_ctl);
434#endif
435#if defined(UARCH_ppc32)
436 kbd_add_dev(&adb_port, &apple_ctl);
437#endif
438#if defined(UARCH_sparc64) && defined(PROCESSOR_sun4v)
439 kbd_add_dev(&niagara_port, &stty_ctl);
440#endif
441#if defined(UARCH_sparc64) && defined(MACHINE_generic)
442 kbd_add_dev(&ns16550_port, &sun_ctl);
443#endif
444 /* Silence warning on abs32le about kbd_add_dev() being unused */
445 (void) kbd_add_dev;
446}
447
448/** Add legacy drivers/devices. */
449static void mouse_add_legacy_devs(void)
450{
451 /*
452 * Need to add these drivers based on config unless we can probe
453 * them automatically.
454 */
455#if defined(UARCH_ppc32)
456 mouse_add_dev(&adb_mouse_port, &adb_proto);
457#endif
458 /* Silence warning on abs32le about mouse_add_dev() being unused */
459 (void) mouse_add_dev;
460}
461
462static void kbd_devs_yield(void)
463{
464 /* For each keyboard device */
465 list_foreach(kbd_devs, kdev_link) {
466 kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t,
467 kbd_devs);
468
469 /* Yield port */
470 if (kdev->port_ops != NULL)
471 (*kdev->port_ops->yield)();
472 }
473}
474
475static void kbd_devs_reclaim(void)
476{
477 /* For each keyboard device */
478 list_foreach(kbd_devs, kdev_link) {
479 kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t,
480 kbd_devs);
481
482 /* Reclaim port */
483 if (kdev->port_ops != NULL)
484 (*kdev->port_ops->reclaim)();
485 }
486}
487
488static int dev_check_new_kbdevs(void)
489{
490 category_id_t keyboard_cat;
491 service_id_t *svcs;
492 size_t count, i;
493 bool already_known;
494 int rc;
495
496 rc = loc_category_get_id("keyboard", &keyboard_cat, IPC_FLAG_BLOCKING);
497 if (rc != EOK) {
498 printf("%s: Failed resolving category 'keyboard'.\n", NAME);
499 return ENOENT;
500 }
501
502 /*
503 * Check for new keyboard devices
504 */
505 rc = loc_category_get_svcs(keyboard_cat, &svcs, &count);
506 if (rc != EOK) {
507 printf("%s: Failed getting list of keyboard devices.\n",
508 NAME);
509 return EIO;
510 }
511
512 for (i = 0; i < count; i++) {
513 already_known = false;
514
515 /* Determine whether we already know this device. */
516 list_foreach(kbd_devs, kdev_link) {
517 kbd_dev_t *kdev = list_get_instance(kdev_link,
518 kbd_dev_t, kbd_devs);
519 if (kdev->svc_id == svcs[i]) {
520 already_known = true;
521 break;
522 }
523 }
524
525 if (!already_known) {
526 kbd_dev_t *kdev;
527 if (kbd_add_kbdev(svcs[i], &kdev) == EOK) {
528 printf("%s: Connected keyboard device '%s'\n",
529 NAME, kdev->svc_name);
530 }
531 }
532 }
533
534 free(svcs);
535
536 /* XXX Handle device removal */
537
538 return EOK;
539}
540
541static int dev_check_new_mousedevs(void)
542{
543 category_id_t mouse_cat;
544 service_id_t *svcs;
545 size_t count, i;
546 bool already_known;
547 int rc;
548
549 rc = loc_category_get_id("mouse", &mouse_cat, IPC_FLAG_BLOCKING);
550 if (rc != EOK) {
551 printf("%s: Failed resolving category 'mouse'.\n", NAME);
552 return ENOENT;
553 }
554
555 /*
556 * Check for new mouse devices
557 */
558 rc = loc_category_get_svcs(mouse_cat, &svcs, &count);
559 if (rc != EOK) {
560 printf("%s: Failed getting list of mouse devices.\n",
561 NAME);
562 return EIO;
563 }
564
565 for (i = 0; i < count; i++) {
566 already_known = false;
567
568 /* Determine whether we already know this device. */
569 list_foreach(mouse_devs, mdev_link) {
570 mouse_dev_t *mdev = list_get_instance(mdev_link,
571 mouse_dev_t, mouse_devs);
572 if (mdev->svc_id == svcs[i]) {
573 already_known = true;
574 break;
575 }
576 }
577
578 if (!already_known) {
579 mouse_dev_t *mdev;
580 if (mouse_add_mousedev(svcs[i], &mdev) == EOK) {
581 printf("%s: Connected mouse device '%s'\n",
582 NAME, mdev->svc_name);
583 }
584 }
585 }
586
587 free(svcs);
588
589 /* XXX Handle device removal */
590
591 return EOK;
592}
593
594static int dev_check_new(void)
595{
596 int rc;
597
598 fibril_mutex_lock(&discovery_lock);
599
600 rc = dev_check_new_kbdevs();
601 if (rc != EOK) {
602 fibril_mutex_unlock(&discovery_lock);
603 return rc;
604 }
605
606 rc = dev_check_new_mousedevs();
607 if (rc != EOK) {
608 fibril_mutex_unlock(&discovery_lock);
609 return rc;
610 }
611
612 fibril_mutex_unlock(&discovery_lock);
613
614 return EOK;
615}
616
617static void cat_change_cb(void)
618{
619 dev_check_new();
620}
621
622/** Start listening for new devices. */
623static int input_start_dev_discovery(void)
624{
625 int rc;
626
627 rc = loc_register_cat_change_cb(cat_change_cb);
628 if (rc != EOK) {
629 printf("%s: Failed registering callback for device discovery. "
630 "(%d)\n", NAME, rc);
631 return rc;
632 }
633
634 return dev_check_new();
635}
636
637int main(int argc, char **argv)
638{
639 printf("%s: HelenOS input service\n", NAME);
640
641 sysarg_t obio;
642
643 list_initialize(&kbd_devs);
644 list_initialize(&mouse_devs);
645
646 if ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))
647 irc_service = true;
648
649 if (irc_service) {
650 while (irc_sess == NULL)
651 irc_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
652 SERVICE_IRC, 0, 0);
653 }
654
655 /* Add legacy keyboard devices. */
656 kbd_add_legacy_devs();
657
658 /* Add legacy mouse devices. */
659 mouse_add_legacy_devs();
660
661 /* Register driver */
662 async_set_client_connection(client_connection);
663 int rc = loc_server_register(NAME);
664 if (rc < 0) {
665 printf("%s: Unable to register server (%d)\n", NAME, rc);
666 return -1;
667 }
668
669 char kbd[LOC_NAME_MAXLEN + 1];
670 snprintf(kbd, LOC_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
671
672 service_id_t service_id;
673 if (loc_service_register(kbd, &service_id) != EOK) {
674 printf("%s: Unable to register service %s\n", NAME, kbd);
675 return -1;
676 }
677
678 /* Start looking for new input devices */
679 input_start_dev_discovery();
680
681 printf("%s: Accepting connections\n", NAME);
682 async_manager();
683
684 /* Not reached. */
685 return 0;
686}
687
688/**
689 * @}
690 */
Note: See TracBrowser for help on using the repository browser.