Changes in uspace/srv/hid/console/console.c [854eddd6:8c74d15] in mainline

File:

• uspace/srv/hid/console/console.c (modified) (37 diffs)

uspace/srv/hid/console/console.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2006 Josef Cejka
- * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -35 +34 @@
 
 #include <libc.h>
-#include <ipc/input.h>
+#include <ipc/kbd.h>
 #include <io/keycode.h>
+#include <ipc/mouse.h>
 #include <ipc/fb.h>
 #include <ipc/services.h>
-#include <ns.h>
-#include <ns_obsolete.h>
+#include <ipc/ns.h>
 #include <errno.h>
 #include <str_error.h>
@@ -46 +45 @@
 #include <unistd.h>
 #include <async.h>
-#include <async_obsolete.h>
 #include <adt/fifo.h>
 #include <sys/mman.h>
@@ -54 +52 @@
 #include <event.h>
 #include <devmap.h>
-#include <devmap_obsolete.h>
 #include <fcntl.h>
 #include <vfs/vfs.h>
@@ -60 +57 @@
 #include <io/style.h>
 #include <io/screenbuffer.h>
+#include <inttypes.h>
 
 #include "console.h"
@@ -65 +63 @@
 #include "keybuffer.h"
 
+
 #define NAME       "console"
 #define NAMESPACE  "term"
-
-/** Phone to the input server. */
-static int input_phone;
+/** Interval for checking for new keyboard (1/4s). */
+#define HOTPLUG_WATCH_INTERVAL (1000 * 250)
+
+/* Kernel defines 32 but does not export it. */
+#define MAX_IPC_OUTGOING_PHONES 128
+/** To allow proper phone closing. */
+static ipc_callid_t driver_phones[MAX_IPC_OUTGOING_PHONES] = { 0 };
+
+/** Phone to the keyboard driver. */
+static int kbd_phone;
+
+/** Phone to the mouse driver. */
+static int mouse_phone;
 
 /** Information about framebuffer */
@@ -88 +97 @@
 } console_t;
 
+
+
 /** Array of data for virtual consoles */
 static console_t consoles[CONSOLE_COUNT];
@@ -111 +122 @@
 static void curs_visibility(bool visible)
 {
-        async_obsolete_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, visible); 
+        async_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, visible); 
 }
 
 static void curs_hide_sync(void)
 {
-        async_obsolete_req_1_0(fb_info.phone, FB_CURSOR_VISIBILITY, false); 
+        async_req_1_0(fb_info.phone, FB_CURSOR_VISIBILITY, false); 
 }
 
 static void curs_goto(sysarg_t x, sysarg_t y)
 {
-        async_obsolete_msg_2(fb_info.phone, FB_CURSOR_GOTO, x, y);
+        async_msg_2(fb_info.phone, FB_CURSOR_GOTO, x, y);
 }
 
 static void screen_clear(void)
 {
-        async_obsolete_msg_0(fb_info.phone, FB_CLEAR);
+        async_msg_0(fb_info.phone, FB_CLEAR);
 }
 
 static void screen_yield(void)
 {
-        async_obsolete_req_0_0(fb_info.phone, FB_SCREEN_YIELD);
+        async_req_0_0(fb_info.phone, FB_SCREEN_YIELD);
 }
 
 static void screen_reclaim(void)
 {
-        async_obsolete_req_0_0(fb_info.phone, FB_SCREEN_RECLAIM);
-}
-
-static void input_yield(void)
-{
-        async_obsolete_req_0_0(input_phone, INPUT_YIELD);
-}
-
-static void input_reclaim(void)
-{
-        async_obsolete_req_0_0(input_phone, INPUT_RECLAIM);
+        async_req_0_0(fb_info.phone, FB_SCREEN_RECLAIM);
+}
+
+static void kbd_yield(void)
+{
+        async_req_0_0(kbd_phone, KBD_YIELD);
+}
+
+static void kbd_reclaim(void)
+{
+        async_req_0_0(kbd_phone, KBD_RECLAIM);
 }
 
 static void set_style(uint8_t style)
 {
-        async_obsolete_msg_1(fb_info.phone, FB_SET_STYLE, style);
+        async_msg_1(fb_info.phone, FB_SET_STYLE, style);
 }
 
 static void set_color(uint8_t fgcolor, uint8_t bgcolor, uint8_t flags)
 {
-        async_obsolete_msg_3(fb_info.phone, FB_SET_COLOR, fgcolor, bgcolor, flags);
+        async_msg_3(fb_info.phone, FB_SET_COLOR, fgcolor, bgcolor, flags);
 }
 
 static void set_rgb_color(uint32_t fgcolor, uint32_t bgcolor)
 {
-        async_obsolete_msg_2(fb_info.phone, FB_SET_RGB_COLOR, fgcolor, bgcolor); 
+        async_msg_2(fb_info.phone, FB_SET_RGB_COLOR, fgcolor, bgcolor); 
 }
 
@@ -216 +227 @@
                 }
                 
-                async_obsolete_req_4_0(fb_info.phone, FB_DRAW_TEXT_DATA,
+                async_req_4_0(fb_info.phone, FB_DRAW_TEXT_DATA,
                     x0, y0, width, height);
         }
@@ -257 +268 @@
 static void fb_putchar(wchar_t c, sysarg_t col, sysarg_t row)
 {
-        async_obsolete_msg_3(fb_info.phone, FB_PUTCHAR, c, col, row);
+        async_msg_3(fb_info.phone, FB_PUTCHAR, c, col, row);
 }
 
@@ -306 +317 @@
                 
                 if (cons == active_console)
-                        async_obsolete_msg_1(fb_info.phone, FB_SCROLL, 1);
+                        async_msg_1(fb_info.phone, FB_SCROLL, 1);
         }
         
@@ -317 +328 @@
 static void change_console(console_t *cons)
 {
-        if (cons == active_console)
+        if (cons == active_console) {
                 return;
+        }
         
         fb_pending_flush();
         
         if (cons == kernel_console) {
-                async_obsolete_serialize_start();
+                async_serialize_start();
                 curs_hide_sync();
                 gcons_in_kernel();
                 screen_yield();
-                input_yield();
-                async_obsolete_serialize_end();
+                kbd_yield();
+                async_serialize_end();
                 
                 if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE)) {
@@ -338 +350 @@
         
         if (cons != kernel_console) {
-                async_obsolete_serialize_start();
+                async_serialize_start();
                 
                 if (active_console == kernel_console) {
                         screen_reclaim();
-                        input_reclaim();
+                        kbd_reclaim();
                         gcons_redraw_console();
                 }
@@ -365 +377 @@
                         
                         /* This call can preempt, but we are already at the end */
-                        rc = async_obsolete_req_4_0(fb_info.phone, FB_DRAW_TEXT_DATA,
+                        rc = async_req_4_0(fb_info.phone, FB_DRAW_TEXT_DATA,
                             0, 0, cons->scr.size_x,
                             cons->scr.size_y);
@@ -393 +405 @@
                 curs_visibility(cons->scr.is_cursor_visible);
                 
-                async_obsolete_serialize_end();
-        }
-}
-
-/** Handler for input events */
-static void input_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+                async_serialize_end();
+        }
+}
+
+static void close_driver_phone(ipc_callid_t hash)
+{
+        int i;
+        for (i = 0; i < MAX_IPC_OUTGOING_PHONES; i++) {
+                if (driver_phones[i] == hash) {
+                        printf("Device %" PRIxn " gone.\n", hash);
+                        driver_phones[i] = 0;
+                        async_hangup(i);
+                        return;
+                }
+        }
+}
+
+/** Handler for keyboard */
+static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)
 {
         /* Ignore parameters, the connection is already opened */
@@ -406 +431 @@
                 
                 int retval;
-                kbd_event_t ev;
-                
-                if (!IPC_GET_IMETHOD(call)) {
+                console_event_t ev;
+                
+                switch (IPC_GET_IMETHOD(call)) {
+                case IPC_M_PHONE_HUNGUP:
                         /* TODO: Handle hangup */
-                        async_obsolete_hangup(input_phone);
+                        close_driver_phone(iid);
                         return;
-                }
-                
-                switch (IPC_GET_IMETHOD(call)) {
-                case INPUT_EVENT_KEY:
-                        /* Got key press/release event */
+                case KBD_EVENT:
+                        /* Got event from keyboard driver. */
                         retval = 0;
                         ev.type = IPC_GET_ARG1(call);
@@ -437 +460 @@
                         fibril_mutex_unlock(&input_mutex);
                         break;
-                case INPUT_EVENT_MOVE:
-                        /* Got pointer move event */
+                default:
+                        retval = ENOENT;
+                }
+                async_answer_0(callid, retval);
+        }
+}
+
+/** Handler for mouse events */
+static void mouse_events(ipc_callid_t iid, ipc_call_t *icall)
+{
+        /* Ignore parameters, the connection is already opened */
+        while (true) {
+                ipc_call_t call;
+                ipc_callid_t callid = async_get_call(&call);
+                
+                int retval;
+                
+                switch (IPC_GET_IMETHOD(call)) {
+                case IPC_M_PHONE_HUNGUP:
+                        /* TODO: Handle hangup */
+                        close_driver_phone(iid);
+                        return;
+                case MEVENT_BUTTON:
+                        if (IPC_GET_ARG1(call) == 1) {
+                                int newcon = gcons_mouse_btn((bool) IPC_GET_ARG2(call));
+                                if (newcon != -1) {
+                                        change_console(&consoles[newcon]);
+                                }
+                        }
+                        retval = 0;
+                        break;
+                case MEVENT_MOVE:
                         gcons_mouse_move((int) IPC_GET_ARG1(call),
                             (int) IPC_GET_ARG2(call));
                         retval = 0;
                         break;
-                case INPUT_EVENT_BUTTON:
-                        /* Got pointer button press/release event */
-                        if (IPC_GET_ARG1(call) == 1) {
-                                int newcon = gcons_mouse_btn((bool) IPC_GET_ARG2(call));
-                                if (newcon != -1)
-                                        change_console(&consoles[newcon]);
-                        }
-                        retval = 0;
-                        break;
                 default:
                         retval = ENOENT;
                 }
+
                 async_answer_0(callid, retval);
         }
@@ -470 +515 @@
         }
         
-        async_obsolete_serialize_start();
+        async_serialize_start();
         
         size_t off = 0;
@@ -478 +523 @@
         }
         
-        async_obsolete_serialize_end();
+        async_serialize_end();
         
         gcons_notify_char(cons->index);
@@ -504 +549 @@
         
         size_t pos = 0;
-        kbd_event_t ev;
+        console_event_t ev;
         fibril_mutex_lock(&input_mutex);
         
@@ -529 +574 @@
 static void cons_get_event(console_t *cons, ipc_callid_t rid, ipc_call_t *request)
 {
-        kbd_event_t ev;
+        console_event_t ev;
         
         fibril_mutex_lock(&input_mutex);
@@ -545 +590 @@
 
 /** Default thread for new connections */
-static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+static void client_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
         console_t *cons = NULL;
@@ -573 +618 @@
         int rc;
         
-        async_obsolete_serialize_start();
+        async_serialize_start();
         if (cons->refcount == 0)
                 gcons_notify_connect(cons->index);
@@ -583 +628 @@
         
         while (true) {
-                async_obsolete_serialize_end();
+                async_serialize_end();
                 callid = async_get_call(&call);
-                async_obsolete_serialize_start();
+                async_serialize_start();
                 
                 arg1 = 0;
@@ -591 +636 @@
                 arg3 = 0;
                 
-                if (!IPC_GET_IMETHOD(call)) {
+                switch (IPC_GET_IMETHOD(call)) {
+                case IPC_M_PHONE_HUNGUP:
                         cons->refcount--;
                         if (cons->refcount == 0)
                                 gcons_notify_disconnect(cons->index);
                         return;
-                }
-                
-                switch (IPC_GET_IMETHOD(call)) {
                 case VFS_OUT_READ:
-                        async_obsolete_serialize_end();
+                        async_serialize_end();
                         cons_read(cons, callid, &call);
-                        async_obsolete_serialize_start();
+                        async_serialize_start();
                         continue;
                 case VFS_OUT_WRITE:
-                        async_obsolete_serialize_end();
+                        async_serialize_end();
                         cons_write(cons, callid, &call);
-                        async_obsolete_serialize_start();
+                        async_serialize_start();
                         continue;
                 case VFS_OUT_SYNC:
                         fb_pending_flush();
                         if (cons == active_console) {
-                                async_obsolete_req_0_0(fb_info.phone, FB_FLUSH);
+                                async_req_0_0(fb_info.phone, FB_FLUSH);
                                 curs_goto(cons->scr.position_x, cons->scr.position_y);
                         }
@@ -619 +662 @@
                         /* Send message to fb */
                         if (cons == active_console)
-                                async_obsolete_msg_0(fb_info.phone, FB_CLEAR);
+                                async_msg_0(fb_info.phone, FB_CLEAR);
                         
                         screenbuffer_clear(&cons->scr);
@@ -678 +721 @@
                         break;
                 case CONSOLE_GET_EVENT:
-                        async_obsolete_serialize_end();
+                        async_serialize_end();
                         cons_get_event(cons, callid, &call);
-                        async_obsolete_serialize_start();
+                        async_serialize_start();
                         continue;
                 case CONSOLE_KCON_ENABLE:
@@ -695 +738 @@
 }
 
-static int connect_input(const char *dev_path)
-{
-        int phone;
-        devmap_handle_t handle;
-        
-        int rc = devmap_device_get_handle(dev_path, &handle, 0);
-        if (rc == EOK) {
-                phone = devmap_obsolete_device_connect(handle, 0);
-                if (phone < 0) {
-                        printf("%s: Failed to connect to input device\n", NAME);
-                        return phone;
-                }
-        } else {
+static int async_connect_to_me_hack(int phone, sysarg_t arg1, sysarg_t arg2,
+sysarg_t arg3, async_client_conn_t client_receiver, ipc_callid_t *hash)
+{
+        sysarg_t task_hash;
+        sysarg_t phone_hash;
+        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
+            NULL, NULL, NULL, &task_hash, &phone_hash);
+        if (rc != EOK)
                 return rc;
-        }
-        
-        /* NB: The callback connection is slotted for removal */
-        rc = async_obsolete_connect_to_me(phone, SERVICE_CONSOLE, 0, 0,
-            input_events, NULL);
-
+
+        if (client_receiver != NULL)
+                async_new_connection(task_hash, phone_hash, phone_hash, NULL,
+                    client_receiver);
+
+        if (hash != NULL) {
+                *hash = phone_hash;
+        }
+
+        return EOK;
+}
+
+static int connect_keyboard_or_mouse(const char *devname,
+    async_client_conn_t handler, const char *path)
+{
+        int fd = open(path, O_RDONLY);
+        if (fd < 0) {
+                return fd;
+        }
+        
+        int phone = fd_phone(fd);
+        close(fd);
+        if (phone < 0) {
+                printf(NAME ": Failed to connect to input device\n");
+                return phone;
+        }
+        
+        ipc_callid_t hash;
+        int rc = async_connect_to_me_hack(phone, SERVICE_CONSOLE, 0, phone,
+            handler, &hash);
         if (rc != EOK) {
-                async_obsolete_hangup(phone);
-                printf("%s: Failed to create callback from input device (%s).\n",
-                    NAME, str_error(rc));
+                async_hangup(phone);
+                printf(NAME ": " \
+                    "Failed to create callback from input device: %s.\n",
+                    str_error(rc));
                 return rc;
         }
         
+        driver_phones[phone] = hash;
+
+        printf(NAME ": found %s \"%s\" (%" PRIxn ").\n", devname, path, hash);
+
         return phone;
 }
 
-static bool console_srv_init(char *input_dev)
-{
-        /* Connect to input server */
-        input_phone = connect_input(input_dev);
-        if (input_phone < 0)
+static int connect_keyboard(const char *path)
+{
+        return connect_keyboard_or_mouse("keyboard", keyboard_events, path);
+}
+
+static int connect_mouse(const char *path)
+{
+        return connect_keyboard_or_mouse("mouse", mouse_events, path);
+}
+
+struct hid_class_info {
+        char *classname;
+        int (*connection_func)(const char *);
+};
+
+/** Periodically check for new keyboards in /dev/class/.
+ *
+ * @param arg Class name.
+ * @return This function should never exit.
+ */
+static int check_new_device_fibril(void *arg)
+{
+        struct hid_class_info *dev_info = arg;
+
+        size_t index = 1;
+
+        while (true) {
+                async_usleep(HOTPLUG_WATCH_INTERVAL);
+                char *path;
+                int rc = asprintf(&path, "/dev/class/%s\\%zu",
+                    dev_info->classname, index);
+                if (rc < 0) {
+                        continue;
+                }
+                rc = 0;
+                rc = dev_info->connection_func(path);
+                if (rc > 0) {
+                        /* We do not allow unplug. */
+                        index++;
+                }
+
+                free(path);
+        }
+
+        return EOK;
+}
+
+
+/** Start a fibril monitoring hot-plugged keyboards.
+ */
+static void check_new_devices_in_background(int (*connection_func)(const char *),
+    const char *classname)
+{
+        struct hid_class_info *dev_info = malloc(sizeof(struct hid_class_info));
+        if (dev_info == NULL) {
+                printf(NAME ": " \
+                    "out of memory, will not start hot-plug-watch fibril.\n");
+                return;
+        }
+        int rc;
+
+        rc = asprintf(&dev_info->classname, "%s", classname);
+        if (rc < 0) {
+                printf(NAME ": failed to format classname: %s.\n",
+                    str_error(rc));
+                return;
+        }
+        dev_info->connection_func = connection_func;
+
+        fid_t fid = fibril_create(check_new_device_fibril, (void *)dev_info);
+        if (!fid) {
+                printf(NAME
+                    ": failed to create hot-plug-watch fibril for %s.\n",
+                    classname);
+                return;
+        }
+        fibril_add_ready(fid);
+}
+
+static bool console_init(char *input)
+{
+        /* Connect to input device */
+        kbd_phone = connect_keyboard(input);
+        if (kbd_phone < 0) {
                 return false;
+        }
+
+        mouse_phone = connect_mouse("/dev/hid_in/mouse");
+        if (mouse_phone < 0) {
+                printf(NAME ": Failed to connect to mouse device: %s.\n",
+                    str_error(mouse_phone));
+        }
         
         /* Connect to framebuffer driver */
-        fb_info.phone = service_obsolete_connect_blocking(SERVICE_VIDEO, 0, 0);
+        fb_info.phone = service_connect_blocking(SERVICE_VIDEO, 0, 0);
         if (fb_info.phone < 0) {
-                printf("%s: Failed to connect to video service\n", NAME);
-                return false;
+                printf(NAME ": Failed to connect to video service\n");
+                return -1;
         }
         
@@ -742 +895 @@
         int rc = devmap_driver_register(NAME, client_connection);
         if (rc < 0) {
-                printf("%s: Unable to register driver (%d)\n", NAME, rc);
+                printf(NAME ": Unable to register driver (%d)\n", rc);
                 return false;
         }
@@ -750 +903 @@
         
         /* Synchronize, the gcons could put something in queue */
-        async_obsolete_req_0_0(fb_info.phone, FB_FLUSH);
-        async_obsolete_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.cols, &fb_info.rows);
-        async_obsolete_req_0_1(fb_info.phone, FB_GET_COLOR_CAP, &fb_info.color_cap);
+        async_req_0_0(fb_info.phone, FB_FLUSH);
+        async_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.cols, &fb_info.rows);
+        async_req_0_1(fb_info.phone, FB_GET_COLOR_CAP, &fb_info.color_cap);
         
         /* Set up shared memory buffer. */
@@ -763 +916 @@
         
         if (interbuffer) {
-                if (async_obsolete_share_out_start(fb_info.phone, interbuffer,
+                if (async_share_out_start(fb_info.phone, interbuffer,
                     AS_AREA_READ) != EOK) {
                         as_area_destroy(interbuffer);
@@ -778 +931 @@
                         if (screenbuffer_init(&consoles[i].scr,
                             fb_info.cols, fb_info.rows) == NULL) {
-                                printf("%s: Unable to allocate screen buffer %zu\n", NAME, i);
+                                printf(NAME ": Unable to allocate screen buffer %zu\n", i);
                                 return false;
                         }
@@ -790 +943 @@
                         
                         if (devmap_device_register(vc, &consoles[i].devmap_handle) != EOK) {
-                                printf("%s: Unable to register device %s\n", NAME, vc);
+                                printf(NAME ": Unable to register device %s\n", vc);
                                 return false;
                         }
@@ -800 +953 @@
         
         /* Initialize the screen */
-        async_obsolete_serialize_start();
+        async_serialize_start();
         gcons_redraw_console();
         set_style(STYLE_NORMAL);
@@ -806 +959 @@
         curs_goto(0, 0);
         curs_visibility(active_console->scr.is_cursor_visible);
-        async_obsolete_serialize_end();
+        async_serialize_end();
         
         /* Receive kernel notifications */
         async_set_interrupt_received(interrupt_received);
         if (event_subscribe(EVENT_KCONSOLE, 0) != EOK)
-                printf("%s: Error registering kconsole notifications\n", NAME);
-        
+                printf(NAME ": Error registering kconsole notifications\n");
+        
+        /* Start fibril for checking on hot-plugged keyboards. */
+        check_new_devices_in_background(connect_keyboard, "keyboard");
+        check_new_devices_in_background(connect_mouse, "mouse");
+
         return true;
 }
@@ -818 +975 @@
 static void usage(void)
 {
-        printf("Usage: console <input_dev>\n");
+        printf("Usage: console <input>\n");
 }
 
@@ -830 +987 @@
         printf(NAME ": HelenOS Console service\n");
         
-        if (!console_srv_init(argv[1]))
+        if (!console_init(argv[1]))
                 return -1;
-        
+
         printf(NAME ": Accepting connections\n");
         async_manager();