Ignore:
File:
1 edited

Legend:

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

    rcce8a83 r333c233  
    3838
    3939#include <adt/list.h>
    40 #include <bool.h>
    4140#include <ipc/services.h>
    4241#include <ipc/input.h>
     
    5453#include <io/console.h>
    5554#include <io/keycode.h>
    56 #include <loc.h>
     55#include <devmap.h>
    5756#include <input.h>
    5857#include <kbd.h>
     
    6463
    6564// FIXME: remove this header
    66 #include <abi/ipc/methods.h>
     65#include <kernel/ipc/ipc_methods.h>
    6766
    6867/* In microseconds */
     
    276275        kdev->port_ops = port;
    277276        kdev->ctl_ops = ctl;
    278         kdev->svc_id = 0;
     277        kdev->dev_path = NULL;
    279278       
    280279        /* Initialize port driver. */
     
    304303        mdev->port_ops = port;
    305304        mdev->proto_ops = proto;
    306         mdev->svc_id = 0;
     305        mdev->dev_path = NULL;
    307306       
    308307        /* Initialize port driver. */
     
    325324/** Add new kbdev device.
    326325 *
    327  * @param service_id    Service ID of the keyboard device
     326 * @param dev_path Filesystem path to the device (/dev/class/...)
    328327 *
    329328 */
    330 static int kbd_add_kbdev(service_id_t service_id, kbd_dev_t **kdevp)
     329static int kbd_add_kbdev(const char *dev_path)
    331330{
    332331        kbd_dev_t *kdev = kbd_dev_new();
     
    334333                return -1;
    335334       
    336         kdev->svc_id = service_id;
     335        kdev->dev_path = dev_path;
    337336        kdev->port_ops = NULL;
    338337        kdev->ctl_ops = &kbdev_ctl;
    339        
    340         int rc = loc_service_get_name(service_id, &kdev->svc_name);
    341         if (rc != EOK) {
    342                 kdev->svc_name = NULL;
    343                 goto fail;
    344         }
    345338       
    346339        /* Initialize controller driver. */
     
    350343       
    351344        list_append(&kdev->kbd_devs, &kbd_devs);
    352         *kdevp = kdev;
    353345        return EOK;
    354346       
    355347fail:
    356         if (kdev->svc_name != NULL)
    357                 free(kdev->svc_name);
    358348        free(kdev);
    359349        return -1;
     
    362352/** Add new mousedev device.
    363353 *
    364  * @param service_id    Service ID of the mouse device
     354 * @param dev_path Filesystem path to the device (/dev/class/...)
    365355 *
    366356 */
    367 static int mouse_add_mousedev(service_id_t service_id, mouse_dev_t **mdevp)
     357static int mouse_add_mousedev(const char *dev_path)
    368358{
    369359        mouse_dev_t *mdev = mouse_dev_new();
     
    371361                return -1;
    372362       
    373         mdev->svc_id = service_id;
     363        mdev->dev_path = dev_path;
    374364        mdev->port_ops = NULL;
    375365        mdev->proto_ops = &mousedev_proto;
    376        
    377         int rc = loc_service_get_name(service_id, &mdev->svc_name);
    378         if (rc != EOK) {
    379                 mdev->svc_name = NULL;
    380                 goto fail;
    381         }
    382366       
    383367        /* Initialize controller driver. */
     
    387371       
    388372        list_append(&mdev->mouse_devs, &mouse_devs);
    389         *mdevp = mdev;
    390373        return EOK;
    391374       
     
    499482/** Periodically check for new input devices.
    500483 *
    501  * Looks under /loc/class/keyboard and /loc/class/mouse.
     484 * Looks under /dev/class/keyboard and /dev/class/mouse.
    502485 *
    503486 * @param arg Ignored
     
    506489static int dev_discovery_fibril(void *arg)
    507490{
    508         category_id_t keyboard_cat, mouse_cat;
    509         service_id_t *svcs;
    510         size_t count, i;
    511         bool already_known;
     491        char *dev_path;
     492        size_t kbd_id = 1;
     493        size_t mouse_id = 1;
    512494        int rc;
    513        
    514         rc = loc_category_get_id("keyboard", &keyboard_cat, IPC_FLAG_BLOCKING);
    515         if (rc != EOK) {
    516                 printf("%s: Failed resolving category 'keyboard'.\n", NAME);
    517                 return ENOENT;
    518         }
    519        
    520         rc = loc_category_get_id("mouse", &mouse_cat, IPC_FLAG_BLOCKING);
    521         if (rc != EOK) {
    522                 printf("%s: Failed resolving category 'mouse'.\n", NAME);
    523                 return ENOENT;
    524         }
    525495       
    526496        while (true) {
     
    528498               
    529499                /*
    530                  * Check for new keyboard devices
     500                 * Check for new keyboard device
    531501                 */
    532                 rc = loc_category_get_svcs(keyboard_cat, &svcs, &count);
    533                 if (rc != EOK) {
    534                         printf("%s: Failed getting list of keyboard devices.\n",
    535                             NAME);
     502                rc = asprintf(&dev_path, "/dev/class/keyboard\\%zu", kbd_id);
     503                if (rc < 0)
    536504                        continue;
     505               
     506                if (kbd_add_kbdev(dev_path) == EOK) {
     507                        printf("%s: Connected keyboard device '%s'\n",
     508                            NAME, dev_path);
     509                       
     510                        /* XXX Handle device removal */
     511                        ++kbd_id;
    537512                }
    538 
    539                 for (i = 0; i < count; i++) {
    540                         already_known = false;
     513               
     514                free(dev_path);
     515               
     516                /*
     517                 * Check for new mouse device
     518                 */
     519                rc = asprintf(&dev_path, "/dev/class/mouse\\%zu", mouse_id);
     520                if (rc < 0)
     521                        continue;
     522               
     523                if (mouse_add_mousedev(dev_path) == EOK) {
     524                        printf("%s: Connected mouse device '%s'\n",
     525                            NAME, dev_path);
    541526                       
    542                         /* Determine whether we already know this device. */
    543                         list_foreach(kbd_devs, kdev_link) {
    544                                 kbd_dev_t *kdev = list_get_instance(kdev_link,
    545                                     kbd_dev_t, kbd_devs);
    546                                 if (kdev->svc_id == svcs[i]) {
    547                                         already_known = true;
    548                                         break;
    549                                 }
    550                         }
    551 
    552                         if (!already_known) {
    553                                 kbd_dev_t *kdev;
    554                                 if (kbd_add_kbdev(svcs[i], &kdev) == EOK) {
    555                                         printf("%s: Connected keyboard device '%s'\n",
    556                                             NAME, kdev->svc_name);
    557                                 }
    558                         }
     527                        /* XXX Handle device removal */
     528                        ++mouse_id;
    559529                }
    560530               
    561                 /* XXX Handle device removal */
    562                
    563                 /*
    564                  * Check for new mouse devices
    565                  */
    566                 rc = loc_category_get_svcs(mouse_cat, &svcs, &count);
    567                 if (rc != EOK) {
    568                         printf("%s: Failed getting list of mouse devices.\n",
    569                             NAME);
    570                         continue;
    571                 }
    572 
    573                 for (i = 0; i < count; i++) {
    574                         already_known = false;
    575                        
    576                         /* Determine whether we already know this device. */
    577                         list_foreach(mouse_devs, mdev_link) {
    578                                 mouse_dev_t *mdev = list_get_instance(mdev_link,
    579                                     mouse_dev_t, mouse_devs);
    580                                 if (mdev->svc_id == svcs[i]) {
    581                                         already_known = true;
    582                                         break;
    583                                 }
    584                         }
    585 
    586                         if (!already_known) {
    587                                 mouse_dev_t *mdev;
    588                                 if (mouse_add_mousedev(svcs[i], &mdev) == EOK) {
    589                                         printf("%s: Connected mouse device '%s'\n",
    590                                             NAME, mdev->svc_name);
    591                                 }
    592                         }
    593                 }
    594                
    595                 /* XXX Handle device removal */
     531                free(dev_path);
    596532        }
    597533       
     
    636572       
    637573        /* Register driver */
    638         int rc = loc_server_register(NAME, client_connection);
     574        int rc = devmap_driver_register(NAME, client_connection);
    639575        if (rc < 0) {
    640                 printf("%s: Unable to register server (%d)\n", NAME, rc);
     576                printf("%s: Unable to register driver (%d)\n", NAME, rc);
    641577                return -1;
    642578        }
    643579       
    644         char kbd[LOC_NAME_MAXLEN + 1];
    645         snprintf(kbd, LOC_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
    646        
    647         service_id_t service_id;
    648         if (loc_service_register(kbd, &service_id) != EOK) {
    649                 printf("%s: Unable to register service %s\n", NAME, kbd);
     580        char kbd[DEVMAP_NAME_MAXLEN + 1];
     581        snprintf(kbd, DEVMAP_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
     582       
     583        devmap_handle_t devmap_handle;
     584        if (devmap_device_register(kbd, &devmap_handle) != EOK) {
     585                printf("%s: Unable to register device %s\n", NAME, kbd);
    650586                return -1;
    651587        }
Note: See TracChangeset for help on using the changeset viewer.