Changeset 15f3c3f in mainline for uspace/srv/hid


Ignore:
Timestamp:
2011-06-22T22:00:52Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
86ffa27f
Parents:
ef09a7a
Message:

Rename devmap to loc, devfs to locfs.

Location:
uspace/srv/hid
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/hid/console/console.c

    ref09a7a r15f3c3f  
    5353#include <sysinfo.h>
    5454#include <event.h>
    55 #include <devmap.h>
     55#include <loc.h>
    5656#include <fcntl.h>
    5757#include <vfs/vfs.h>
     
    8181        size_t index;             /**< Console index */
    8282        size_t refcount;          /**< Connection reference count */
    83         devmap_handle_t devmap_handle;  /**< Device handle */
     83        service_id_t service_id;  /**< Service ID */
    8484        keybuffer_t keybuffer;    /**< Buffer for incoming keys. */
    8585        screenbuffer_t scr;       /**< Screenbuffer for saving screen
     
    582582                        continue;
    583583               
    584                 if (consoles[i].devmap_handle == (devmap_handle_t) IPC_GET_ARG1(*icall)) {
     584                if (consoles[i].service_id == (service_id_t) IPC_GET_ARG1(*icall)) {
    585585                        cons = &consoles[i];
    586586                        break;
     
    724724}
    725725
    726 static async_sess_t *connect_input(const char *dev_path)
     726static async_sess_t *connect_input(const char *svc_path)
    727727{
    728728        async_sess_t *sess;
    729729        async_exch_t *exch;
    730         devmap_handle_t handle;
    731        
    732         int rc = devmap_device_get_handle(dev_path, &handle, 0);
     730        service_id_t service_id;
     731       
     732        int rc = loc_service_get_id(svc_path, &service_id, 0);
    733733        if (rc == EOK) {
    734                 sess = devmap_device_connect(EXCHANGE_ATOMIC, handle, 0);
     734                sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
    735735                if (sess == NULL) {
    736736                        printf("%s: Failed to connect to input server\n", NAME);
     
    776776        }
    777777       
    778         /* Register driver */
    779         int rc = devmap_driver_register(NAME, client_connection);
     778        /* Register server */
     779        int rc = loc_server_register(NAME, client_connection);
    780780        if (rc < 0) {
    781                 printf("%s: Unable to register driver (%d)\n", NAME, rc);
     781                printf("%s: Unable to register server (%d)\n", NAME, rc);
    782782                return false;
    783783        }
     
    823823                        consoles[i].refcount = 0;
    824824                       
    825                         char vc[DEVMAP_NAME_MAXLEN + 1];
    826                         snprintf(vc, DEVMAP_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
     825                        char vc[LOC_NAME_MAXLEN + 1];
     826                        snprintf(vc, LOC_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
    827827                       
    828                         if (devmap_device_register(vc, &consoles[i].devmap_handle) != EOK) {
    829                                 printf("%s: Unable to register device %s\n", NAME, vc);
     828                        if (loc_service_register(vc, &consoles[i].service_id) != EOK) {
     829                                printf("%s: Unable to register service %s\n", NAME, vc);
    830830                                return false;
    831831                        }
  • uspace/srv/hid/input/generic/input.c

    ref09a7a r15f3c3f  
    5353#include <io/console.h>
    5454#include <io/keycode.h>
    55 #include <devmap.h>
     55#include <loc.h>
    5656#include <input.h>
    5757#include <kbd.h>
     
    324324/** Add new kbdev device.
    325325 *
    326  * @param dev_path Filesystem path to the device (/dev/class/...)
     326 * @param dev_path Filesystem path to the device (/loc/class/...)
    327327 *
    328328 */
     
    352352/** Add new mousedev device.
    353353 *
    354  * @param dev_path Filesystem path to the device (/dev/class/...)
     354 * @param dev_path Filesystem path to the device (/loc/class/...)
    355355 *
    356356 */
     
    486486/** Periodically check for new input devices.
    487487 *
    488  * Looks under /dev/class/keyboard and /dev/class/mouse.
     488 * Looks under /loc/class/keyboard and /loc/class/mouse.
    489489 *
    490490 * @param arg Ignored
     
    504504                 * Check for new keyboard device
    505505                 */
    506                 rc = asprintf(&dev_path, "/dev/class/keyboard\\%zu", kbd_id);
     506                rc = asprintf(&dev_path, "/loc/class/keyboard\\%zu", kbd_id);
    507507                if (rc < 0)
    508508                        continue;
     
    521521                 * Check for new mouse device
    522522                 */
    523                 rc = asprintf(&dev_path, "/dev/class/mouse\\%zu", mouse_id);
     523                rc = asprintf(&dev_path, "/loc/class/mouse\\%zu", mouse_id);
    524524                if (rc < 0)
    525525                        continue;
     
    573573        /* Add legacy keyboard devices. */
    574574        kbd_add_legacy_devs();
    575        
     575
    576576        /* Add legacy mouse devices. */
    577577        mouse_add_legacy_devs();
    578578       
    579579        /* Register driver */
    580         int rc = devmap_driver_register(NAME, client_connection);
     580        int rc = loc_server_register(NAME, client_connection);
    581581        if (rc < 0) {
    582                 printf("%s: Unable to register driver (%d)\n", NAME, rc);
     582                printf("%s: Unable to register server (%d)\n", NAME, rc);
    583583                return -1;
    584584        }
    585585       
    586         char kbd[DEVMAP_NAME_MAXLEN + 1];
    587         snprintf(kbd, DEVMAP_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
    588        
    589         devmap_handle_t devmap_handle;
    590         if (devmap_device_register(kbd, &devmap_handle) != EOK) {
    591                 printf("%s: Unable to register device %s\n", NAME, kbd);
     586        char kbd[LOC_NAME_MAXLEN + 1];
     587        snprintf(kbd, LOC_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
     588       
     589        service_id_t service_id;
     590        if (loc_service_register(kbd, &service_id) != EOK) {
     591                printf("%s: Unable to register service %s\n", NAME, kbd);
    592592                return -1;
    593593        }
  • uspace/srv/hid/input/port/adb.c

    ref09a7a r15f3c3f  
    4343#include <fcntl.h>
    4444#include <errno.h>
    45 #include <devmap.h>
     45#include <loc.h>
    4646
    4747static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
     
    6666{
    6767        const char *dev = "adb/kbd";
    68         devmap_handle_t handle;
     68        service_id_t service_id;
    6969        async_exch_t *exch;
    7070        int rc;
     
    7272        kbd_dev = kdev;
    7373       
    74         rc = devmap_device_get_handle(dev, &handle, 0);
     74        rc = loc_service_get_id(dev, &service_id, 0);
    7575        if (rc != EOK)
    7676                return rc;
    7777       
    78         dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle, 0);
     78        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
    7979        if (dev_sess == NULL) {
    8080                printf("%s: Failed to connect to device\n", NAME);
  • uspace/srv/hid/input/port/adb_mouse.c

    ref09a7a r15f3c3f  
    4141#include <mouse.h>
    4242#include <errno.h>
    43 #include <devmap.h>
     43#include <loc.h>
    4444
    4545static mouse_dev_t *mouse_dev;
     
    7878        mouse_dev = mdev;
    7979       
    80         devmap_handle_t handle;
    81         int rc = devmap_device_get_handle(dev, &handle, 0);
     80        service_id_t service_id;
     81        int rc = loc_service_get_id(dev, &service_id, 0);
    8282        if (rc != EOK)
    8383                return rc;
    8484       
    85         dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle, 0);
     85        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
    8686        if (dev_sess == NULL) {
    8787                printf("%s: Failed to connect to device\n", NAME);
  • uspace/srv/hid/input/port/chardev.c

    ref09a7a r15f3c3f  
    4040#include <kbd_port.h>
    4141#include <kbd.h>
    42 #include <devmap.h>
     42#include <loc.h>
    4343#include <errno.h>
    4444#include <stdio.h>
     
    7171static int chardev_port_init(kbd_dev_t *kdev)
    7272{
    73         devmap_handle_t handle;
     73        service_id_t service_id;
    7474        async_exch_t *exch;
    7575        unsigned int i;
     
    7979       
    8080        for (i = 0; i < num_devs; i++) {
    81                 rc = devmap_device_get_handle(in_devs[i], &handle, 0);
     81                rc = loc_service_get_id(in_devs[i], &service_id, 0);
    8282                if (rc == EOK)
    8383                        break;
     
    8989        }
    9090       
    91         dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle,
     91        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id,
    9292            IPC_FLAG_BLOCKING);
    9393        if (dev_sess == NULL) {
  • uspace/srv/hid/input/port/chardev_mouse.c

    ref09a7a r15f3c3f  
    3939#include <async.h>
    4040#include <errno.h>
    41 #include <devmap.h>
     41#include <loc.h>
    4242#include <input.h>
    4343#include <mouse_port.h>
     
    8282static int chardev_port_init(mouse_dev_t *mdev)
    8383{
    84         devmap_handle_t handle;
     84        service_id_t service_id;
    8585        unsigned int i;
    8686        int rc;
     
    8989       
    9090        for (i = 0; i < num_devs; i++) {
    91                 rc = devmap_device_get_handle(in_devs[i], &handle, 0);
     91                rc = loc_service_get_id(in_devs[i], &service_id, 0);
    9292                if (rc == EOK)
    9393                        break;
     
    9999        }
    100100       
    101         dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle,
     101        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id,
    102102            IPC_FLAG_BLOCKING);
    103103        if (dev_sess == NULL) {
  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c

    ref09a7a r15f3c3f  
    3939#include <ddi.h>
    4040#include <libarch/ddi.h>
    41 #include <devmap.h>
     41#include <loc.h>
    4242#include <io/console.h>
    4343#include <vfs/vfs.h>
     
    9090        printf(NAME ": S3C24xx touchscreen driver\n");
    9191
    92         rc = devmap_driver_register(NAME, s3c24xx_ts_connection);
     92        rc = loc_server_register(NAME, s3c24xx_ts_connection);
    9393        if (rc < 0) {
    9494                printf(NAME ": Unable to register driver.\n");
     
    103103                return -1;
    104104
    105         rc = devmap_device_register(NAMESPACE "/mouse", &ts->devmap_handle);
     105        rc = loc_service_register(NAMESPACE "/mouse", &ts->service_id);
    106106        if (rc != EOK) {
    107107                printf(NAME ": Unable to register device %s.\n",
  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.h

    ref09a7a r15f3c3f  
    124124        int client_phone;
    125125
    126         /** Device handle */
    127         devmap_handle_t devmap_handle;
     126        /** Service ID */
     127        service_id_t service_id;
    128128
    129129        /** Device/driver state */
Note: See TracChangeset for help on using the changeset viewer.