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

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a8bf1ea was a8bf1ea, checked in by Jan Vesely <jano.vesely@…>, 13 years ago

input: Remove traces of ps2 mouse and keyboard.

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