Changeset 1875a0c in mainline


Ignore:
Timestamp:
2011-06-21T19:10:20Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
022d9f67
Parents:
a9d85df
Message:

input server improvements

  • integrate legacy port mouse drivers (PS/2, ADB) into the input server (to be on par with the legacy keyboard drivers)
  • create generic port/protocol layers for the mouse in the input server
  • rename the "hid_in" namespace to "hid" namespace (hid_in/input was rather redundant)
  • rename the mouse event IPC messages to be more consistent with the keyboard event messages
  • rename input server ops structure members to be more generic (parse_scancode → parse)
  • cstyle changes (newlines, comments, printouts)
Files:
6 deleted
34 edited
8 moved

Legend:

Unmodified
Added
Removed

  • boot/arch/amd64/Makefile.inc

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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/drv/bus/usb/usbhid/mouse/mousedev.c

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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/include/ipc/mouseev.h

    ra9d85df r1875a0c  
    3434 */
    3535
    36 #ifndef LIBC_IPC_MOUSE_H_
    37 #define LIBC_IPC_MOUSE_H_
     36#ifndef LIBC_IPC_MOUSEEV_H_
     37#define LIBC_IPC_MOUSEEV_H_
    3838
    3939#include <ipc/common.h>
     40#include <ipc/dev_iface.h>
    4041
    4142typedef enum {
    42         MEVENT_BUTTON = IPC_FIRST_USER_METHOD,
    43         MEVENT_MOVE
    44 } mouse_notif_t;
     43        MOUSEEV_YIELD = DEV_FIRST_CUSTOM_METHOD,
     44        MOUSEEV_RECLAIM
     45} mouseev_request_t;
     46
     47typedef enum {
     48        MOUSEEV_MOVE_EVENT = IPC_FIRST_USER_METHOD,
     49        MOUSEEV_BUTTON_EVENT
     50} mouseev_notif_t;
    4551
    4652#endif

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

    ra9d85df r1875a0c  
    482482                        retval = ENOENT;
    483483                }
     484
    484485                async_answer_0(callid, retval);
    485486        }

  • uspace/srv/hid/input/Makefile

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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/include/mouse_port.h

    ra9d85df r1875a0c  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
    30  * @brief
     29/** @addtogroup inputgen generic
     30 * @brief Mouse port driver interface.
     31 * @ingroup input
    3132 * @{
    3233 */
    … …  
    3940#include <sys/types.h>
    4041
    41 extern int mouse_port_init(void);
    42 extern void mouse_port_yield(void);
    43 extern void mouse_port_reclaim(void);
    44 extern void mouse_port_write(uint8_t);
     42struct mouse_dev;
     43
     44typedef struct mouse_port_ops {
     45        int (*init)(struct mouse_dev *);
     46        void (*yield)(void);
     47        void (*reclaim)(void);
     48        void (*write)(uint8_t);
     49} mouse_port_ops_t;
     50
     51extern mouse_port_ops_t adb_mouse_port;
     52extern mouse_port_ops_t chardev_mouse_port;
    4553
    4654#endif
    … …  
    4856/**
    4957 * @}
    50  */
    51 
     58 */

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

    ra9d85df r1875a0c  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
    30  * @brief
     29/** @addtogroup inputgen generic
     30 * @brief Mouse protocol driver interface.
     31 * @ingroup input
    3132 * @{
    3233 */
    … …  
    3738#define MOUSE_PROTO_H_
    3839
    39 extern void mouse_proto_parse_byte(int);
    40 extern int mouse_proto_init(void);
     40#include <mouse_port.h>
     41
     42struct mouse_dev;
     43
     44typedef struct mouse_proto_ops {
     45        void (*parse)(sysarg_t);
     46        int (*init)(struct mouse_dev *);
     47} mouse_proto_ops_t;
     48
     49extern mouse_proto_ops_t adb_proto;
     50extern mouse_proto_ops_t ps2_proto;
     51extern mouse_proto_ops_t mousedev_proto;
    4152
    4253#endif

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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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/adb_mouse.c

    ra9d85df r1875a0c  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
     29/** @addtogroup mouse_port
     30 * @ingroup mouse
    3031 * @{
    31  */ 
     32 */
    3233/** @file
    33  * @brief
     34 * @brief ADB mouse port driver.
    3435 */
    3536
    36 #include <ipc/char.h>
     37#include <ipc/adb.h>
    3738#include <async.h>
    38 #include <vfs/vfs.h>
    39 #include <fcntl.h>
     39#include <input.h>
     40#include <mouse_port.h>
     41#include <mouse.h>
    4042#include <errno.h>
    4143#include <devmap.h>
    42 #include <char_mouse.h>
    43 #include <mouse_port.h>
    4444
    45 static void chardev_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    46 
     45static mouse_dev_t *mouse_dev;
    4746static async_sess_t *dev_sess;
    4847
    49 #define NAME "char_mouse"
    50 
    51 int mouse_port_init(void)
    52 {
    53         devmap_handle_t handle;
    54         async_exch_t *exch;
    55         int rc;
    56        
    57         rc = devmap_device_get_handle("char/ps2b", &handle,
    58             IPC_FLAG_BLOCKING);
    59        
    60         if (rc != EOK) {
    61                 printf("%s: Failed resolving PS/2\n", NAME);
    62                 return rc;
    63         }
    64        
    65         dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle,
    66             IPC_FLAG_BLOCKING);
    67         if (dev_sess == NULL) {
    68                 printf("%s: Failed connecting to PS/2\n", NAME);
    69                 return ENOENT;
    70         }
    71        
    72         exch = async_exchange_begin(dev_sess);
    73         if (exch == NULL) {
    74                 printf("%s: Failed starting exchange with PS/2\n", NAME);
    75                 async_hangup(dev_sess);
    76                 return ENOMEM;
    77         }
    78        
    79         /* NB: The callback connection is slotted for removal */
    80         rc = async_connect_to_me(exch, 0, 0, 0, chardev_events, NULL);
    81         async_exchange_end(exch);
    82        
    83         if (rc != 0) {
    84                 printf(NAME ": Failed to create callback from device\n");
    85                 async_hangup(dev_sess);
    86                 return false;
    87         }
    88        
    89         return 0;
    90 }
    91 
    92 void mouse_port_yield(void)
    93 {
    94 }
    95 
    96 void mouse_port_reclaim(void)
    97 {
    98 }
    99 
    100 void mouse_port_write(uint8_t data)
    101 {
    102         async_exch_t *exch = async_exchange_begin(dev_sess);
    103         if (exch == NULL) {
    104                 printf("%s: Failed starting exchange with PS/2\n", NAME);
    105                 return;
    106         }
    107        
    108         async_msg_1(exch, CHAR_WRITE_BYTE, data);
    109        
    110         async_exchange_end(exch);
    111 }
    112 
    113 static void chardev_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     48static void mouse_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    11449{
    11550        /* Ignore parameters, the connection is already opened */
    11651        while (true) {
    117 
    11852                ipc_call_t call;
    11953                ipc_callid_t callid = async_get_call(&call);
    120 
     54               
    12155                int retval;
    12256               
    … …  
    12559                        return;
    12660                }
    127 
     61               
    12862                switch (IPC_GET_IMETHOD(call)) {
    129                 case IPC_FIRST_USER_METHOD:
    130                         mouse_handle_byte(IPC_GET_ARG1(call));
     63                case ADB_REG_NOTIF:
     64                        mouse_push_data(mouse_dev, IPC_GET_ARG1(call));
    13165                        break;
    13266                default:
    13367                        retval = ENOENT;
    13468                }
     69               
    13570                async_answer_0(callid, retval);
    13671        }
    13772}
    13873
     74static int adb_port_init(mouse_dev_t *mdev)
     75{
     76        const char *dev = "adb/mouse";
     77       
     78        mouse_dev = mdev;
     79       
     80        devmap_handle_t handle;
     81        int rc = devmap_device_get_handle(dev, &handle, 0);
     82        if (rc != EOK)
     83                return rc;
     84       
     85        dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle, 0);
     86        if (dev_sess == NULL) {
     87                printf("%s: Failed to connect to device\n", NAME);
     88                return ENOENT;
     89        }
     90       
     91        async_exch_t *exch = async_exchange_begin(dev_sess);
     92        if (exch == NULL) {
     93                printf("%s: Failed starting exchange with device\n", NAME);
     94                async_hangup(dev_sess);
     95                return ENOMEM;
     96        }
     97       
     98        /* NB: The callback connection is slotted for removal */
     99        rc = async_connect_to_me(exch, 0, 0, 0, mouse_port_events, NULL);
     100        async_exchange_end(exch);
     101        if (rc != EOK) {
     102                printf("%s: Failed to create callback from device\n", NAME);
     103                async_hangup(dev_sess);
     104                return rc;
     105        }
     106       
     107        return EOK;
     108}
     109
     110static void adb_port_yield(void)
     111{
     112}
     113
     114static void adb_port_reclaim(void)
     115{
     116}
     117
     118static void adb_port_write(uint8_t data)
     119{
     120}
     121
     122mouse_port_ops_t adb_mouse_port = {
     123        .init = adb_port_init,
     124        .yield = adb_port_yield,
     125        .reclaim = adb_port_reclaim,
     126        .write = adb_port_write
     127};
     128
    139129/**
    140130 * @}

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

    ra9d85df r1875a0c  
    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/chardev_mouse.c

    ra9d85df r1875a0c  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
     29/** @addtogroup mouse_port
     30 * @ingroup mouse
    3031 * @{
    31  */ 
     32 */
    3233/** @file
    33  * @brief
     34 * @brief Chardev mouse port driver.
    3435 */
    3536
    36 #include <ipc/adb.h>
     37#include <ipc/char.h>
     38#include <stdio.h>
    3739#include <async.h>
    38 #include <vfs/vfs.h>
    39 #include <fcntl.h>
    4040#include <errno.h>
    4141#include <devmap.h>
    42 #include <async.h>
    43 #include <kernel/ipc/ipc_methods.h>
     42#include <input.h>
     43#include <mouse_port.h>
     44#include <mouse.h>
    4445
    45 #include "adb_mouse.h"
    46 #include "adb_dev.h"
     46static mouse_dev_t *mouse_dev;
     47static async_sess_t *dev_sess;
    4748
    48 static void adb_dev_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
     49/** List of devices to try connecting to. */
     50static const char *in_devs[] = {
     51        "char/ps2b",
     52};
    4953
    50 int adb_dev_init(void)
     54static const unsigned int num_devs = sizeof(in_devs) / sizeof(in_devs[0]);
     55
     56static void mouse_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     57{
     58        /* Ignore parameters, the connection is already opened */
     59        while (true) {
     60                ipc_call_t call;
     61                ipc_callid_t callid = async_get_call(&call);
     62               
     63                if (!IPC_GET_IMETHOD(call)) {
     64                        /* TODO: Handle hangup */
     65                        return;
     66                }
     67               
     68                int retval;
     69               
     70                switch (IPC_GET_IMETHOD(call)) {
     71                case CHAR_NOTIF_BYTE:
     72                        mouse_push_data(mouse_dev, IPC_GET_ARG1(call));
     73                        break;
     74                default:
     75                        retval = ENOENT;
     76                }
     77               
     78                async_answer_0(callid, retval);
     79        }
     80}
     81
     82static int chardev_port_init(mouse_dev_t *mdev)
    5183{
    5284        devmap_handle_t handle;
    53         async_exch_t *exch;
     85        unsigned int i;
    5486        int rc;
    5587       
    56         rc = devmap_device_get_handle("adb/mouse", &handle,
    57             IPC_FLAG_BLOCKING);
    58         if (rc != EOK) {
    59                 printf("%s: Failed resolving ADB\n", NAME);
    60                 return rc;
     88        mouse_dev = mdev;
     89       
     90        for (i = 0; i < num_devs; i++) {
     91                rc = devmap_device_get_handle(in_devs[i], &handle, 0);
     92                if (rc == EOK)
     93                        break;
    6194        }
    6295       
    63         async_sess_t *dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle,
     96        if (i >= num_devs) {
     97                printf("%s: Could not find any suitable input device\n", NAME);
     98                return -1;
     99        }
     100       
     101        dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle,
    64102            IPC_FLAG_BLOCKING);
    65103        if (dev_sess == NULL) {
    66                 printf("%s: Failed connecting to ADB\n", NAME);
     104                printf("%s: Failed connecting to device\n", NAME);
    67105                return ENOENT;
    68106        }
    69107       
    70         exch = async_exchange_begin(dev_sess);
     108        async_exch_t *exch = async_exchange_begin(dev_sess);
    71109        if (exch == NULL) {
    72                 printf("%s: Failed starting exchange with ADB\n", NAME);
     110                printf("%s: Failed starting exchange with device\n", NAME);
    73111                async_hangup(dev_sess);
    74112                return ENOMEM;
    … …  
    76114       
    77115        /* NB: The callback connection is slotted for removal */
    78         rc = async_connect_to_me(exch, 0, 0, 0, adb_dev_events, NULL);
     116        rc = async_connect_to_me(exch, 0, 0, 0, mouse_port_events, NULL);
    79117        async_exchange_end(exch);
    80118       
    81119        if (rc != 0) {
    82                 printf(NAME ": Failed to create callback from device\n");
     120                printf("%s: Failed to create callback from device\n", NAME);
    83121                async_hangup(dev_sess);
    84                 return ENOENT;
     122                return -1;
    85123        }
    86124       
    … …  
    88126}
    89127
    90 static void adb_dev_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     128static void chardev_port_yield(void)
    91129{
    92         /* Ignore parameters, the connection is already opened */
    93         while (true) {
     130}
    94131
    95                 ipc_call_t call;
    96                 ipc_callid_t callid = async_get_call(&call);
     132static void chardev_port_reclaim(void)
     133{
     134}
    97135
    98                 int retval;
    99                
    100                 if (!IPC_GET_IMETHOD(call)) {
    101                         /* TODO: Handle hangup */
    102                         return;
    103                 }
     136static void chardev_port_write(uint8_t data)
     137{
     138        async_exch_t *exch = async_exchange_begin(dev_sess);
     139        if (exch == NULL) {
     140                printf("%s: Failed starting exchange with device\n", NAME);
     141                return;
     142        }
    104143
    105                 switch (IPC_GET_IMETHOD(call)) {
    106                 case IPC_FIRST_USER_METHOD:
    107                         mouse_handle_data(IPC_GET_ARG1(call));
    108                         break;
    109                 default:
    110                         retval = ENOENT;
    111                 }
    112                 async_answer_0(callid, retval);
    113         }
     144        async_msg_1(exch, CHAR_WRITE_BYTE, data);
     145        async_exchange_end(exch);
    114146}
     147
     148mouse_port_ops_t chardev_mouse_port = {
     149        .init = chardev_port_init,
     150        .yield = chardev_port_yield,
     151        .reclaim = chardev_port_reclaim,
     152        .write = chardev_port_write
     153};
    115154
    116155/**

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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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

    ra9d85df r1875a0c  
    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/input/proto/adb.c

    ra9d85df r1875a0c  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
    30  * @brief
     29/** @addtogroup mouse_proto
     30 * @ingroup input
    3131 * @{
    3232 */
    33 /** @file
     33/**
     34 * @file
     35 * @brief ADB protocol driver.
    3436 */
    3537
    36 #ifndef ADB_MOUSE_H_
    37 #define ADB_MOUSE_H_
     38#include <bool.h>
     39#include <mouse.h>
     40#include <mouse_port.h>
     41#include <mouse_proto.h>
    3842
    39 #include <sys/types.h>
     43static mouse_dev_t *mouse_dev;
     44static bool b1_pressed;
     45static bool b2_pressed;
    4046
    41 #define NAME       "adb_ms"
    42 #define NAMESPACE  "hid_in"
     47static int adb_proto_init(mouse_dev_t *mdev)
     48{
     49        mouse_dev = mdev;
     50        b1_pressed = false;
     51        b2_pressed = false;
     52       
     53        return 0;
     54}
    4355
    44 extern void mouse_handle_data(uint16_t);
     56/** Process mouse data */
     57static void adb_proto_parse(sysarg_t data)
     58{
     59        bool b1, b2;
     60        uint16_t udx, udy;
     61        int dx, dy;
     62       
     63        /* Extract fields. */
     64        b1 = ((data >> 15) & 1) == 0;
     65        udy = (data >> 8) & 0x7f;
     66        b2 = ((data >> 7) & 1) == 0;
     67        udx = data & 0x7f;
     68       
     69        /* Decode 7-bit two's complement signed values. */
     70        dx = (udx & 0x40) ? (udx - 0x80) : udx;
     71        dy = (udy & 0x40) ? (udy - 0x80) : udy;
     72       
     73        if (b1 != b1_pressed) {
     74                mouse_push_event_button(mouse_dev, 1, b1);
     75                b1_pressed = b1;
     76        }
     77       
     78        if (b2 != b2_pressed) {
     79                mouse_push_event_button(mouse_dev, 2, b2);
     80                b1_pressed = b1;
     81        }
     82       
     83        if (dx != 0 || dy != 0)
     84                mouse_push_event_move(mouse_dev, dx, dy);
     85}
    4586
    46 #endif
     87mouse_proto_ops_t adb_proto = {
     88        .parse = adb_proto_parse,
     89        .init = adb_proto_init
     90};
    4791
    4892/**

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

    ra9d85df r1875a0c  
    11/*
    2  * Copyright (c) 2011 Jiri Svoboda
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /**
    30  * @addtogroup inputgen generic
    31  * @brief Mouse device handling.
     29/** @addtogroup mouse_proto
    3230 * @ingroup input
    3331 * @{
    3432 */
    35 /** @file
     33/**
     34 * @file
     35 * @brief Mouse device connector controller driver.
    3636 */
    3737
    38 #include <adt/list.h>
     38#include <stdio.h>
     39#include <fcntl.h>
     40#include <vfs/vfs_sess.h>
     41#include <malloc.h>
    3942#include <async.h>
    4043#include <errno.h>
    41 #include <fcntl.h>
     44#include <ipc/mouseev.h>
    4245#include <input.h>
    43 #include <ipc/mouse.h>
    4446#include <mouse.h>
    45 #include <stdio.h>
    46 #include <stdlib.h>
    47 #include <vfs/vfs_sess.h>
     47#include <mouse_port.h>
     48#include <mouse_proto.h>
    4849
    49 static void mouse_callback_conn(ipc_callid_t, ipc_call_t *, void *);
     50/** Mousedev softstate */
     51typedef struct {
     52        /** Link to generic mouse device */
     53        mouse_dev_t *mouse_dev;
     54       
     55        /** Session to mouse device */
     56        async_sess_t *sess;
     57       
     58        /** File descriptor of open mousedev device */
     59        int fd;
     60} mousedev_t;
    5061
    51 static mouse_dev_t *mouse_dev_new(void)
     62static mousedev_t *mousedev_new(mouse_dev_t *mdev)
    5263{
    53         mouse_dev_t *mdev;
    54 
    55         mdev = calloc(1, sizeof(mouse_dev_t));
    56         if (mdev == NULL) {
    57                 printf(NAME ": Error allocating mouse device. "
    58                     "Out of memory.\n");
     64        mousedev_t *mousedev = calloc(1, sizeof(mousedev_t));
     65        if (mousedev == NULL)
    5966                return NULL;
    60         }
    61 
    62         link_initialize(&mdev->mouse_devs);
    63         return mdev;
     67       
     68        mousedev->mouse_dev = mdev;
     69        mousedev->fd = -1;
     70       
     71        return mousedev;
    6472}
    6573
    66 static int mouse_dev_connect(mouse_dev_t *mdev, const char *dev_path)
     74static void mousedev_destroy(mousedev_t *mousedev)
    6775{
    68         async_sess_t *sess;
    69         async_exch_t *exch;
    70         int fd;
    71         int rc;
    72 
    73         fd = open(dev_path, O_RDWR);
    74         if (fd < 0) {
    75                 return -1;
    76         }
    77 
    78         sess = fd_session(EXCHANGE_SERIALIZE, fd);
    79         if (sess == NULL) {
    80                 printf(NAME ": Failed starting session with '%s'\n", dev_path);
    81                 close(fd);
    82                 return -1;
    83         }
    84 
    85         exch = async_exchange_begin(sess);
    86         if (exch == NULL) {
    87                 printf(NAME ": Failed starting exchange with '%s'.\n", dev_path);
    88                 return -1;
    89         }
    90 
    91         rc = async_connect_to_me(exch, 0, 0, 0, mouse_callback_conn, mdev);
    92         if (rc != EOK) {
    93                 printf(NAME ": Failed creating callback connection from '%s'.\n",
    94                     dev_path);
    95                 async_exchange_end(exch);
    96                 return -1;
    97         }
    98 
    99         async_exchange_end(exch);
    100 
    101         mdev->dev_path = dev_path;
    102         return 0;
     76        if (mousedev->sess != NULL)
     77                async_hangup(mousedev->sess);
     78       
     79        if (mousedev->fd >= 0)
     80                close(mousedev->fd);
     81       
     82        free(mousedev);
    10383}
    10484
    105 /** Add new mouse device.
    106  *
    107  * @param dev_path      Filesystem path to the device (/dev/class/...)
    108  */
    109 int mouse_add_dev(const char *dev_path)
     85static void mousedev_callback_conn(ipc_callid_t iid, ipc_call_t *icall,
     86    void *arg)
    11087{
    111         mouse_dev_t *mdev;
    112         int rc;
    113 
    114         mdev = mouse_dev_new();
    115         if (mdev == NULL)
    116                 return -1;
    117 
    118         rc = mouse_dev_connect(mdev, dev_path);
    119         if (rc != EOK) {
    120                 free(mdev);
    121                 return -1;
    122         }
    123 
    124         list_append(&mdev->mouse_devs, &mouse_devs);
    125         return EOK;
    126 }
    127 
    128 /** Mouse device callback connection handler. */
    129 static void mouse_callback_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    130 {
    131         int retval;
    132 
     88        /* Mousedev device structure */
     89        mousedev_t *mousedev = (mousedev_t *) arg;
     90       
    13391        while (true) {
    13492                ipc_call_t call;
    135                 ipc_callid_t callid;
    136 
    137                 callid = async_get_call(&call);
     93                ipc_callid_t callid = async_get_call(&call);
     94               
    13895                if (!IPC_GET_IMETHOD(call)) {
    13996                        /* XXX Handle hangup */
    14097                        return;
    14198                }
    142 
     99               
     100                int retval;
     101               
    143102                switch (IPC_GET_IMETHOD(call)) {
    144                 case MEVENT_BUTTON:
    145                         input_event_button(IPC_GET_ARG1(call),
     103                case MOUSEEV_MOVE_EVENT:
     104                        mouse_push_event_move(mousedev->mouse_dev, IPC_GET_ARG1(call),
    146105                            IPC_GET_ARG2(call));
    147                         retval = 0;
     106                        retval = EOK;
    148107                        break;
    149                 case MEVENT_MOVE:
    150                         input_event_move(IPC_GET_ARG1(call),
     108                case MOUSEEV_BUTTON_EVENT:
     109                        mouse_push_event_button(mousedev->mouse_dev, IPC_GET_ARG1(call),
    151110                            IPC_GET_ARG2(call));
    152                         retval = 0;
     111                        retval = EOK;
    153112                        break;
    154113                default:
    … …  
    156115                        break;
    157116                }
    158 
     117               
    159118                async_answer_0(callid, retval);
    160119        }
    161120}
    162121
     122static int mousedev_proto_init(mouse_dev_t *mdev)
     123{
     124        const char *pathname = mdev->dev_path;
     125       
     126        int fd = open(pathname, O_RDWR);
     127        if (fd < 0)
     128                return -1;
     129       
     130        async_sess_t *sess = fd_session(EXCHANGE_SERIALIZE, fd);
     131        if (sess == NULL) {
     132                printf("%s: Failed starting session with '%s'\n", NAME, pathname);
     133                close(fd);
     134                return -1;
     135        }
     136       
     137        mousedev_t *mousedev = mousedev_new(mdev);
     138        if (mousedev == NULL) {
     139                printf("%s: Failed allocating device structure for '%s'.\n",
     140                    NAME, pathname);
     141                return -1;
     142        }
     143       
     144        mousedev->fd = fd;
     145        mousedev->sess = sess;
     146       
     147        async_exch_t *exch = async_exchange_begin(sess);
     148        if (exch == NULL) {
     149                printf("%s: Failed starting exchange with '%s'.\n", NAME, pathname);
     150                mousedev_destroy(mousedev);
     151                return -1;
     152        }
     153       
     154        int rc = async_connect_to_me(exch, 0, 0, 0, mousedev_callback_conn, mousedev);
     155        async_exchange_end(exch);
     156       
     157        if (rc != EOK) {
     158                printf("%s: Failed creating callback connection from '%s'.\n",
     159                    NAME, pathname);
     160                mousedev_destroy(mousedev);
     161                return -1;
     162        }
     163       
     164        return 0;
     165}
     166
     167mouse_proto_ops_t mousedev_proto = {
     168        .init = mousedev_proto_init
     169};
     170
    163171/**
    164172 * @}

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

    ra9d85df r1875a0c  
    11/*
    2  * Copyright (c) 2006 Ondrej Palkovsky
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
     29/** @addtogroup mouse_proto
     30 * @ingroup input
    3031 * @{
    3132 */
    3233/**
    3334 * @file
    34  * @brief PS/2 mouse protocol driver.
     35 * @brief PS/2 protocol driver.
    3536 */
    3637
    37 #include <stdio.h>
     38#include <mouse.h>
    3839#include <mouse_port.h>
    39 #include <char_mouse.h>
    4040#include <mouse_proto.h>
    41 
    42 #define BUFSIZE 3
    4341
    4442#define PS2_MOUSE_OUT_INIT  0xf4
    4543#define PS2_MOUSE_ACK       0xfa
     44
     45#define BUFSIZE 3
    4646
    4747typedef struct {
    … …  
    4949                unsigned char data[BUFSIZE];
    5050                struct {
    51                         unsigned leftbtn : 1;
    52                         unsigned rightbtn : 1;
    53                         unsigned middlebtn : 1;
    54                         unsigned isone : 1; /* Always one */
    55                         unsigned xsign : 1;
    56                         unsigned ysign : 1;
    57                         unsigned xovfl : 1;
    58                         unsigned yovfl : 1;
     51                        unsigned int leftbtn : 1;
     52                        unsigned int rightbtn : 1;
     53                        unsigned int middlebtn : 1;
     54                        unsigned int isone : 1; /* Always one */
     55                        unsigned int xsign : 1;
     56                        unsigned int ysign : 1;
     57                        unsigned int xovfl : 1;
     58                        unsigned int yovfl : 1;
    5959                        unsigned char x;
    6060                        unsigned char y;
    … …  
    6464
    6565static ps2packet_t buf;
    66 static int bufpos = 0;
    67 static int leftbtn = 0;
    68 static int rightbtn = 0;
    69 static int middlebtn = 0;
     66static unsigned int bufpos;
     67static unsigned int leftbtn;
     68static unsigned int rightbtn;
     69static unsigned int middlebtn;
    7070
    71 int mouse_proto_init(void)
     71static mouse_dev_t *mouse_dev;
     72
     73static int ps2_proto_init(mouse_dev_t *mdev)
    7274{
    73         mouse_port_write(PS2_MOUSE_OUT_INIT);
     75        mouse_dev = mdev;
     76        bufpos = 0;
     77        leftbtn = 0;
     78        rightbtn = 0;
     79       
     80        mouse_dev->port_ops->write(PS2_MOUSE_OUT_INIT);
    7481        return 0;
    7582}
    … …  
    7986{
    8087        int tmp;
    81 
     88       
    8289        if (!sign)
    8390                return data;
    84 
    85         tmp = ((unsigned char)~data) + 1;
     91       
     92        tmp = ((unsigned char) ~data) + 1;
    8693        return -tmp;
    8794}
    8895
    8996/** Process mouse data */
    90 void mouse_proto_parse_byte(int data)
     97static void ps2_proto_parse(sysarg_t data)
    9198{
    9299        int x, y;
    93 
     100       
    94101        /* Check that we have not lost synchronization */
    95102        if (bufpos == 0 && !(data & 0x8))
    96103                return; /* Synchro lost, ignore byte */
    97 
     104       
    98105        buf.u.data[bufpos++] = data;
    99106        if (bufpos == BUFSIZE) {
    100107                bufpos = 0;
    101 
     108               
    102109                if (buf.u.val.leftbtn ^ leftbtn) {
    103110                        leftbtn = buf.u.val.leftbtn;
    104                         mouse_ev_btn(1, leftbtn);
     111                        mouse_push_event_button(mouse_dev, 1, leftbtn);
    105112                }
    106 
     113               
    107114                if (buf.u.val.rightbtn ^ rightbtn) {
    108115                        rightbtn = buf.u.val.rightbtn;
    109                         mouse_ev_btn(2, rightbtn);
     116                        mouse_push_event_button(mouse_dev, 2, rightbtn);
    110117                }
    111 
     118               
    112119                if (buf.u.val.middlebtn ^ middlebtn) {
    113120                        middlebtn = buf.u.val.middlebtn;
    114                         mouse_ev_btn(3, middlebtn);
     121                        mouse_push_event_button(mouse_dev, 3, middlebtn);
    115122                }
     123               
     124                x = bit9toint(buf.u.val.xsign, buf.u.val.x);
     125                y = -bit9toint(buf.u.val.ysign, buf.u.val.y);
     126               
     127                if (x != 0 || y != 0)
     128                        mouse_push_event_move(mouse_dev, x, y);
     129        }
     130}
    116131
    117                 x =   bit9toint(buf.u.val.xsign, buf.u.val.x);
    118                 y = - bit9toint(buf.u.val.ysign, buf.u.val.y);
    119 
    120                 if (x != 0 || y != 0) {
    121                         mouse_ev_move(x, y);
    122                 }
    123         }
    124 
    125         return;
    126 }
     132mouse_proto_ops_t ps2_proto = {
     133        .parse = ps2_proto_parse,
     134        .init = ps2_proto_init
     135};
    127136
    128137/**

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

    ra9d85df r1875a0c  
    5757
    5858#define NAME "s3c24ser"
    59 #define NAMESPACE "hid_in"
     59#define NAMESPACE "hid"
    6060
    6161static irq_cmd_t ts_irq_cmds[] = {
Note: See TracChangeset for help on using the changeset viewer.