Changes in / [40f606b:3b2e387] in mainline


Ignore:
Files:
8 added
14 deleted
45 edited

Legend:

Unmodified
Added
Removed

  • boot/arch/amd64/Makefile.inc

    r40f606b r3b2e387  
    3535
    3636RD_SRVS_NON_ESSENTIAL += \
    37         $(USPACE_PATH)/srv/bd/ata_bd/ata_bd \
    38         $(USPACE_PATH)/srv/hid/char_mouse/char_ms
     37        $(USPACE_PATH)/srv/bd/ata_bd/ata_bd
    3938
    4039RD_DRVS += \

  • boot/arch/ppc32/Makefile.inc

    r40f606b r3b2e387  
    4343        $(USPACE_PATH)/srv/hw/bus/cuda_adb/cuda_adb
    4444
    45 RD_SRVS_NON_ESSENTIAL += \
    46         $(USPACE_PATH)/srv/hid/adb_mouse/adb_ms
    47 
    4845RD_DRVS += \
    4946        infrastructure/rootmac

  • uspace/Makefile

    r40f606b r3b2e387  
    8181        srv/fs/devfs \
    8282        srv/fs/ext2fs \
    83         srv/hid/adb_mouse \
    84         srv/hid/char_mouse \
    8583        srv/hid/s3c24xx_ts \
    8684        srv/hid/fb \

  • uspace/app/init/init.c

    r40f606b r3b2e387  
    275275        srv_start("/srv/i8042");
    276276        srv_start("/srv/s3c24ser");
    277         srv_start("/srv/adb_ms");
    278         srv_start("/srv/char_ms");
    279277        srv_start("/srv/s3c24ts");
    280278       
    281279        spawn("/srv/fb");
    282280        spawn("/srv/input");
    283         console("hid_in/input");
     281        console("hid/input");
    284282       
    285283        spawn("/srv/clip");

  • uspace/app/klog/klog.c

    r40f606b r3b2e387  
    143143 * Receives kernel klog notifications.
    144144 *
    145  * @param callid        IPC call ID
    146  * @param call          IPC call structure
    147  * @param arg           Local argument
     145 * @param callid IPC call ID
     146 * @param call   IPC call structure
     147 * @param arg    Local argument
    148148 *
    149149 */

  • uspace/app/mkbd/main.c

    r40f606b r3b2e387  
    280280        size_t actual_size;
    281281        int event_nr;
    282 
     282       
    283283        while (true) {
    284284                /** @todo Try blocking call. */

  • uspace/app/trace/trace.c

    r40f606b r3b2e387  
    792792        proto_register(SERVICE_VFS, p);
    793793
     794#if 0
    794795        p = proto_new("console");
    795796
    … …  
    827828        proto_console = p;
    828829        proto_register(SERVICE_CONSOLE, p);
     830#endif
    829831}
    830832

  • uspace/drv/bus/usb/usbhid/mouse/mousedev.c

    r40f606b r3b2e387  
    4444#include <async_obsolete.h>
    4545#include <str_error.h>
    46 #include <ipc/mouse.h>
     46#include <ipc/mouseev.h>
    4747#include <io/console.h>
    4848
    … …  
    270270        if ((shift_x != 0) || (shift_y != 0)) {
    271271                async_obsolete_req_2_0(mouse_dev->mouse_phone,
    272                     MEVENT_MOVE, shift_x, shift_y);
     272                    MOUSEEV_MOVE_EVENT, shift_x, shift_y);
    273273        }
    274274
    … …  
    296296                    && field->value != 0) {
    297297                        async_obsolete_req_2_0(mouse_dev->mouse_phone,
    298                             MEVENT_BUTTON, field->usage, 1);
     298                            MOUSEEV_BUTTON_EVENT, field->usage, 1);
    299299                        mouse_dev->buttons[field->usage - field->usage_minimum]
    300300                            = field->value;
    301                 } else if (
    302                     mouse_dev->buttons[field->usage - field->usage_minimum] != 0
     301                } else if (mouse_dev->buttons[field->usage - field->usage_minimum] != 0
    303302                    && field->value == 0) {
    304                        async_obsolete_req_2_0(mouse_dev->mouse_phone,
    305                            MEVENT_BUTTON, field->usage, 0);
    306                        mouse_dev->buttons[field->usage - field->usage_minimum]
    307                            = field->value;
    308                }
     303                        async_obsolete_req_2_0(mouse_dev->mouse_phone,
     304                           MOUSEEV_BUTTON_EVENT, field->usage, 0);
     305                        mouse_dev->buttons[field->usage - field->usage_minimum] =
     306                           field->value;
     307                }
    309308               
    310309                field = usb_hid_report_get_sibling(

  • uspace/drv/bus/usb/usbmouse/mouse.c

    r40f606b r3b2e387  
    3838#include <errno.h>
    3939#include <str_error.h>
    40 #include <ipc/mouse.h>
     40#include <ipc/mouseev.h>
    4141#include <async.h>
    4242#include "mouse.h"
    … …  
    8686                       
    8787                        async_exch_t *exch = async_exchange_begin(mouse->console_sess);
    88                         async_req_2_0(exch, MEVENT_MOVE, -shift_x / 10, -shift_y / 10);
     88                        async_req_2_0(exch, MOUSEEV_MOVE_EVENT, -shift_x / 10, -shift_y / 10);
    8989                        async_exchange_end(exch);
    9090                }
    … …  
    9393                       
    9494                        async_exch_t *exch = async_exchange_begin(mouse->console_sess);
    95                         async_req_2_0(exch, MEVENT_BUTTON, 1, 1);
    96                         async_req_2_0(exch, MEVENT_BUTTON, 1, 0);
     95                        async_req_2_0(exch, MOUSEEV_BUTTON_EVENT, 1, 1);
     96                        async_req_2_0(exch, MOUSEEV_BUTTON_EVENT, 1, 0);
    9797                        async_exchange_end(exch);
    9898                }

  • uspace/lib/c/generic/async.c

    r40f606b r3b2e387  
    213213 * This function is defined as a weak symbol - to be redefined in user code.
    214214 *
    215  * @param callid        Hash of the incoming call.
    216  * @param call          Data of the incoming call.
    217  * @param arg           Local argument
     215 * @param callid Hash of the incoming call.
     216 * @param call   Data of the incoming call.
     217 * @param arg    Local argument
    218218 *
    219219 */
    … …  
    228228 * This function is defined as a weak symbol - to be redefined in user code.
    229229 *
    230  * @param callid        Hash of the incoming call.
    231  * @param call          Data of the incoming call.
    232  * @param arg           Local argument.
     230 * @param callid Hash of the incoming call.
     231 * @param call   Data of the incoming call.
     232 * @param arg    Local argument.
    233233 *
    234234 */
    … …  
    709709 * @param cfibril       Fibril function that should be called upon opening the
    710710 *                      connection.
    711  * @param carg          Extra argument to pass to the connection fibril
     711 * @param carg          Extra argument to pass to the connection fibril
    712712 *
    713713 * @return New fibril id or NULL on failure.

  • uspace/lib/c/generic/str.c

    r40f606b r3b2e387  
    540540
    541541        dstr_size = str_size(dest);
    542         if (dstr_size >= size) {
     542        if (dstr_size >= size)
    543543                return;
    544         }
     544       
    545545        str_cpy(dest + dstr_size, size - dstr_size, src);
    546546}

  • uspace/lib/c/generic/task.c

    r40f606b r3b2e387  
    190190       
    191191        return EOK;
     192       
    192193error:
    193194        /* Error exit */

  • uspace/lib/c/include/async.h

    r40f606b r3b2e387  
    5555/** Client connection handler
    5656 *
    57  * @param callid        ID of incoming call or 0 if connection initiated from
    58  *                      inside using async_connect_to_me()
    59  * @param call          Incoming call or 0 if connection initiated from inside
    60  * @param arg           Local argument passed from async_new_connection() or
    61  *                      async_connect_to_me()
     57 * @param callid ID of incoming call or 0 if connection initiated from
     58 *               inside using async_connect_to_me()
     59 * @param call   Incoming call or 0 if connection initiated from inside
     60 * @param arg    Local argument passed from async_new_connection() or
     61 *               async_connect_to_me()
    6262 */
    6363typedef void (*async_client_conn_t)(ipc_callid_t, ipc_call_t *, void *);

  • uspace/lib/c/include/ipc/services.h

    r40f606b r3b2e387  
    4343        SERVICE_PCI,
    4444        SERVICE_VIDEO,
    45         SERVICE_CONSOLE,
    4645        SERVICE_VFS,
    4746        SERVICE_DEVMAP,

  • uspace/lib/usb/src/debug.c

    r40f606b r3b2e387  
    6868                if (rc > 0) {
    6969                        log_stream = fopen(fname, "w");
    70                         if (log_stream != NULL) {
     70                        if (log_stream != NULL)
    7171                                setvbuf(log_stream, NULL, _IOFBF, BUFSIZ);
    72                         }
     72                       
    7373                        free(fname);
    7474                }

  • uspace/lib/usbvirt/src/device.c

    r40f606b r3b2e387  
    4949/** Main IPC call handling from virtual host controller.
    5050 *
    51  * @param iid           Caller identification
    52  * @param icall         Initial incoming call
    53  * @param arg           Local argument
     51 * @param iid   Caller identification
     52 * @param icall Initial incoming call
     53 * @param arg   Local argument
    5454 */
    5555static void callback_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)

  • uspace/srv/fs/fat/fat_idx.c

    r40f606b r3b2e387  
    5959typedef struct {
    6060        link_t          link;
    61         devmap_handle_t devmap_handle;
     61        devmap_handle_t devmap_handle;
    6262
    6363        /** Next unassigned index. */
    64         fs_index_t      next;
     64        fs_index_t next;
    6565        /** Number of remaining unassigned indices. */
    66         uint64_t        remaining;
     66        uint64_t remaining;
    6767
    6868        /** Sorted list of intervals of freed indices. */
    69         list_t          freed_list;
     69        list_t freed_list;
    7070} unused_t;
    7171
    … …  
    9797                        return u;
    9898        }
    99 
     99       
    100100        if (lock)
    101101                fibril_mutex_unlock(&unused_lock);

  • uspace/srv/hid/console/console.c

    r40f606b r3b2e387  
    482482                        retval = ENOENT;
    483483                }
     484
    484485                async_answer_0(callid, retval);
    485486        }
    … …  
    747748       
    748749        /* NB: The callback connection is slotted for removal */
    749         rc = async_connect_to_me(exch, SERVICE_CONSOLE, 0, 0, input_events,
    750             NULL);
     750        rc = async_connect_to_me(exch, 0, 0, 0, input_events, NULL);
    751751
    752752        async_exchange_end(exch);

  • uspace/srv/hid/input/Makefile

    r40f606b r3b2e387  
    3636        generic/input.c \
    3737        generic/layout.c \
    38         generic/mouse.c \
    3938        generic/stroke.c \
    4039        layout/cz.c \
    … …  
    4241        layout/us_dvorak.c \
    4342        port/adb.c \
     43        port/adb_mouse.c \
    4444        port/chardev.c \
     45        port/chardev_mouse.c \
    4546        port/gxemul.c \
    4647        port/msim.c \
    … …  
    5152        port/ski.c \
    5253        port/z8530.c \
     54        proto/adb.c \
     55        proto/mousedev.c \
     56        proto/ps2.c \
    5357        ctl/apple.c \
    5458        ctl/gxe_fb.c \

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

    r40f606b r3b2e387  
    3333/**
    3434 * @file
    35  * @brief       Apple ADB keyboard controller driver.
     35 * @brief Apple ADB keyboard controller driver.
    3636 */
    3737
    … …  
    4242#include <kbd_port.h>
    4343
    44 static void apple_ctl_parse_scancode(int);
     44static void apple_ctl_parse(sysarg_t);
    4545static int apple_ctl_init(kbd_dev_t *);
    46 static void apple_ctl_set_ind(kbd_dev_t *, unsigned);
     46static void apple_ctl_set_ind(kbd_dev_t *, unsigned int);
    4747
    4848kbd_ctl_ops_t apple_ctl = {
    49         .parse_scancode = apple_ctl_parse_scancode,
     49        .parse = apple_ctl_parse,
    5050        .init = apple_ctl_init,
    5151        .set_ind = apple_ctl_set_ind
    … …  
    6464}
    6565
    66 static void apple_ctl_parse_scancode(int scancode)
     66static void apple_ctl_parse(sysarg_t scancode)
    6767{
    6868        kbd_event_type_t type;
    6969        unsigned int key;
    7070
    71         if (scancode < 0 || scancode >= 0x100)
     71        if (scancode >= 0x100)
    7272                return;
    7373
    … …  
    8181        key = scanmap[scancode];
    8282        if (key != 0)
    83                 kbd_push_ev(kbd_dev, type, key);
     83                kbd_push_event(kbd_dev, type, key);
    8484}
    8585

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

    r40f606b r3b2e387  
    4444#include <stroke.h>
    4545
    46 static void gxe_fb_ctl_parse_scancode(int);
     46static void gxe_fb_ctl_parse(sysarg_t);
    4747static int gxe_fb_ctl_init(kbd_dev_t *);
    48 static void gxe_fb_ctl_set_ind(kbd_dev_t *, unsigned);
     48static void gxe_fb_ctl_set_ind(kbd_dev_t *, unsigned int);
    4949
    5050kbd_ctl_ops_t gxe_fb_ctl = {
    51         .parse_scancode = gxe_fb_ctl_parse_scancode,
     51        .parse = gxe_fb_ctl_parse,
    5252        .init = gxe_fb_ctl_init,
    5353        .set_ind = gxe_fb_ctl_set_ind
    … …  
    229229}
    230230
    231 static void gxe_fb_ctl_parse_scancode(int scancode)
     231static void gxe_fb_ctl_parse(sysarg_t scancode)
    232232{
    233233        unsigned mods, key;

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

    r40f606b r3b2e387  
    5353
    5454static int kbdev_ctl_init(kbd_dev_t *);
    55 static void kbdev_ctl_set_ind(kbd_dev_t *, unsigned);
     55static void kbdev_ctl_set_ind(kbd_dev_t *, unsigned int);
    5656
    5757static void kbdev_callback_conn(ipc_callid_t, ipc_call_t *, void *arg);
    5858
    5959kbd_ctl_ops_t kbdev_ctl = {
    60         .parse_scancode = NULL,
     60        .parse = NULL,
    6161        .init = kbdev_ctl_init,
    6262        .set_ind = kbdev_ctl_set_ind
    … …  
    116116        sess = fd_session(EXCHANGE_SERIALIZE, fd);
    117117        if (sess == NULL) {
    118                 printf(NAME ": Failed starting session with '%s'\n", pathname);
     118                printf("%s: Failed starting session with '%s'\n", NAME, pathname);
    119119                close(fd);
    120120                return -1;
    … …  
    123123        kbdev = kbdev_new(kdev);
    124124        if (kbdev == NULL) {
    125                 printf(NAME ": Failed allocating device structure for '%s'.\n",
    126                     pathname);
     125                printf("%s: Failed allocating device structure for '%s'.\n",
     126                    NAME, pathname);
    127127                return -1;
    128128        }
    … …  
    133133        exch = async_exchange_begin(sess);
    134134        if (exch == NULL) {
    135                 printf(NAME ": Failed starting exchange with '%s'.\n", pathname);
     135                printf("%s: Failed starting exchange with '%s'.\n", NAME, pathname);
    136136                kbdev_destroy(kbdev);
    137137                return -1;
    … …  
    140140        rc = async_connect_to_me(exch, 0, 0, 0, kbdev_callback_conn, kbdev);
    141141        if (rc != EOK) {
    142                 printf(NAME ": Failed creating callback connection from '%s'.\n",
    143                     pathname);
     142                printf("%s: Failed creating callback connection from '%s'.\n",
     143                    NAME, pathname);
    144144                async_exchange_end(exch);
    145145                kbdev_destroy(kbdev);
    … …  
    193193                        type = IPC_GET_ARG1(call);
    194194                        key = IPC_GET_ARG2(call);
    195                         kbd_push_ev(kbdev->kbd_dev, type, key);
     195                        kbd_push_event(kbdev->kbd_dev, type, key);
    196196                        break;
    197197                default:

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

    r40f606b r3b2e387  
    4343#include <gsp.h>
    4444
    45 static void pc_ctl_parse_scancode(int);
     45static void pc_ctl_parse(sysarg_t);
    4646static int pc_ctl_init(kbd_dev_t *);
    47 static void pc_ctl_set_ind(kbd_dev_t *, unsigned);
     47static void pc_ctl_set_ind(kbd_dev_t *, unsigned int);
    4848
    4949kbd_ctl_ops_t pc_ctl = {
    50         .parse_scancode = pc_ctl_parse_scancode,
     50        .parse = pc_ctl_parse,
    5151        .init = pc_ctl_init,
    5252        .set_ind = pc_ctl_set_ind
    … …  
    215215}
    216216
    217 static void pc_ctl_parse_scancode(int scancode)
     217static void pc_ctl_parse(sysarg_t scancode)
    218218{
    219219        kbd_event_type_t type;
    … …  
    257257        }
    258258
    259         if ((scancode < 0) || ((size_t) scancode >= map_length))
     259        if ((size_t) scancode >= map_length)
    260260                return;
    261261
    262262        key = map[scancode];
    263263        if (key != 0)
    264                 kbd_push_ev(kbd_dev, type, key);
     264                kbd_push_event(kbd_dev, type, key);
    265265}
    266266

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

    r40f606b r3b2e387  
    3333/**
    3434 * @file
    35  * @brief       Serial TTY-like keyboard controller driver.
     35 * @brief Serial TTY-like keyboard controller driver.
    3636 */
    3737
    … …  
    4343#include <stroke.h>
    4444
    45 static void stty_ctl_parse_scancode(int);
     45static void stty_ctl_parse(sysarg_t);
    4646static int stty_ctl_init(kbd_dev_t *);
    47 static void stty_ctl_set_ind(kbd_dev_t *, unsigned);
     47static void stty_ctl_set_ind(kbd_dev_t *, unsigned int);
    4848
    4949kbd_ctl_ops_t stty_ctl = {
    50         .parse_scancode = stty_ctl_parse_scancode,
     50        .parse = stty_ctl_parse,
    5151        .init = stty_ctl_init,
    5252        .set_ind = stty_ctl_set_ind
    … …  
    228228}
    229229
    230 static void stty_ctl_parse_scancode(int scancode)
     230static void stty_ctl_parse(sysarg_t scancode)
    231231{
    232232        unsigned mods, key;

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

    r40f606b r3b2e387  
    3434/**
    3535 * @file
    36  * @brief       Sun keyboard controller driver.
     36 * @brief Sun keyboard controller driver.
    3737 */
    3838
    … …  
    4343#include <kbd_port.h>
    4444
    45 static void sun_ctl_parse_scancode(int);
     45static void sun_ctl_parse(sysarg_t);
    4646static int sun_ctl_init(kbd_dev_t *);
    47 static void sun_ctl_set_ind(kbd_dev_t *, unsigned);
     47static void sun_ctl_set_ind(kbd_dev_t *, unsigned int);
    4848
    4949kbd_ctl_ops_t sun_ctl = {
    50         .parse_scancode = sun_ctl_parse_scancode,
     50        .parse = sun_ctl_parse,
    5151        .init = sun_ctl_init,
    5252        .set_ind = sun_ctl_set_ind
    … …  
    6666}
    6767
    68 static void sun_ctl_parse_scancode(int scancode)
     68static void sun_ctl_parse(sysarg_t scancode)
    6969{
    7070        kbd_event_type_t type;
    7171        unsigned int key;
    7272
    73         if (scancode < 0 || scancode >= 0x100)
     73        if (scancode >= 0x100)
    7474                return;
    7575
    … …  
    8686        key = scanmap_simple[scancode];
    8787        if (key != 0)
    88                 kbd_push_ev(kbd_dev, type, key);
     88                kbd_push_event(kbd_dev, type, key);
    8989}
    9090

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

    r40f606b r3b2e387  
    5858#include <kbd_port.h>
    5959#include <kbd_ctl.h>
     60#include <mouse_proto.h>
    6061#include <layout.h>
    6162#include <mouse.h>
    … …  
    6566
    6667/* In microseconds */
    67 #define DISCOVERY_POLL_INTERVAL         (10*1000*1000)
    68 
    69 static void kbd_devs_yield(void);
    70 static void kbd_devs_reclaim(void);
    71 
    72 static void input_event_key(int, unsigned int, unsigned, wchar_t);
    73 
    74 int client_phone = -1;
    75 
    76 /** List of keyboard devices */
    77 static list_t kbd_devs;
    78 
    79 /** List of mouse devices */
    80 list_t mouse_devs;
    81 
    82 bool irc_service = false;
    83 int irc_phone = -1;
    84 
    85 #define NUM_LAYOUTS 3
     68#define DISCOVERY_POLL_INTERVAL  (10 * 1000 * 1000)
     69
     70#define NUM_LAYOUTS  3
    8671
    8772static layout_ops_t *layout[NUM_LAYOUTS] = {
    … …  
    9176};
    9277
    93 void 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 
    99 void kbd_push_ev(kbd_dev_t *kdev, int type, unsigned int key)
     78static void kbd_devs_yield(void);
     79static void kbd_devs_reclaim(void);
     80
     81int client_phone = -1;
     82
     83/** List of keyboard devices */
     84static list_t kbd_devs;
     85
     86/** List of mouse devices */
     87static list_t mouse_devs;
     88
     89bool irc_service = false;
     90int irc_phone = -1;
     91
     92void kbd_push_data(kbd_dev_t *kdev, sysarg_t data)
     93{
     94        (*kdev->ctl_ops->parse)(data);
     95}
     96
     97void mouse_push_data(mouse_dev_t *mdev, sysarg_t data)
     98{
     99        (*mdev->proto_ops->parse)(data);
     100}
     101
     102void kbd_push_event(kbd_dev_t *kdev, int type, unsigned int key)
    100103{
    101104        kbd_event_t ev;
    102         unsigned mod_mask;
    103 
     105        unsigned int mod_mask;
     106       
    104107        switch (key) {
    105108        case KC_LCTRL: mod_mask = KM_LCTRL; break;
    … …  
    111114        default: mod_mask = 0; break;
    112115        }
    113 
     116       
    114117        if (mod_mask != 0) {
    115118                if (type == KEY_PRESS)
    … …  
    118121                        kdev->mods = kdev->mods & ~mod_mask;
    119122        }
    120 
     123       
    121124        switch (key) {
    122125        case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
    … …  
    125128        default: mod_mask = 0; break;
    126129        }
    127 
     130       
    128131        if (mod_mask != 0) {
    129132                if (type == KEY_PRESS) {
    … …  
    135138                        kdev->mods = kdev->mods ^ (mod_mask & ~kdev->lock_keys);
    136139                        kdev->lock_keys = kdev->lock_keys | mod_mask;
    137 
     140                       
    138141                        /* Update keyboard lock indicator lights. */
    139142                        (*kdev->ctl_ops->set_ind)(kdev, kdev->mods);
    … …  
    142145                }
    143146        }
    144 /*
    145         printf("type: %d\n", type);
    146         printf("mods: 0x%x\n", mods);
    147         printf("keycode: %u\n", key);
    148 */
     147       
    149148        if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
    150                 key == KC_F1) {
     149            key == KC_F1) {
    151150                layout_destroy(kdev->active_layout);
    152151                kdev->active_layout = layout_create(layout[0]);
    153152                return;
    154153        }
    155 
     154       
    156155        if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
    157                 key == KC_F2) {
     156            key == KC_F2) {
    158157                layout_destroy(kdev->active_layout);
    159158                kdev->active_layout = layout_create(layout[1]);
    160159                return;
    161160        }
    162 
     161       
    163162        if (type == KEY_PRESS && (kdev->mods & KM_LCTRL) &&
    164                 key == KC_F3) {
     163            key == KC_F3) {
    165164                layout_destroy(kdev->active_layout);
    166165                kdev->active_layout = layout_create(layout[2]);
    167166                return;
    168167        }
    169 
     168       
    170169        ev.type = type;
    171170        ev.key = key;
    172171        ev.mods = kdev->mods;
    173 
     172       
    174173        ev.c = layout_parse_ev(kdev->active_layout, &ev);
    175         input_event_key(ev.type, ev.key, ev.mods, ev.c);
    176 }
    177 
    178 /** Key has been pressed or released. */
    179 static 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);
     174        async_obsolete_msg_4(client_phone, INPUT_EVENT_KEY, ev.type, ev.key,
     175            ev.mods, ev.c);
    184176}
    185177
    186178/** Mouse pointer has moved. */
    187 void input_event_move(int dx, int dy)
     179void mouse_push_event_move(mouse_dev_t *mdev, int dx, int dy)
    188180{
    189181        async_obsolete_msg_2(client_phone, INPUT_EVENT_MOVE, dx, dy);
    … …  
    191183
    192184/** Mouse button has been pressed. */
    193 void input_event_button(int bnum, int press)
     185void mouse_push_event_button(mouse_dev_t *mdev, int bnum, int press)
    194186{
    195187        async_obsolete_msg_2(client_phone, INPUT_EVENT_BUTTON, bnum, press);
    … …  
    201193        ipc_call_t call;
    202194        int retval;
    203 
     195       
    204196        async_answer_0(iid, EOK);
    205 
     197       
    206198        while (true) {
    207199                callid = async_get_call(&call);
    … …  
    237229                        retval = EINVAL;
    238230                }
     231               
    239232                async_answer_0(callid, retval);
    240         }       
     233        }
    241234}
    242235
    243236static kbd_dev_t *kbd_dev_new(void)
    244237{
    245         kbd_dev_t *kdev;
    246 
    247         kdev = calloc(1, sizeof(kbd_dev_t));
     238        kbd_dev_t *kdev = calloc(1, sizeof(kbd_dev_t));
    248239        if (kdev == NULL) {
    249                 printf(NAME ": Error allocating keyboard device. "
    250                     "Out of memory.\n");
     240                printf("%s: Error allocating keyboard device. "
     241                    "Out of memory.\n", NAME);
    251242                return NULL;
    252243        }
    253 
     244       
    254245        link_initialize(&kdev->kbd_devs);
    255 
     246       
    256247        kdev->mods = KM_NUM_LOCK;
    257248        kdev->lock_keys = 0;
    258249        kdev->active_layout = layout_create(layout[0]);
    259 
     250       
    260251        return kdev;
     252}
     253
     254static 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;
    261266}
    262267
    … …  
    264269static void kbd_add_dev(kbd_port_ops_t *port, kbd_ctl_ops_t *ctl)
    265270{
    266         kbd_dev_t *kdev;
    267 
    268         kdev = kbd_dev_new();
     271        kbd_dev_t *kdev = kbd_dev_new();
    269272        if (kdev == NULL)
    270273                return;
    271 
     274       
    272275        kdev->port_ops = port;
    273276        kdev->ctl_ops = ctl;
    274277        kdev->dev_path = NULL;
    275 
     278       
    276279        /* Initialize port driver. */
    277280        if ((*kdev->port_ops->init)(kdev) != 0)
    278281                goto fail;
    279 
     282       
    280283        /* Initialize controller driver. */
    281284        if ((*kdev->ctl_ops->init)(kdev) != 0) {
    … …  
    283286                goto fail;
    284287        }
    285 
     288       
    286289        list_append(&kdev->kbd_devs, &kbd_devs);
    287290        return;
     291       
    288292fail:
    289293        free(kdev);
    290294}
    291295
     296/** Add new legacy mouse device. */
     297static 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       
     320fail:
     321        free(mdev);
     322}
     323
    292324/** Add new kbdev device.
    293325 *
    294  * @param dev_path      Filesystem path to the device (/dev/class/...)
     326 * @param dev_path Filesystem path to the device (/dev/class/...)
     327 *
    295328 */
    296329static int kbd_add_kbdev(const char *dev_path)
    297330{
    298         kbd_dev_t *kdev;
    299 
    300         kdev = kbd_dev_new();
     331        kbd_dev_t *kdev = kbd_dev_new();
    301332        if (kdev == NULL)
    302333                return -1;
    303 
     334       
    304335        kdev->dev_path = dev_path;
    305336        kdev->port_ops = NULL;
    306337        kdev->ctl_ops = &kbdev_ctl;
    307 
     338       
    308339        /* Initialize controller driver. */
    309340        if ((*kdev->ctl_ops->init)(kdev) != 0) {
    310341                goto fail;
    311342        }
    312 
     343       
    313344        list_append(&kdev->kbd_devs, &kbd_devs);
    314345        return EOK;
     346       
    315347fail:
    316348        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 */
     357static 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       
     375fail:
     376        free(mdev);
    317377        return -1;
    318378}
    … …  
    375435}
    376436
     437/** Add legacy drivers/devices. */
     438static void mouse_add_legacy_devs(void)
     439{
     440        /*
     441         * Need to add these drivers based on config unless we can probe
     442         * them automatically.
     443         */
     444#if defined(UARCH_amd64)
     445        mouse_add_dev(&chardev_mouse_port, &ps2_proto);
     446#endif
     447#if defined(UARCH_ia32)
     448        mouse_add_dev(&chardev_mouse_port, &ps2_proto);
     449#endif
     450#if defined(MACHINE_i460GX)
     451        mouse_add_dev(&chardev_mouse_port, &ps2_proto);
     452#endif
     453#if defined(UARCH_ppc32)
     454        mouse_add_dev(&adb_mouse_port, &adb_proto);
     455#endif
     456        /* Silence warning on abs32le about mouse_add_dev() being unused */
     457        (void) mouse_add_dev;
     458}
     459
    377460static void kbd_devs_yield(void)
    378461{
    … …  
    381464                kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t,
    382465                    kbd_devs);
    383 
     466               
    384467                /* Yield port */
    385468                if (kdev->port_ops != NULL)
    … …  
    394477                kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t,
    395478                    kbd_devs);
    396 
     479               
    397480                /* Reclaim port */
    398481                if (kdev->port_ops != NULL)
    … …  
    405488 * Looks under /dev/class/keyboard and /dev/class/mouse.
    406489 *
    407  * @param arg   Ignored
     490 * @param arg Ignored
     491 *
    408492 */
    409493static int dev_discovery_fibril(void *arg)
    … …  
    413497        size_t mouse_id = 1;
    414498        int rc;
    415 
     499       
    416500        while (true) {
    417501                async_usleep(DISCOVERY_POLL_INTERVAL);
    418 
     502               
    419503                /*
    420504                 * Check for new keyboard device
    … …  
    423507                if (rc < 0)
    424508                        continue;
    425 
     509               
    426510                if (kbd_add_kbdev(dev_path) == EOK) {
    427                         printf(NAME ": Connected keyboard device '%s'\n",
    428                             dev_path);
    429 
     511                        printf("%s: Connected keyboard device '%s'\n",
     512                            NAME, dev_path);
     513                       
    430514                        /* XXX Handle device removal */
    431515                        ++kbd_id;
    432516                }
    433 
     517               
    434518                free(dev_path);
    435 
     519               
    436520                /*
    437521                 * Check for new mouse device
    … …  
    440524                if (rc < 0)
    441525                        continue;
    442 
    443                 if (mouse_add_dev(dev_path) == EOK) {
    444                         printf(NAME ": Connected mouse device '%s'\n",
    445                             dev_path);
    446 
     526               
     527                if (mouse_add_mousedev(dev_path) == EOK) {
     528                        printf("%s: Connected mouse device '%s'\n",
     529                            NAME, dev_path);
     530                       
    447531                        /* XXX Handle device removal */
    448532                        ++mouse_id;
    449533                }
    450 
     534               
    451535                free(dev_path);
    452536        }
    453 
     537       
    454538        return EOK;
    455539}
    … …  
    458542static void input_start_dev_discovery(void)
    459543{
    460         fid_t fid;
    461 
    462         fid = fibril_create(dev_discovery_fibril, NULL);
     544        fid_t fid = fibril_create(dev_discovery_fibril, NULL);
    463545        if (!fid) {
    464                 printf(NAME ": Failed to create device discovery fibril.\n");
     546                printf("%s: Failed to create device discovery fibril.\n",
     547                    NAME);
    465548                return;
    466549        }
    467 
     550       
    468551        fibril_add_ready(fid);
    469552}
    … …  
    490573        /* Add legacy keyboard devices. */
    491574        kbd_add_legacy_devs();
    492 
    493         /* Add legacy (devmap-style) mouse device. */
    494         (void) mouse_add_dev("/dev/hid_in/mouse");
     575       
     576        /* Add legacy mouse devices. */
     577        mouse_add_legacy_devs();
    495578       
    496579        /* Register driver */
    … …  
    509592                return -1;
    510593        }
    511 
     594       
    512595        /* Start looking for new input devices */
    513596        input_start_dev_discovery();
    514 
    515         printf(NAME ": Accepting connections\n");
     597       
     598        printf("%s: Accepting connections\n", NAME);
    516599        async_manager();
    517 
     600       
    518601        /* Not reached. */
    519602        return 0;

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

    r40f606b r3b2e387  
    4848        layout = calloc(1, sizeof(layout_t));
    4949        if (layout == NULL) {
    50                 printf(NAME ": Out of memory.\n");
     50                printf("%s: Out of memory.\n", NAME);
    5151                return NULL;
    5252        }

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

    r40f606b r3b2e387  
    6060        while (mods_keys[i][0] != 0) {
    6161                if (mod & mods_keys[i][0]) {
    62                         kbd_push_ev(kdev, KEY_PRESS, mods_keys[i][1]);
     62                        kbd_push_event(kdev, KEY_PRESS, mods_keys[i][1]);
    6363                }
    6464                ++i;
    … …  
    6767        /* Simulate key press and release. */
    6868        if (key != 0) {
    69                 kbd_push_ev(kdev, KEY_PRESS, key);
    70                 kbd_push_ev(kdev, KEY_RELEASE, key);
     69                kbd_push_event(kdev, KEY_PRESS, key);
     70                kbd_push_event(kdev, KEY_RELEASE, key);
    7171        }
    7272
    … …  
    7575        while (mods_keys[i][0] != 0) {
    7676                if (mod & mods_keys[i][0]) {
    77                         kbd_push_ev(kdev, KEY_RELEASE, mods_keys[i][1]);
     77                        kbd_push_event(kdev, KEY_RELEASE, mods_keys[i][1]);
    7878                }
    7979                ++i;

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

    r40f606b r3b2e387  
    4242
    4343#define NAME       "input"
    44 #define NAMESPACE  "hid_in"
     44#define NAMESPACE  "hid"
    4545
    4646extern bool irc_service;
    4747extern int irc_phone;
    48 
    49 extern list_t mouse_devs;
    50 
    51 void input_event_move(int, int);
    52 void input_event_button(int bnum, int press);
    5348
    5449#endif

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

    r40f606b r3b2e387  
    7171} kbd_dev_t;
    7272
    73 extern void kbd_push_scancode(kbd_dev_t *, int);
    74 extern void kbd_push_ev(kbd_dev_t *, int, unsigned int);
     73extern void kbd_push_data(kbd_dev_t *, sysarg_t);
     74extern void kbd_push_event(kbd_dev_t *, int, unsigned int);
    7575
    7676#endif

  • uspace/srv/hid/input/include/kbd_ctl.h

    r40f606b r3b2e387  
    2828
    2929/** @addtogroup inputgen generic
    30  * @brief       Keyboard controller driver interface.
    31  * @ingroup  input
     30 * @brief Keyboard controller driver interface.
     31 * @ingroup input
    3232 * @{
    3333 */
    … …  
    4343
    4444typedef struct kbd_ctl_ops {
    45         void (*parse_scancode)(int);
     45        void (*parse)(sysarg_t);
    4646        int (*init)(struct kbd_dev *);
    47         void (*set_ind)(struct kbd_dev *, unsigned);
     47        void (*set_ind)(struct kbd_dev *, unsigned int);
    4848} kbd_ctl_ops_t;
    4949
    … …  
    5959/**
    6060 * @}
    61  */
    62 
     61 */

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

    r40f606b r3b2e387  
    2828
    2929/** @addtogroup inputgen generic
    30  * @brief       Keyboard port driver interface.
    31  * @ingroup  input
     30 * @brief Keyboard port driver interface.
     31 * @ingroup input
    3232 * @{
    3333 */
    … …  
    5151extern kbd_port_ops_t adb_port;
    5252extern kbd_port_ops_t chardev_port;
    53 extern kbd_port_ops_t dummy_port;
    5453extern kbd_port_ops_t gxemul_port;
    5554extern kbd_port_ops_t msim_port;
    … …  
    6564/**
    6665 * @}
    67  */
    68 
     66 */

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

    r40f606b r3b2e387  
    4040#include <adt/list.h>
    4141
     42struct mouse_port_ops;
     43struct mouse_proto_ops;
     44
    4245typedef struct mouse_dev {
    4346        /** Link to mouse_devs list */
    4447        link_t mouse_devs;
    45 
    46         /** Path to the device */
     48       
     49        /** Path to the device (only for mouseev devices) */
    4750        const char *dev_path;
     51       
     52        /** Port ops */
     53        struct mouse_port_ops *port_ops;
     54       
     55        /** Protocol ops */
     56        struct mouse_proto_ops *proto_ops;
    4857} mouse_dev_t;
    4958
    50 int mouse_add_dev(const char *dev_path);
     59extern void mouse_push_data(mouse_dev_t *, sysarg_t);
     60extern void mouse_push_event_move(mouse_dev_t *, int, int);
     61extern void mouse_push_event_button(mouse_dev_t *, int, int);
    5162
    5263#endif

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

    r40f606b r3b2e387  
    391391        cz_state = malloc(sizeof(layout_cz_t));
    392392        if (cz_state == NULL) {
    393                 printf(NAME ": Out of memory.\n");
     393                printf("%s: Out of memory.\n", NAME);
    394394                return ENOMEM;
    395395        }

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

    r40f606b r3b2e387  
    9393        async_exchange_end(exch);
    9494        if (rc != EOK) {
    95                 printf(NAME ": Failed to create callback from device\n");
     95                printf("%s: Failed to create callback from device\n", NAME);
    9696                async_hangup(dev_sess);
    9797                return rc;
    … …  
    142142static void adb_kbd_reg0_data(uint16_t data)
    143143{
    144         uint8_t b0, b1;
    145 
    146         b0 = (data >> 8) & 0xff;
    147         b1 = data & 0xff;
    148 
     144        uint8_t b0 = (data >> 8) & 0xff;
     145        uint8_t b1 = data & 0xff;
     146       
    149147        if (b0 != 0xff)
    150                 kbd_push_scancode(kbd_dev, b0);
     148                kbd_push_data(kbd_dev, b0);
     149       
    151150        if (b1 != 0xff)
    152                 kbd_push_scancode(kbd_dev, b1);
     151                kbd_push_data(kbd_dev, b1);
    153152}
    154153

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

    r40f606b r3b2e387  
    108108       
    109109        if (rc != 0) {
    110                 printf(NAME ": Failed to create callback from device\n");
     110                printf("%s: Failed to create callback from device\n", NAME);
    111111                async_hangup(dev_sess);
    112112                return -1;
    … …  
    153153                switch (IPC_GET_IMETHOD(call)) {
    154154                case CHAR_NOTIF_BYTE:
    155                         kbd_push_scancode(kbd_dev, IPC_GET_ARG1(call));
     155                        kbd_push_data(kbd_dev, IPC_GET_ARG1(call));
    156156                        break;
    157157                default:

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

    r40f606b r3b2e387  
    108108
    109109/** Process data sent when a key is pressed.
    110  * 
    111  *  @param keybuffer Buffer of pressed keys.
    112  *  @param call      IPC call.
    113110 *
    114  *  @return Always 1.
     111 * @param keybuffer Buffer of pressed keys.
     112 * @param call      IPC call.
     113 *
    115114 */
    116115static void gxemul_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    117116{
    118         int scan_code = IPC_GET_ARG2(*call);
    119 
    120         kbd_push_scancode(kbd_dev, scan_code);
     117        kbd_push_data(kbd_dev, IPC_GET_ARG2(*call));
    121118}
    122119

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

    r40f606b r3b2e387  
    109109static void msim_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    110110{
    111         int scan_code = IPC_GET_ARG2(*call);
    112         kbd_push_scancode(kbd_dev, scan_code);
     111        kbd_push_data(kbd_dev, IPC_GET_ARG2(*call));
    113112}
    114113
    115114/** @}
    116 */
     115 */

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

    r40f606b r3b2e387  
    148148                c = input_buffer->data[input_buffer->read_ptr];
    149149                input_buffer->read_ptr =
    150                         ((input_buffer->read_ptr) + 1) % INPUT_BUFFER_SIZE;
    151                 kbd_push_scancode(kbd_dev, c);
     150                    ((input_buffer->read_ptr) + 1) % INPUT_BUFFER_SIZE;
     151                kbd_push_data(kbd_dev, c);
    152152        }
    153153}

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

    r40f606b r3b2e387  
    156156static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    157157{
    158         int scan_code = IPC_GET_ARG2(*call);
    159         kbd_push_scancode(kbd_dev, scan_code);
     158        kbd_push_data(kbd_dev, IPC_GET_ARG2(*call));
    160159       
    161160        if (irc_service)

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

    r40f606b r3b2e387  
    137137static void pl050_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    138138{
    139         int scan_code = IPC_GET_ARG2(*call);
    140 
    141         kbd_push_scancode(kbd_dev, scan_code);
    142         return;
     139        kbd_push_data(kbd_dev, IPC_GET_ARG2(*call));
    143140}
    144141
    145142/**
    146143 * @}
    147  */ 
     144 */

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

    r40f606b r3b2e387  
    183183                *in_rdptr_ptr = (((*in_rdptr_ptr) - begin + 1) % size) + begin;
    184184                buf_ptr = (volatile char *)
    185                         SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
    186                 kbd_push_scancode(kbd_dev, c);
     185                    SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
     186                kbd_push_data(kbd_dev, c);
    187187        }
    188188}

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

    r40f606b r3b2e387  
    110110                        if (c == 0)
    111111                                break;
    112                         kbd_push_scancode(kbd_dev, c);
     112                        kbd_push_data(kbd_dev, c);
    113113                }
    114114

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

    r40f606b r3b2e387  
    142142static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    143143{
    144         int scan_code = IPC_GET_ARG2(*call);
    145         kbd_push_scancode(kbd_dev, scan_code);
     144        kbd_push_data(kbd_dev, IPC_GET_ARG2(*call));
    146145       
    147146        if (irc_service)

  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c

    r40f606b r3b2e387  
    4242#include <io/console.h>
    4343#include <vfs/vfs.h>
    44 #include <ipc/mouse.h>
     44#include <ipc/mouseev.h>
    4545#include <async.h>
    4646#include <async_obsolete.h>
    … …  
    5757
    5858#define NAME "s3c24ser"
    59 #define NAMESPACE "hid_in"
     59#define NAMESPACE "hid"
    6060
    6161static irq_cmd_t ts_irq_cmds[] = {
    … …  
    284284        button = 1;
    285285        press = 0;
    286         async_obsolete_msg_2(ts->client_phone, MEVENT_BUTTON, button, press);
     286        async_obsolete_msg_2(ts->client_phone, MOUSEEV_BUTTON_EVENT, button, press);
    287287
    288288        s3c24xx_ts_wait_for_int_mode(ts, updn_down);
    … …  
    325325
    326326        /* Send notifications to client. */
    327         async_obsolete_msg_2(ts->client_phone, MEVENT_MOVE, dx, dy);
    328         async_obsolete_msg_2(ts->client_phone, MEVENT_BUTTON, button, press);
     327        async_obsolete_msg_2(ts->client_phone, MOUSEEV_MOVE_EVENT, dx, dy);
     328        async_obsolete_msg_2(ts->client_phone, MOUSEEV_BUTTON_EVENT, button, press);
    329329
    330330        ts->last_x = x_pos;
Note: See TracChangeset for help on using the changeset viewer.