Changes in uspace/srv/hid/input/input.c [c928bb7:73d8600] in mainline

File:

• uspace/srv/hid/input/input.c (modified) (40 diffs)

uspace/srv/hid/input/input.c

@@ -42 +42 @@
 #include <ipc/services.h>
 #include <ipc/input.h>
-#include <sysinfo.h>
+#include <config.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
-#include <stdio.h>
 #include <ns.h>
 #include <async.h>
@@ -54 +53 @@
 #include <io/keycode.h>
 #include <loc.h>
+#include <str_error.h>
+#include <char_dev_iface.h>
+#include <fibril.h>
 #include "layout.h"
 #include "kbd.h"
@@ -60 +62 @@
 #include "mouse.h"
 #include "mouse_proto.h"
+#include "serial.h"
 #include "input.h"
 
@@ -71 +74 @@
 };
 
-static void kbd_devs_yield(void);
-static void kbd_devs_reclaim(void);
-
-async_sess_t *client_sess = NULL;
+typedef struct {
+        /** Link into the list of clients */
+        link_t link;
+        
+        /** Indicate whether the client is active */
+        bool active;
+        
+        /** Client callback session */
+        async_sess_t *sess;
+} client_t;
+
+/** List of clients */
+static list_t clients;
+static client_t *active_client = NULL;
+
+/** Kernel override */
+static bool active = true;
+
+/** Serial console specified by the user */
+static char *serial_console;
 
 /** List of keyboard devices */
@@ -82 +101 @@
 static list_t mouse_devs;
 
-bool irc_service = false;
-async_sess_t *irc_sess = NULL;
+/** List of serial devices */
+static list_t serial_devs;
 
 static FIBRIL_MUTEX_INITIALIZE(discovery_lock);
+
+static void *client_data_create(void)
+{
+        client_t *client = (client_t *) calloc(1, sizeof(client_t));
+        if (client == NULL)
+                return NULL;
+        
+        link_initialize(&client->link);
+        client->active = false;
+        client->sess = NULL;
+        
+        list_append(&client->link, &clients);
+        
+        return client;
+}
+
+static void client_data_destroy(void *data)
+{
+        client_t *client = (client_t *) data;
+        
+        list_remove(&client->link);
+        free(client);
+}
 
 void kbd_push_data(kbd_dev_t *kdev, sysarg_t data)
@@ -103 +145 @@
         
         switch (key) {
-        case KC_LCTRL: mod_mask = KM_LCTRL; break;
-        case KC_RCTRL: mod_mask = KM_RCTRL; break;
-        case KC_LSHIFT: mod_mask = KM_LSHIFT; break;
-        case KC_RSHIFT: mod_mask = KM_RSHIFT; break;
-        case KC_LALT: mod_mask = KM_LALT; break;
-        case KC_RALT: mod_mask = KM_RALT; break;
-        default: mod_mask = 0; break;
+        case KC_LCTRL:
+                mod_mask = KM_LCTRL;
+                break;
+        case KC_RCTRL:
+                mod_mask = KM_RCTRL;
+                break;
+        case KC_LSHIFT:
+                mod_mask = KM_LSHIFT;
+                break;
+        case KC_RSHIFT:
+                mod_mask = KM_RSHIFT;
+                break;
+        case KC_LALT:
+                mod_mask = KM_LALT;
+                break;
+        case KC_RALT:
+                mod_mask = KM_RALT;
+                break;
+        default:
+                mod_mask = 0;
         }
         
@@ -120 +175 @@
         
         switch (key) {
-        case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
-        case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
-        case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
-        default: mod_mask = 0; break;
+        case KC_CAPS_LOCK:
+                mod_mask = KM_CAPS_LOCK;
+                break;
+        case KC_NUM_LOCK:
+                mod_mask = KM_NUM_LOCK;
+                break;
+        case KC_SCROLL_LOCK:
+                mod_mask = KM_SCROLL_LOCK;
+                break;
+        default:
+                mod_mask = 0;
         }
         
@@ -143 +205 @@
         }
         
-        if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
-            key == KC_F1) {
+        // TODO: More elegant layout switching
+        
+        if ((type == KEY_PRESS) && (kdev->mods & KM_LCTRL) &&
+            (key == KC_F1)) {
                 layout_destroy(kdev->active_layout);
                 kdev->active_layout = layout_create(layout[0]);
@@ -150 +214 @@
         }
         
-        if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
-            key == KC_F2) {
+        if ((type == KEY_PRESS) && (kdev->mods & KM_LCTRL) &&
+            (key == KC_F2)) {
                 layout_destroy(kdev->active_layout);
                 kdev->active_layout = layout_create(layout[1]);
@@ -157 +221 @@
         }
         
-        if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
-            key == KC_F3) {
+        if ((type == KEY_PRESS) && (kdev->mods & KM_LCTRL) &&
+            (key == KC_F3)) {
                 layout_destroy(kdev->active_layout);
                 kdev->active_layout = layout_create(layout[2]);
@@ -164 +228 @@
         }
         
-        if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
-            key == KC_F4) {
+        if ((type == KEY_PRESS) && (kdev->mods & KM_LCTRL) &&
+            (key == KC_F4)) {
                 layout_destroy(kdev->active_layout);
                 kdev->active_layout = layout_create(layout[3]);
@@ -177 +241 @@
         ev.c = layout_parse_ev(kdev->active_layout, &ev);
         
-        async_exch_t *exch = async_exchange_begin(client_sess);
-        async_msg_4(exch, INPUT_EVENT_KEY, ev.type, ev.key, ev.mods, ev.c);
-        async_exchange_end(exch);
-}
-
-/** Mouse pointer has moved. */
+        list_foreach(clients, link, client_t, client) {
+                if (client->active) {
+                        async_exch_t *exch = async_exchange_begin(client->sess);
+                        async_msg_4(exch, INPUT_EVENT_KEY, ev.type, ev.key, ev.mods, ev.c);
+                        async_exchange_end(exch);
+                }
+        }
+}
+
+/** Mouse pointer has moved (relative mode). */
 void mouse_push_event_move(mouse_dev_t *mdev, int dx, int dy, int dz)
 {
-        async_exch_t *exch = async_exchange_begin(client_sess);
-        if (dx || dy)
-                async_msg_2(exch, INPUT_EVENT_MOVE, dx, dy);
-        if (dz) {
-                // TODO: Implement proper wheel support
-                keycode_t code = dz > 0 ? KC_UP : KC_DOWN;
-                for (int i = 0; i < 3; ++i) {
-                        async_msg_4(exch, INPUT_EVENT_KEY, KEY_PRESS, code, 0, 0);
-                }
-                async_msg_4(exch, INPUT_EVENT_KEY, KEY_RELEASE, code, 0, 0);
-        }
-        async_exchange_end(exch);
-}
-
-/** Mouse pointer has moved in absolute mode. */
+        list_foreach(clients, link, client_t, client) {
+                if (client->active) {
+                        async_exch_t *exch = async_exchange_begin(client->sess);
+                        
+                        if ((dx) || (dy))
+                                async_msg_2(exch, INPUT_EVENT_MOVE, dx, dy);
+                        
+                        if (dz) {
+                                // TODO: Implement proper wheel support
+                                keycode_t code = dz > 0 ? KC_UP : KC_DOWN;
+                                
+                                for (unsigned int i = 0; i < 3; i++)
+                                        async_msg_4(exch, INPUT_EVENT_KEY, KEY_PRESS, code, 0, 0);
+                                
+                                async_msg_4(exch, INPUT_EVENT_KEY, KEY_RELEASE, code, 0, 0);
+                        }
+                        
+                        async_exchange_end(exch);
+                }
+        }
+}
+
+/** Mouse pointer has moved (absolute mode). */
 void mouse_push_event_abs_move(mouse_dev_t *mdev, unsigned int x, unsigned int y,
     unsigned int max_x, unsigned int max_y)
 {
-        if (max_x && max_y) {
-                async_exch_t *exch = async_exchange_begin(client_sess);
-                async_msg_4(exch, INPUT_EVENT_ABS_MOVE, x, y, max_x, max_y);
-                async_exchange_end(exch);
+        list_foreach(clients, link, client_t, client) {
+                if (client->active) {
+                        if ((max_x) && (max_y)) {
+                                async_exch_t *exch = async_exchange_begin(client->sess);
+                                async_msg_4(exch, INPUT_EVENT_ABS_MOVE, x, y, max_x, max_y);
+                                async_exchange_end(exch);
+                        }
+                }
         }
 }
@@ -213 +293 @@
 void mouse_push_event_button(mouse_dev_t *mdev, int bnum, int press)
 {
-        async_exch_t *exch = async_exchange_begin(client_sess);
-        async_msg_2(exch, INPUT_EVENT_BUTTON, bnum, press);
-        async_exchange_end(exch);
-}
-
+        list_foreach(clients, link, client_t, client) {
+                if (client->active) {
+                        async_exch_t *exch = async_exchange_begin(client->sess);
+                        async_msg_2(exch, INPUT_EVENT_BUTTON, bnum, press);
+                        async_exchange_end(exch);
+                }
+        }
+}
+
+/** Arbitrate client actiovation */
+static void client_arbitration(void)
+{
+        /* Mutual exclusion of active clients */
+        list_foreach(clients, link, client_t, client)
+                client->active = ((active) && (client == active_client));
+        
+        /* Notify clients about the arbitration */
+        list_foreach(clients, link, client_t, client) {
+                async_exch_t *exch = async_exchange_begin(client->sess);
+                async_msg_0(exch, client->active ?
+                    INPUT_EVENT_ACTIVE : INPUT_EVENT_DEACTIVE);
+                async_exchange_end(exch);
+        }
+}
+
+/** New client connection */
 static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
+        client_t *client = (client_t *) async_get_client_data();
+        if (client == NULL) {
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
         async_answer_0(iid, EOK);
         
@@ -227 +334 @@
                 
                 if (!IPC_GET_IMETHOD(call)) {
-                        if (client_sess != NULL) {
-                                async_hangup(client_sess);
-                                client_sess = NULL;
+                        if (client->sess != NULL) {
+                                async_hangup(client->sess);
+                                client->sess = NULL;
                         }
                         
@@ -239 +346 @@
                     async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
                 if (sess != NULL) {
-                        if (client_sess == NULL) {
-                                client_sess = sess;
+                        if (client->sess == NULL) {
+                                client->sess = sess;
                                 async_answer_0(callid, EOK);
                         } else
@@ -246 +353 @@
                 } else {
                         switch (IPC_GET_IMETHOD(call)) {
-                        case INPUT_YIELD:
-                                kbd_devs_yield();
-                                async_answer_0(callid, EOK);
-                                break;
-                        case INPUT_RECLAIM:
-                                kbd_devs_reclaim();
+                        case INPUT_ACTIVATE:
+                                active_client = client;
+                                client_arbitration();
                                 async_answer_0(callid, EOK);
                                 break;
@@ -261 +365 @@
 }
 
+static void kconsole_event_handler(ipc_callid_t callid, ipc_call_t *call,
+    void *arg)
+{
+        if (IPC_GET_ARG1(*call)) {
+                /* Kernel console activated */
+                active = false;
+        } else {
+                /* Kernel console deactivated */
+                active = true;
+        }
+        
+        client_arbitration();
+}
+
 static kbd_dev_t *kbd_dev_new(void)
 {
@@ -270 +388 @@
         }
         
-        link_initialize(&kdev->kbd_devs);
+        link_initialize(&kdev->link);
         
         kdev->mods = KM_NUM_LOCK;
@@ -283 +401 @@
         mouse_dev_t *mdev = calloc(1, sizeof(mouse_dev_t));
         if (mdev == NULL) {
-                printf("%s: Error allocating keyboard device. "
+                printf("%s: Error allocating mouse device. "
                     "Out of memory.\n", NAME);
                 return NULL;
         }
         
-        link_initialize(&mdev->mouse_devs);
+        link_initialize(&mdev->link);
         
         return mdev;
+}
+
+static serial_dev_t *serial_dev_new(void)
+{
+        serial_dev_t *sdev = calloc(1, sizeof(serial_dev_t));
+        if (sdev == NULL) {
+                printf("%s: Error allocating serial device. "
+                    "Out of memory.\n", NAME);
+                return NULL;
+        }
+        
+        sdev->kdev = kbd_dev_new();
+        if (sdev->kdev == NULL) {
+                free(sdev);
+                return NULL;
+        }
+
+        link_initialize(&sdev->link);
+        
+        return sdev;
 }
 
@@ -314 +452 @@
         }
         
-        list_append(&kdev->kbd_devs, &kbd_devs);
+        list_append(&kdev->link, &kbd_devs);
         return;
         
@@ -342 +480 @@
         }
         
-        list_append(&mdev->mouse_devs, &mouse_devs);
+        list_append(&mdev->link, &mouse_devs);
         return;
         
@@ -351 +489 @@
 /** Add new kbdev device.
  *
- * @param service_id    Service ID of the keyboard device
+ * @param service_id Service ID of the keyboard device
  *
  */
@@ -375 +513 @@
         }
         
-        list_append(&kdev->kbd_devs, &kbd_devs);
+        list_append(&kdev->link, &kbd_devs);
         *kdevp = kdev;
         return EOK;
@@ -388 +526 @@
 /** Add new mousedev device.
  *
- * @param service_id    Service ID of the mouse device
+ * @param service_id Service ID of the mouse device
  *
  */
@@ -412 +550 @@
         }
         
-        list_append(&mdev->mouse_devs, &mouse_devs);
+        list_append(&mdev->link, &mouse_devs);
         *mdevp = mdev;
         return EOK;
@@ -420 +558 @@
         return -1;
 }
+
+static int serial_consumer(void *arg)
+{
+        serial_dev_t *sdev = (serial_dev_t *) arg;
+
+        while (true) {
+                uint8_t data;
+
+                char_dev_read(sdev->sess, &data, sizeof(data));
+                kbd_push_data(sdev->kdev, data);
+        }
+
+        return EOK;
+}
+
+/** Add new serial console device.
+ *
+ * @param service_id Service ID of the chardev device
+ *
+ */
+static int serial_add_srldev(service_id_t service_id, serial_dev_t **sdevp)
+{
+        bool match = false;
+
+        serial_dev_t *sdev = serial_dev_new();
+        if (sdev == NULL)
+                return -1;
+        
+        sdev->kdev->svc_id = service_id;
+        
+        int rc = loc_service_get_name(service_id, &sdev->kdev->svc_name);
+        if (rc != EOK)
+                goto fail;
+
+        list_append(&sdev->link, &serial_devs);
+
+        /*
+         * Is this the device the user wants to use as a serial console?
+         */
+        match = (serial_console != NULL) &&
+            !str_cmp(serial_console, sdev->kdev->svc_name);
+
+        if (match) {
+                sdev->kdev->ctl_ops = &stty_ctl;
+
+                /* Initialize controller driver. */
+                if ((*sdev->kdev->ctl_ops->init)(sdev->kdev) != 0) {
+                        list_remove(&sdev->link);
+                        goto fail;
+                }
+
+                sdev->sess = loc_service_connect(service_id, INTERFACE_DDF,
+                    IPC_FLAG_BLOCKING);
+
+                fid_t fid = fibril_create(serial_consumer, sdev);
+                fibril_add_ready(fid);
+        }
+        
+        *sdevp = sdev;
+        return EOK;
+        
+fail:
+        if (sdev->kdev->svc_name != NULL)
+                free(sdev->kdev->svc_name);
+        free(sdev->kdev);
+        free(sdev);
+        return -1;
+}
+
 
 /** Add legacy drivers/devices. */
@@ -431 +638 @@
         kbd_add_dev(&chardev_port, &stty_ctl);
 #endif
-#if defined(UARCH_arm32) && defined(MACHINE_integratorcp)
-        kbd_add_dev(&pl050_port, &pc_ctl);
-#endif
 #if defined(MACHINE_ski)
         kbd_add_dev(&ski_port, &stty_ctl);
@@ -440 +644 @@
         kbd_add_dev(&msim_port, &stty_ctl);
 #endif
-#if (defined(MACHINE_lgxemul) || defined(MACHINE_bgxemul)) && defined(CONFIG_FB)
-        kbd_add_dev(&gxemul_port, &gxe_fb_ctl);
-#endif
-#if defined(MACHINE_lgxemul) || defined(MACHINE_bgxemul) && !defined(CONFIG_FB)
-        kbd_add_dev(&gxemul_port, &stty_ctl);
-#endif
 #if defined(UARCH_ppc32)
         kbd_add_dev(&adb_port, &apple_ctl);
@@ -451 +649 @@
 #if defined(UARCH_sparc64) && defined(PROCESSOR_sun4v)
         kbd_add_dev(&niagara_port, &stty_ctl);
-#endif
-#if defined(UARCH_sparc64) && defined(MACHINE_generic)
-        kbd_add_dev(&ns16550_port, &sun_ctl);
 #endif
         /* Silence warning on abs32le about kbd_add_dev() being unused */
@@ -473 +668 @@
 }
 
-static void kbd_devs_yield(void)
-{
-        /* For each keyboard device */
-        list_foreach(kbd_devs, kdev_link) {
-                kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t,
-                    kbd_devs);
-                
-                /* Yield port */
-                if (kdev->port_ops != NULL)
-                        (*kdev->port_ops->yield)();
-        }
-}
-
-static void kbd_devs_reclaim(void)
-{
-        /* For each keyboard device */
-        list_foreach(kbd_devs, kdev_link) {
-                kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t,
-                    kbd_devs);
-                
-                /* Reclaim port */
-                if (kdev->port_ops != NULL)
-                        (*kdev->port_ops->reclaim)();
-        }
-}
-
 static int dev_check_new_kbdevs(void)
 {
@@ -527 +696 @@
                 
                 /* Determine whether we already know this device. */
-                list_foreach(kbd_devs, kdev_link) {
-                        kbd_dev_t *kdev = list_get_instance(kdev_link,
-                            kbd_dev_t, kbd_devs);
+                list_foreach(kbd_devs, link, kbd_dev_t, kdev) {
                         if (kdev->svc_id == svcs[i]) {
                                 already_known = true;
@@ -580 +747 @@
                 
                 /* Determine whether we already know this device. */
-                list_foreach(mouse_devs, mdev_link) {
-                        mouse_dev_t *mdev = list_get_instance(mdev_link,
-                            mouse_dev_t, mouse_devs);
+                list_foreach(mouse_devs, link, mouse_dev_t, mdev) {
                         if (mdev->svc_id == svcs[i]) {
                                 already_known = true;
@@ -605 +770 @@
 }
 
+static int dev_check_new_serialdevs(void)
+{
+        category_id_t serial_cat;
+        service_id_t *svcs;
+        size_t count, i;
+        bool already_known;
+        int rc;
+        
+        rc = loc_category_get_id("serial", &serial_cat, IPC_FLAG_BLOCKING);
+        if (rc != EOK) {
+                printf("%s: Failed resolving category 'serial'.\n", NAME);
+                return ENOENT;
+        }
+        
+        /*
+         * Check for new serial devices
+         */
+        rc = loc_category_get_svcs(serial_cat, &svcs, &count);
+        if (rc != EOK) {
+                printf("%s: Failed getting list of serial devices.\n",
+                    NAME);
+                return EIO;
+        }
+
+        for (i = 0; i < count; i++) {
+                already_known = false;
+                
+                /* Determine whether we already know this device. */
+                list_foreach(serial_devs, link, serial_dev_t, sdev) {
+                        if (sdev->kdev->svc_id == svcs[i]) {
+                                already_known = true;
+                                break;
+                        }
+                }
+                
+                if (!already_known) {
+                        serial_dev_t *sdev;
+                        if (serial_add_srldev(svcs[i], &sdev) == EOK) {
+                                printf("%s: Connected serial device '%s'\n",
+                                    NAME, sdev->kdev->svc_name);
+                        }
+                }
+        }
+        
+        free(svcs);
+        
+        /* XXX Handle device removal */
+        
+        return EOK;
+}
+
 static int dev_check_new(void)
 {
@@ -611 +827 @@
         fibril_mutex_lock(&discovery_lock);
         
-        rc = dev_check_new_kbdevs();
-        if (rc != EOK) {
-                fibril_mutex_unlock(&discovery_lock);
-                return rc;
-        }
-        
-        rc = dev_check_new_mousedevs();
-        if (rc != EOK) {
-                fibril_mutex_unlock(&discovery_lock);
-                return rc;
+        if (!serial_console) {
+                rc = dev_check_new_kbdevs();
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&discovery_lock);
+                        return rc;
+                }
+        
+                rc = dev_check_new_mousedevs();
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&discovery_lock);
+                        return rc;
+                }
+        } else {
+                rc = dev_check_new_serialdevs();
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&discovery_lock);
+                        return rc;
+                }
         }
         
@@ -636 +860 @@
 static int input_start_dev_discovery(void)
 {
-        int rc;
-
-        rc = loc_register_cat_change_cb(cat_change_cb);
+        int rc = loc_register_cat_change_cb(cat_change_cb);
         if (rc != EOK) {
                 printf("%s: Failed registering callback for device discovery. "
@@ -644 +866 @@
                 return rc;
         }
-
+        
         return dev_check_new();
 }
@@ -655 +877 @@
 int main(int argc, char **argv)
 {
+        int rc;
+
         if (argc < 2) {
                 usage(argv[0]);
@@ -662 +886 @@
         printf("%s: HelenOS input service\n", NAME);
         
-        sysarg_t obio;
-        
+        list_initialize(&clients);
         list_initialize(&kbd_devs);
         list_initialize(&mouse_devs);
-        
-        if ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))
-                irc_service = true;
-        
-        if (irc_service) {
-                while (irc_sess == NULL)
-                        irc_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-                            SERVICE_IRC, 0, 0);
-        }
+        list_initialize(&serial_devs);
+        
+        serial_console = config_get_value("console");
         
         /* Add legacy keyboard devices. */
@@ -683 +900 @@
         
         /* Register driver */
-        async_set_client_connection(client_connection);
-        int rc = loc_server_register(NAME);
+        async_set_client_data_constructor(client_data_create);
+        async_set_client_data_destructor(client_data_destroy);
+        async_set_fallback_port_handler(client_connection, NULL);
+        
+        rc = loc_server_register(NAME);
         if (rc != EOK) {
                 printf("%s: Unable to register server\n", NAME);
@@ -696 +916 @@
                 return rc;
         }
+        
+        /* Receive kernel notifications */
+        rc = async_event_subscribe(EVENT_KCONSOLE, kconsole_event_handler, NULL);
+        if (rc != EOK)
+                printf("%s: Failed to register kconsole notifications (%s)\n",
+                    NAME, str_error(rc));
         
         /* Start looking for new input devices */