Changeset 593e023 in mainline for uspace/srv/hid/input


Ignore:
Timestamp:
2014-08-12T17:14:32Z (11 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c3bdc92
Parents:
ce3efa0
Message:

allow compositor and console to coexist side-by-side, use the input server as a poor man's seat arbitrator

  • kernel console notifies both about the release and grab events
  • input server arbitrates the seat selection between kernel console and any number of user space UIs (currently the console server and the compositor server)
  • input port yield and reclaim methods have been removed (they are used only on Ski and Niagara, both already need a more generic mechanism for the kernel/user space cooperation)
  • console and compositor server keep track of the kernel console via the input arbitration
  • move the waiting for a character device from init and terminal widget to getterm
Location:
uspace/srv/hid/input
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/hid/input/input.c

    rce3efa0 r593e023  
    5454#include <io/keycode.h>
    5555#include <loc.h>
     56#include <event.h>
     57#include <str_error.h>
    5658#include "layout.h"
    5759#include "kbd.h"
    … …  
    6264#include "input.h"
    6365
     66bool irc_service = false;
     67async_sess_t *irc_sess = NULL;
     68
    6469#define NUM_LAYOUTS  4
    6570
    … …  
    7176};
    7277
    73 static void kbd_devs_yield(void);
    74 static void kbd_devs_reclaim(void);
    75 
    76 async_sess_t *client_sess = NULL;
     78typedef struct {
     79        /** Link into the list of clients */
     80        link_t link;
     81       
     82        /** Indicate whether the client is active */
     83        bool active;
     84       
     85        /** Client callback session */
     86        async_sess_t *sess;
     87} client_t;
     88
     89/** List of clients */
     90static list_t clients;
     91static client_t *active_client = NULL;
    7792
    7893/** List of keyboard devices */
    … …  
    8297static list_t mouse_devs;
    8398
    84 bool irc_service = false;
    85 async_sess_t *irc_sess = NULL;
    86 
    8799static FIBRIL_MUTEX_INITIALIZE(discovery_lock);
     100
     101static void *client_data_create(void)
     102{
     103        client_t *client = (client_t *) calloc(1, sizeof(client_t));
     104        if (client == NULL)
     105                return NULL;
     106       
     107        link_initialize(&client->link);
     108        client->active = false;
     109        client->sess = NULL;
     110       
     111        list_append(&client->link, &clients);
     112       
     113        return client;
     114}
     115
     116static void client_data_destroy(void *data)
     117{
     118        client_t *client = (client_t *) data;
     119       
     120        list_remove(&client->link);
     121        free(client);
     122}
    88123
    89124void kbd_push_data(kbd_dev_t *kdev, sysarg_t data)
    … …  
    199234        ev.c = layout_parse_ev(kdev->active_layout, &ev);
    200235       
    201         async_exch_t *exch = async_exchange_begin(client_sess);
    202         async_msg_4(exch, INPUT_EVENT_KEY, ev.type, ev.key, ev.mods, ev.c);
    203         async_exchange_end(exch);
    204 }
    205 
    206 /** Mouse pointer has moved. */
     236        list_foreach(clients, link, client_t, client) {
     237                if (client->active) {
     238                        async_exch_t *exch = async_exchange_begin(client->sess);
     239                        async_msg_4(exch, INPUT_EVENT_KEY, ev.type, ev.key, ev.mods, ev.c);
     240                        async_exchange_end(exch);
     241                }
     242        }
     243}
     244
     245/** Mouse pointer has moved (relative mode). */
    207246void mouse_push_event_move(mouse_dev_t *mdev, int dx, int dy, int dz)
    208247{
    209         async_exch_t *exch = async_exchange_begin(client_sess);
    210         if (dx || dy)
    211                 async_msg_2(exch, INPUT_EVENT_MOVE, dx, dy);
    212         if (dz) {
    213                 // TODO: Implement proper wheel support
    214                 keycode_t code = dz > 0 ? KC_UP : KC_DOWN;
    215                 for (int i = 0; i < 3; ++i) {
    216                         async_msg_4(exch, INPUT_EVENT_KEY, KEY_PRESS, code, 0, 0);
    217                 }
    218                 async_msg_4(exch, INPUT_EVENT_KEY, KEY_RELEASE, code, 0, 0);
    219         }
    220         async_exchange_end(exch);
    221 }
    222 
    223 /** Mouse pointer has moved in absolute mode. */
     248        list_foreach(clients, link, client_t, client) {
     249                if (client->active) {
     250                        async_exch_t *exch = async_exchange_begin(client->sess);
     251                       
     252                        if ((dx) || (dy))
     253                                async_msg_2(exch, INPUT_EVENT_MOVE, dx, dy);
     254                       
     255                        if (dz) {
     256                                // TODO: Implement proper wheel support
     257                                keycode_t code = dz > 0 ? KC_UP : KC_DOWN;
     258                               
     259                                for (unsigned int i = 0; i < 3; i++)
     260                                        async_msg_4(exch, INPUT_EVENT_KEY, KEY_PRESS, code, 0, 0);
     261                               
     262                                async_msg_4(exch, INPUT_EVENT_KEY, KEY_RELEASE, code, 0, 0);
     263                        }
     264                       
     265                        async_exchange_end(exch);
     266                }
     267        }
     268}
     269
     270/** Mouse pointer has moved (absolute mode). */
    224271void mouse_push_event_abs_move(mouse_dev_t *mdev, unsigned int x, unsigned int y,
    225272    unsigned int max_x, unsigned int max_y)
    226273{
    227         if (max_x && max_y) {
    228                 async_exch_t *exch = async_exchange_begin(client_sess);
    229                 async_msg_4(exch, INPUT_EVENT_ABS_MOVE, x, y, max_x, max_y);
    230                 async_exchange_end(exch);
     274        list_foreach(clients, link, client_t, client) {
     275                if (client->active) {
     276                        if ((max_x) && (max_y)) {
     277                                async_exch_t *exch = async_exchange_begin(client->sess);
     278                                async_msg_4(exch, INPUT_EVENT_ABS_MOVE, x, y, max_x, max_y);
     279                                async_exchange_end(exch);
     280                        }
     281                }
    231282        }
    232283}
    … …  
    235286void mouse_push_event_button(mouse_dev_t *mdev, int bnum, int press)
    236287{
    237         async_exch_t *exch = async_exchange_begin(client_sess);
    238         async_msg_2(exch, INPUT_EVENT_BUTTON, bnum, press);
    239         async_exchange_end(exch);
    240 }
    241 
     288        list_foreach(clients, link, client_t, client) {
     289                if (client->active) {
     290                        async_exch_t *exch = async_exchange_begin(client->sess);
     291                        async_msg_2(exch, INPUT_EVENT_BUTTON, bnum, press);
     292                        async_exchange_end(exch);
     293                }
     294        }
     295}
     296
     297/** Arbitrate client actiovation */
     298static void client_arbitration(client_t *req)
     299{
     300        /* Mutual exclusion of active clients */
     301        list_foreach(clients, link, client_t, client)
     302                client->active = (client == req);
     303       
     304        /* Notify clients about the arbitration */
     305        list_foreach(clients, link, client_t, client) {
     306                async_exch_t *exch = async_exchange_begin(client->sess);
     307                async_msg_0(exch, client->active ?
     308                    INPUT_EVENT_ACTIVE : INPUT_EVENT_DEACTIVE);
     309                async_exchange_end(exch);
     310        }
     311}
     312
     313/** New client connection */
    242314static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    243315{
     316        client_t *client = (client_t *) async_get_client_data();
     317        if (client == NULL) {
     318                async_answer_0(iid, ENOMEM);
     319                return;
     320        }
     321       
    244322        async_answer_0(iid, EOK);
    245323       
    … …  
    249327               
    250328                if (!IPC_GET_IMETHOD(call)) {
    251                         if (client_sess != NULL) {
    252                                 async_hangup(client_sess);
    253                                 client_sess = NULL;
     329                        if (client->sess != NULL) {
     330                                async_hangup(client->sess);
     331                                client->sess = NULL;
    254332                        }
    255333                       
    … …  
    261339                    async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
    262340                if (sess != NULL) {
    263                         if (client_sess == NULL) {
    264                                 client_sess = sess;
     341                        if (client->sess == NULL) {
     342                                client->sess = sess;
    265343                                async_answer_0(callid, EOK);
    266344                        } else
    … …  
    268346                } else {
    269347                        switch (IPC_GET_IMETHOD(call)) {
    270                         case INPUT_YIELD:
    271                                 kbd_devs_yield();
    272                                 async_answer_0(callid, EOK);
    273                                 break;
    274                         case INPUT_RECLAIM:
    275                                 kbd_devs_reclaim();
     348                        case INPUT_ACTIVATE:
     349                                active_client = client;
     350                                client_arbitration(client);
    276351                                async_answer_0(callid, EOK);
    277352                                break;
    … …  
    283358}
    284359
     360static void kconsole_event_received(ipc_callid_t callid, ipc_call_t *call)
     361{
     362        if (IPC_GET_ARG1(*call)) {
     363                /* Kernel console activated */
     364                client_arbitration(NULL);
     365        } else {
     366                /* Kernel console deactivated */
     367                client_arbitration(active_client);
     368        }
     369}
     370
    285371static kbd_dev_t *kbd_dev_new(void)
    286372{
    … …  
    292378        }
    293379       
    294         link_initialize(&kdev->kbd_devs);
     380        link_initialize(&kdev->link);
    295381       
    296382        kdev->mods = KM_NUM_LOCK;
    … …  
    310396        }
    311397       
    312         link_initialize(&mdev->mouse_devs);
     398        link_initialize(&mdev->link);
    313399       
    314400        return mdev;
    … …  
    336422        }
    337423       
    338         list_append(&kdev->kbd_devs, &kbd_devs);
     424        list_append(&kdev->link, &kbd_devs);
    339425        return;
    340426       
    … …  
    364450        }
    365451       
    366         list_append(&mdev->mouse_devs, &mouse_devs);
     452        list_append(&mdev->link, &mouse_devs);
    367453        return;
    368454       
    … …  
    373459/** Add new kbdev device.
    374460 *
    375  * @param service_id    Service ID of the keyboard device
     461 * @param service_id Service ID of the keyboard device
    376462 *
    377463 */
    … …  
    397483        }
    398484       
    399         list_append(&kdev->kbd_devs, &kbd_devs);
     485        list_append(&kdev->link, &kbd_devs);
    400486        *kdevp = kdev;
    401487        return EOK;
    … …  
    410496/** Add new mousedev device.
    411497 *
    412  * @param service_id    Service ID of the mouse device
     498 * @param service_id Service ID of the mouse device
    413499 *
    414500 */
    … …  
    434520        }
    435521       
    436         list_append(&mdev->mouse_devs, &mouse_devs);
     522        list_append(&mdev->link, &mouse_devs);
    437523        *mdevp = mdev;
    438524        return EOK;
    … …  
    489575}
    490576
    491 static void kbd_devs_yield(void)
    492 {
    493         /* For each keyboard device */
    494         list_foreach(kbd_devs, kbd_devs, kbd_dev_t, kdev) {
    495                 /* Yield port */
    496                 if (kdev->port_ops != NULL)
    497                         (*kdev->port_ops->yield)();
    498         }
    499 }
    500 
    501 static void kbd_devs_reclaim(void)
    502 {
    503         /* For each keyboard device */
    504         list_foreach(kbd_devs, kbd_devs, kbd_dev_t, kdev) {
    505                 /* Reclaim port */
    506                 if (kdev->port_ops != NULL)
    507                         (*kdev->port_ops->reclaim)();
    508         }
    509 }
    510 
    511577static int dev_check_new_kbdevs(void)
    512578{
    … …  
    537603               
    538604                /* Determine whether we already know this device. */
    539                 list_foreach(kbd_devs, kbd_devs, kbd_dev_t, kdev) {
     605                list_foreach(kbd_devs, link, kbd_dev_t, kdev) {
    540606                        if (kdev->svc_id == svcs[i]) {
    541607                                already_known = true;
    … …  
    588654               
    589655                /* Determine whether we already know this device. */
    590                 list_foreach(mouse_devs, mouse_devs, mouse_dev_t, mdev) {
     656                list_foreach(mouse_devs, link, mouse_dev_t, mdev) {
    591657                        if (mdev->svc_id == svcs[i]) {
    592658                                already_known = true;
    … …  
    668734        sysarg_t obio;
    669735       
     736        list_initialize(&clients);
    670737        list_initialize(&kbd_devs);
    671738        list_initialize(&mouse_devs);
    … …  
    687754       
    688755        /* Register driver */
     756        async_set_client_data_constructor(client_data_create);
     757        async_set_client_data_destructor(client_data_destroy);
    689758        async_set_client_connection(client_connection);
    690759       
    … …  
    701770                return rc;
    702771        }
     772       
     773        /* Receive kernel notifications */
     774        async_set_interrupt_received(kconsole_event_received);
     775        rc = event_subscribe(EVENT_KCONSOLE, 0);
     776        if (rc != EOK)
     777                printf("%s: Failed to register kconsole notifications (%s)\n",
     778                    NAME, str_error(rc));
    703779       
    704780        /* Start looking for new input devices */

  • uspace/srv/hid/input/kbd.h

    rce3efa0 r593e023  
    4848typedef struct kbd_dev {
    4949        /** Link to kbd_devs list */
    50         link_t kbd_devs;
     50        link_t link;
    5151
    5252        /** Service ID (only for kbdev devices) */

  • uspace/srv/hid/input/kbd_port.h

    rce3efa0 r593e023  
    4444typedef struct kbd_port_ops {
    4545        int (*init)(struct kbd_dev *);
    46         void (*yield)(void);
    47         void (*reclaim)(void);
    4846        void (*write)(uint8_t);
    4947} kbd_port_ops_t;

  • uspace/srv/hid/input/mouse.h

    rce3efa0 r593e023  
    4646typedef struct mouse_dev {
    4747        /** Link to mouse_devs list */
    48         link_t mouse_devs;
     48        link_t link;
    4949       
    5050        /** Service ID (only for mousedev devices) */

  • uspace/srv/hid/input/mouse_port.h

    rce3efa0 r593e023  
    4444typedef struct mouse_port_ops {
    4545        int (*init)(struct mouse_dev *);
    46         void (*yield)(void);
    47         void (*reclaim)(void);
    4846        void (*write)(uint8_t);
    4947} mouse_port_ops_t;

  • uspace/srv/hid/input/port/adb.c

    rce3efa0 r593e023  
    4949
    5050static int adb_port_init(kbd_dev_t *);
    51 static void adb_port_yield(void);
    52 static void adb_port_reclaim(void);
    53 static void adb_port_write(uint8_t data);
     51static void adb_port_write(uint8_t);
    5452
    5553kbd_port_ops_t adb_port = {
    5654        .init = adb_port_init,
    57         .yield = adb_port_yield,
    58         .reclaim = adb_port_reclaim,
    5955        .write = adb_port_write
    6056};
    … …  
    9591       
    9692        return EOK;
    97 }
    98 
    99 static void adb_port_yield(void)
    100 {
    101 }
    102 
    103 static void adb_port_reclaim(void)
    104 {
    10593}
    10694

  • uspace/srv/hid/input/port/adb_mouse.c

    rce3efa0 r593e023  
    109109}
    110110
    111 static void adb_port_yield(void)
    112 {
    113 }
    114 
    115 static void adb_port_reclaim(void)
    116 {
    117 }
    118 
    119111static void adb_port_write(uint8_t data)
    120112{
    … …  
    123115mouse_port_ops_t adb_mouse_port = {
    124116        .init = adb_port_init,
    125         .yield = adb_port_yield,
    126         .reclaim = adb_port_reclaim,
    127117        .write = adb_port_write
    128118};

  • uspace/srv/hid/input/port/chardev.c

    rce3efa0 r593e023  
    4747
    4848static int chardev_port_init(kbd_dev_t *);
    49 static void chardev_port_yield(void);
    50 static void chardev_port_reclaim(void);
    5149static void chardev_port_write(uint8_t data);
    5250
    5351kbd_port_ops_t chardev_port = {
    5452        .init = chardev_port_init,
    55         .yield = chardev_port_yield,
    56         .reclaim = chardev_port_reclaim,
    5753        .write = chardev_port_write
    5854};
    … …  
    115111}
    116112
    117 static void chardev_port_yield(void)
    118 {
    119 }
    120 
    121 static void chardev_port_reclaim(void)
    122 {
    123 }
    124 
    125113static void chardev_port_write(uint8_t data)
    126114{

  • uspace/srv/hid/input/port/msim.c

    rce3efa0 r593e023  
    4444
    4545static int msim_port_init(kbd_dev_t *);
    46 static void msim_port_yield(void);
    47 static void msim_port_reclaim(void);
    4846static void msim_port_write(uint8_t data);
    4947
    5048kbd_port_ops_t msim_port = {
    5149        .init = msim_port_init,
    52         .yield = msim_port_yield,
    53         .reclaim = msim_port_reclaim,
    5450        .write = msim_port_write
    5551};
    … …  
    104100}
    105101
    106 static void msim_port_yield(void)
    107 {
    108 }
    109 
    110 static void msim_port_reclaim(void)
    111 {
    112 }
    113 
    114102static void msim_port_write(uint8_t data)
    115103{

  • uspace/srv/hid/input/port/niagara.c

    rce3efa0 r593e023  
    4848
    4949static int niagara_port_init(kbd_dev_t *);
    50 static void niagara_port_yield(void);
    51 static void niagara_port_reclaim(void);
    5250static void niagara_port_write(uint8_t data);
    5351
    5452kbd_port_ops_t niagara_port = {
    5553        .init = niagara_port_init,
    56         .yield = niagara_port_yield,
    57         .reclaim = niagara_port_reclaim,
    5854        .write = niagara_port_write
    5955};
    … …  
    7975static input_buffer_t input_buffer = (input_buffer_t) AS_AREA_ANY;
    8076
    81 static volatile bool polling_disabled = false;
    8277static void niagara_thread_impl(void *arg);
    8378
    … …  
    108103       
    109104        return 0;
    110 }
    111 
    112 static void niagara_port_yield(void)
    113 {
    114         polling_disabled = true;
    115 }
    116 
    117 static void niagara_port_reclaim(void)
    118 {
    119         polling_disabled = false;
    120105}
    121106
    … …  
    149134
    150135        while (1) {
    151                 if (polling_disabled == false)
    152                         niagara_key_pressed();
     136                niagara_key_pressed();
    153137                usleep(POLL_INTERVAL);
    154138        }

  • uspace/srv/hid/input/port/ns16550.c

    rce3efa0 r593e023  
    4646
    4747static int ns16550_port_init(kbd_dev_t *);
    48 static void ns16550_port_yield(void);
    49 static void ns16550_port_reclaim(void);
    5048static void ns16550_port_write(uint8_t data);
    5149
    5250kbd_port_ops_t ns16550_port = {
    5351        .init = ns16550_port_init,
    54         .yield = ns16550_port_yield,
    55         .reclaim = ns16550_port_reclaim,
    5652        .write = ns16550_port_write
    5753};
    … …  
    146142}
    147143
    148 static void ns16550_port_yield(void)
    149 {
    150 }
    151 
    152 static void ns16550_port_reclaim(void)
    153 {
    154 }
    155 
    156144static void ns16550_port_write(uint8_t data)
    157145{

  • uspace/srv/hid/input/port/pl050.c

    rce3efa0 r593e023  
    4646
    4747static int pl050_port_init(kbd_dev_t *);
    48 static void pl050_port_yield(void);
    49 static void pl050_port_reclaim(void);
    5048static void pl050_port_write(uint8_t data);
    5149
    5250kbd_port_ops_t pl050_port = {
    5351        .init = pl050_port_init,
    54         .yield = pl050_port_yield,
    55         .reclaim = pl050_port_reclaim,
    5652        .write = pl050_port_write
    5753};
    … …  
    129125}
    130126
    131 static void pl050_port_yield(void)
    132 {
    133 }
    134 
    135 static void pl050_port_reclaim(void)
    136 {
    137 }
    138 
    139127static void pl050_port_write(uint8_t data)
    140128{

  • uspace/srv/hid/input/port/ski.c

    rce3efa0 r593e023  
    4545
    4646static int ski_port_init(kbd_dev_t *);
    47 static void ski_port_yield(void);
    48 static void ski_port_reclaim(void);
    4947static void ski_port_write(uint8_t data);
    5048
    5149kbd_port_ops_t ski_port = {
    5250        .init = ski_port_init,
    53         .yield = ski_port_yield,
    54         .reclaim = ski_port_reclaim,
    5551        .write = ski_port_write
    5652};
    … …  
    6460static void ski_thread_impl(void *arg);
    6561static int32_t ski_getchar(void);
    66 
    67 static volatile bool polling_disabled = false;
    6862
    6963/** Initialize Ski port driver. */
    … …  
    8175
    8276        return 0;
    83 }
    84 
    85 static void ski_port_yield(void)
    86 {
    87         polling_disabled = true;
    88 }
    89 
    90 static void ski_port_reclaim(void)
    91 {
    92         polling_disabled = false;
    9377}
    9478
Note: See TracChangeset for help on using the changeset viewer.