Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/hid/input/generic/input.c

    r336d2f52 rb72efe8  
    5858#include <kbd_port.h>
    5959#include <kbd_ctl.h>
    60 #include <mouse_proto.h>
    6160#include <layout.h>
    6261#include <mouse.h>
     
    6665
    6766/* In microseconds */
    68 #define DISCOVERY_POLL_INTERVAL  (10 * 1000 * 1000)
    69 
    70 #define NUM_LAYOUTS  3
     67#define DISCOVERY_POLL_INTERVAL         (10*1000*1000)
     68
     69static void kbd_devs_yield(void);
     70static void kbd_devs_reclaim(void);
     71
     72static void input_event_key(int, unsigned int, unsigned, wchar_t);
     73
     74int client_phone = -1;
     75
     76/** List of keyboard devices */
     77static list_t kbd_devs;
     78
     79/** List of mouse devices */
     80list_t mouse_devs;
     81
     82bool irc_service = false;
     83int irc_phone = -1;
     84
     85#define NUM_LAYOUTS 3
    7186
    7287static layout_ops_t *layout[NUM_LAYOUTS] = {
     
    7691};
    7792
    78 static void kbd_devs_yield(void);
    79 static void kbd_devs_reclaim(void);
    80 
    81 int client_phone = -1;
    82 
    83 /** List of keyboard devices */
    84 static list_t kbd_devs;
    85 
    86 /** List of mouse devices */
    87 static list_t mouse_devs;
    88 
    89 bool irc_service = false;
    90 int irc_phone = -1;
    91 
    92 void kbd_push_data(kbd_dev_t *kdev, sysarg_t data)
    93 {
    94         (*kdev->ctl_ops->parse)(data);
    95 }
    96 
    97 void mouse_push_data(mouse_dev_t *mdev, sysarg_t data)
    98 {
    99         (*mdev->proto_ops->parse)(data);
    100 }
    101 
    102 void kbd_push_event(kbd_dev_t *kdev, int type, unsigned int key)
     93void kbd_push_scancode(kbd_dev_t *kdev, int scancode)
     94{
     95/*      printf("scancode: 0x%x\n", scancode);*/
     96        (*kdev->ctl_ops->parse_scancode)(scancode);
     97}
     98
     99void kbd_push_ev(kbd_dev_t *kdev, int type, unsigned int key)
    103100{
    104101        kbd_event_t ev;
    105         unsigned int mod_mask;
    106        
     102        unsigned mod_mask;
     103
    107104        switch (key) {
    108105        case KC_LCTRL: mod_mask = KM_LCTRL; break;
     
    114111        default: mod_mask = 0; break;
    115112        }
    116        
     113
    117114        if (mod_mask != 0) {
    118115                if (type == KEY_PRESS)
     
    121118                        kdev->mods = kdev->mods & ~mod_mask;
    122119        }
    123        
     120
    124121        switch (key) {
    125122        case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
     
    128125        default: mod_mask = 0; break;
    129126        }
    130        
     127
    131128        if (mod_mask != 0) {
    132129                if (type == KEY_PRESS) {
     
    138135                        kdev->mods = kdev->mods ^ (mod_mask & ~kdev->lock_keys);
    139136                        kdev->lock_keys = kdev->lock_keys | mod_mask;
    140                        
     137
    141138                        /* Update keyboard lock indicator lights. */
    142139                        (*kdev->ctl_ops->set_ind)(kdev, kdev->mods);
     
    145142                }
    146143        }
    147        
     144/*
     145        printf("type: %d\n", type);
     146        printf("mods: 0x%x\n", mods);
     147        printf("keycode: %u\n", key);
     148*/
    148149        if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
    149             key == KC_F1) {
     150                key == KC_F1) {
    150151                layout_destroy(kdev->active_layout);
    151152                kdev->active_layout = layout_create(layout[0]);
    152153                return;
    153154        }
    154        
     155
    155156        if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
    156             key == KC_F2) {
     157                key == KC_F2) {
    157158                layout_destroy(kdev->active_layout);
    158159                kdev->active_layout = layout_create(layout[1]);
    159160                return;
    160161        }
    161        
     162
    162163        if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
    163             key == KC_F3) {
     164                key == KC_F3) {
    164165                layout_destroy(kdev->active_layout);
    165166                kdev->active_layout = layout_create(layout[2]);
    166167                return;
    167168        }
    168        
     169
    169170        ev.type = type;
    170171        ev.key = key;
    171172        ev.mods = kdev->mods;
    172        
     173
    173174        ev.c = layout_parse_ev(kdev->active_layout, &ev);
    174         async_obsolete_msg_4(client_phone, INPUT_EVENT_KEY, ev.type, ev.key,
    175             ev.mods, ev.c);
     175        input_event_key(ev.type, ev.key, ev.mods, ev.c);
     176}
     177
     178/** Key has been pressed or released. */
     179static void input_event_key(int type, unsigned int key, unsigned mods,
     180    wchar_t c)
     181{
     182        async_obsolete_msg_4(client_phone, INPUT_EVENT_KEY, type, key,
     183            mods, c);
    176184}
    177185
    178186/** Mouse pointer has moved. */
    179 void mouse_push_event_move(mouse_dev_t *mdev, int dx, int dy)
     187void input_event_move(int dx, int dy)
    180188{
    181189        async_obsolete_msg_2(client_phone, INPUT_EVENT_MOVE, dx, dy);
     
    183191
    184192/** Mouse button has been pressed. */
    185 void mouse_push_event_button(mouse_dev_t *mdev, int bnum, int press)
     193void input_event_button(int bnum, int press)
    186194{
    187195        async_obsolete_msg_2(client_phone, INPUT_EVENT_BUTTON, bnum, press);
     
    193201        ipc_call_t call;
    194202        int retval;
    195        
     203
    196204        async_answer_0(iid, EOK);
    197        
     205
    198206        while (true) {
    199207                callid = async_get_call(&call);
     
    229237                        retval = EINVAL;
    230238                }
    231                
    232239                async_answer_0(callid, retval);
    233         }
     240        }       
    234241}
    235242
    236243static kbd_dev_t *kbd_dev_new(void)
    237244{
    238         kbd_dev_t *kdev = calloc(1, sizeof(kbd_dev_t));
     245        kbd_dev_t *kdev;
     246
     247        kdev = calloc(1, sizeof(kbd_dev_t));
    239248        if (kdev == NULL) {
    240                 printf("%s: Error allocating keyboard device. "
    241                     "Out of memory.\n", NAME);
     249                printf(NAME ": Error allocating keyboard device. "
     250                    "Out of memory.\n");
    242251                return NULL;
    243252        }
    244        
     253
    245254        link_initialize(&kdev->kbd_devs);
    246        
     255
    247256        kdev->mods = KM_NUM_LOCK;
    248257        kdev->lock_keys = 0;
    249258        kdev->active_layout = layout_create(layout[0]);
    250        
     259
    251260        return kdev;
    252 }
    253 
    254 static mouse_dev_t *mouse_dev_new(void)
    255 {
    256         mouse_dev_t *mdev = calloc(1, sizeof(mouse_dev_t));
    257         if (mdev == NULL) {
    258                 printf("%s: Error allocating keyboard device. "
    259                     "Out of memory.\n", NAME);
    260                 return NULL;
    261         }
    262        
    263         link_initialize(&mdev->mouse_devs);
    264        
    265         return mdev;
    266261}
    267262
     
    269264static void kbd_add_dev(kbd_port_ops_t *port, kbd_ctl_ops_t *ctl)
    270265{
    271         kbd_dev_t *kdev = kbd_dev_new();
     266        kbd_dev_t *kdev;
     267
     268        kdev = kbd_dev_new();
    272269        if (kdev == NULL)
    273270                return;
    274        
     271
    275272        kdev->port_ops = port;
    276273        kdev->ctl_ops = ctl;
    277274        kdev->dev_path = NULL;
    278        
     275
    279276        /* Initialize port driver. */
    280277        if ((*kdev->port_ops->init)(kdev) != 0)
    281278                goto fail;
    282        
     279
    283280        /* Initialize controller driver. */
    284281        if ((*kdev->ctl_ops->init)(kdev) != 0) {
     
    286283                goto fail;
    287284        }
    288        
     285
    289286        list_append(&kdev->kbd_devs, &kbd_devs);
    290287        return;
    291        
    292288fail:
    293289        free(kdev);
    294290}
    295291
    296 /** Add new legacy mouse device. */
    297 static void mouse_add_dev(mouse_port_ops_t *port, mouse_proto_ops_t *proto)
    298 {
    299         mouse_dev_t *mdev = mouse_dev_new();
    300         if (mdev == NULL)
    301                 return;
    302        
    303         mdev->port_ops = port;
    304         mdev->proto_ops = proto;
    305         mdev->dev_path = NULL;
    306        
    307         /* Initialize port driver. */
    308         if ((*mdev->port_ops->init)(mdev) != 0)
    309                 goto fail;
    310        
    311         /* Initialize protocol driver. */
    312         if ((*mdev->proto_ops->init)(mdev) != 0) {
    313                 /* XXX Uninit port */
    314                 goto fail;
    315         }
    316        
    317         list_append(&mdev->mouse_devs, &mouse_devs);
    318         return;
    319        
    320 fail:
    321         free(mdev);
    322 }
    323 
    324292/** Add new kbdev device.
    325293 *
    326  * @param dev_path Filesystem path to the device (/dev/class/...)
    327  *
     294 * @param dev_path      Filesystem path to the device (/dev/class/...)
    328295 */
    329296static int kbd_add_kbdev(const char *dev_path)
    330297{
    331         kbd_dev_t *kdev = kbd_dev_new();
     298        kbd_dev_t *kdev;
     299
     300        kdev = kbd_dev_new();
    332301        if (kdev == NULL)
    333302                return -1;
    334        
     303
    335304        kdev->dev_path = dev_path;
    336305        kdev->port_ops = NULL;
    337306        kdev->ctl_ops = &kbdev_ctl;
    338        
     307
    339308        /* Initialize controller driver. */
    340309        if ((*kdev->ctl_ops->init)(kdev) != 0) {
    341310                goto fail;
    342311        }
    343        
     312
    344313        list_append(&kdev->kbd_devs, &kbd_devs);
    345314        return EOK;
    346        
    347315fail:
    348316        free(kdev);
    349         return -1;
    350 }
    351 
    352 /** Add new mousedev device.
    353  *
    354  * @param dev_path Filesystem path to the device (/dev/class/...)
    355  *
    356  */
    357 static int mouse_add_mousedev(const char *dev_path)
    358 {
    359         mouse_dev_t *mdev = mouse_dev_new();
    360         if (mdev == NULL)
    361                 return -1;
    362        
    363         mdev->dev_path = dev_path;
    364         mdev->port_ops = NULL;
    365         mdev->proto_ops = &mousedev_proto;
    366        
    367         /* Initialize controller driver. */
    368         if ((*mdev->proto_ops->init)(mdev) != 0) {
    369                 goto fail;
    370         }
    371        
    372         list_append(&mdev->mouse_devs, &mouse_devs);
    373         return EOK;
    374        
    375 fail:
    376         free(mdev);
    377317        return -1;
    378318}
     
    424364        kbd_add_dev(&niagara_port, &stty_ctl);
    425365#endif
     366#if defined(UARCH_sparc64) && defined(MACHINE_serengeti)
     367        kbd_add_dev(&sgcn_port, &stty_ctl);
     368#endif
    426369#if defined(UARCH_sparc64) && defined(MACHINE_generic)
     370        kbd_add_dev(&z8530_port, &sun_ctl);
    427371        kbd_add_dev(&ns16550_port, &sun_ctl);
    428372#endif
    429373        /* Silence warning on abs32le about kbd_add_dev() being unused */
    430374        (void) kbd_add_dev;
    431 }
    432 
    433 /** Add legacy drivers/devices. */
    434 static void mouse_add_legacy_devs(void)
    435 {
    436         /*
    437          * Need to add these drivers based on config unless we can probe
    438          * them automatically.
    439          */
    440 #if defined(UARCH_amd64)
    441         mouse_add_dev(&chardev_mouse_port, &ps2_proto);
    442 #endif
    443 #if defined(UARCH_ia32)
    444         mouse_add_dev(&chardev_mouse_port, &ps2_proto);
    445 #endif
    446 #if defined(MACHINE_i460GX)
    447         mouse_add_dev(&chardev_mouse_port, &ps2_proto);
    448 #endif
    449 #if defined(UARCH_ppc32)
    450         mouse_add_dev(&adb_mouse_port, &adb_proto);
    451 #endif
    452         /* Silence warning on abs32le about mouse_add_dev() being unused */
    453         (void) mouse_add_dev;
    454375}
    455376
     
    460381                kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t,
    461382                    kbd_devs);
    462                
     383
    463384                /* Yield port */
    464385                if (kdev->port_ops != NULL)
     
    473394                kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t,
    474395                    kbd_devs);
    475                
     396
    476397                /* Reclaim port */
    477398                if (kdev->port_ops != NULL)
     
    484405 * Looks under /dev/class/keyboard and /dev/class/mouse.
    485406 *
    486  * @param arg Ignored
    487  *
     407 * @param arg   Ignored
    488408 */
    489409static int dev_discovery_fibril(void *arg)
     
    493413        size_t mouse_id = 1;
    494414        int rc;
    495        
     415
    496416        while (true) {
    497417                async_usleep(DISCOVERY_POLL_INTERVAL);
    498                
     418
    499419                /*
    500420                 * Check for new keyboard device
     
    503423                if (rc < 0)
    504424                        continue;
    505                
     425
    506426                if (kbd_add_kbdev(dev_path) == EOK) {
    507                         printf("%s: Connected keyboard device '%s'\n",
    508                             NAME, dev_path);
    509                        
     427                        printf(NAME ": Connected keyboard device '%s'\n",
     428                            dev_path);
     429
    510430                        /* XXX Handle device removal */
    511431                        ++kbd_id;
    512432                }
    513                
     433
    514434                free(dev_path);
    515                
     435
    516436                /*
    517437                 * Check for new mouse device
     
    520440                if (rc < 0)
    521441                        continue;
    522                
    523                 if (mouse_add_mousedev(dev_path) == EOK) {
    524                         printf("%s: Connected mouse device '%s'\n",
    525                             NAME, dev_path);
    526                        
     442
     443                if (mouse_add_dev(dev_path) == EOK) {
     444                        printf(NAME ": Connected mouse device '%s'\n",
     445                            dev_path);
     446
    527447                        /* XXX Handle device removal */
    528448                        ++mouse_id;
    529449                }
    530                
     450
    531451                free(dev_path);
    532452        }
    533        
     453
    534454        return EOK;
    535455}
     
    538458static void input_start_dev_discovery(void)
    539459{
    540         fid_t fid = fibril_create(dev_discovery_fibril, NULL);
     460        fid_t fid;
     461
     462        fid = fibril_create(dev_discovery_fibril, NULL);
    541463        if (!fid) {
    542                 printf("%s: Failed to create device discovery fibril.\n",
    543                     NAME);
     464                printf(NAME ": Failed to create device discovery fibril.\n");
    544465                return;
    545466        }
    546        
     467
    547468        fibril_add_ready(fid);
    548469}
     
    552473        printf("%s: HelenOS input service\n", NAME);
    553474       
     475        sysarg_t fhc;
    554476        sysarg_t obio;
    555477       
     
    557479        list_initialize(&mouse_devs);
    558480       
    559         if ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))
     481        if (((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc))
     482            || ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio)))
    560483                irc_service = true;
    561484       
     
    567490        /* Add legacy keyboard devices. */
    568491        kbd_add_legacy_devs();
    569        
    570         /* Add legacy mouse devices. */
    571         mouse_add_legacy_devs();
     492
     493        /* Add legacy (devmap-style) mouse device. */
     494        (void) mouse_add_dev("/dev/hid_in/mouse");
    572495       
    573496        /* Register driver */
     
    586509                return -1;
    587510        }
    588        
     511
    589512        /* Start looking for new input devices */
    590513        input_start_dev_discovery();
    591        
    592         printf("%s: Accepting connections\n", NAME);
     514
     515        printf(NAME ": Accepting connections\n");
    593516        async_manager();
    594        
     517
    595518        /* Not reached. */
    596519        return 0;
Note: See TracChangeset for help on using the changeset viewer.