Changeset d900699 in mainline for uspace/srv/hid


Ignore:
Timestamp:
2011-06-17T16:48:53Z (15 years ago)
Author:
Petr Koupy <petr.koupy@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f3a605be
Parents:
df8110d3 (diff), 98caf49 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Location:
uspace/srv/hid
Files:
7 added
2 deleted
11 edited
29 moved

Legend:

Unmodified
Added
Removed

  • uspace/srv/hid/adb_mouse/adb_dev.c

    rdf8110d3 rd900699  
    4848#include "adb_dev.h"
    4949
    50 static void adb_dev_events(ipc_callid_t iid, ipc_call_t *icall);
     50static void adb_dev_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    5151
    5252int adb_dev_init(void)
    … …  
    6868       
    6969        /* NB: The callback connection is slotted for removal */
    70         if (async_obsolete_connect_to_me(dev_phone, 0, 0, 0, adb_dev_events) != 0) {
     70        if (async_obsolete_connect_to_me(dev_phone, 0, 0, 0, adb_dev_events,
     71            NULL) != 0) {
    7172                printf(NAME ": Failed to create callback from device\n");
    7273                return false;
    … …  
    7677}
    7778
    78 static void adb_dev_events(ipc_callid_t iid, ipc_call_t *icall)
     79static void adb_dev_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    7980{
    8081        /* Ignore parameters, the connection is already opened */

  • uspace/srv/hid/adb_mouse/adb_mouse.c

    rdf8110d3 rd900699  
    5252#include <kernel/ipc/ipc_methods.h>
    5353
    54 static void client_connection(ipc_callid_t iid, ipc_call_t *icall);
     54static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    5555static void mouse_ev_btn(int button, int press);
    5656static void mouse_ev_move(int dx, int dy);
    … …  
    9494}
    9595
    96 static void client_connection(ipc_callid_t iid, ipc_call_t *icall)
     96static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    9797{
    9898        ipc_callid_t callid;

  • uspace/srv/hid/char_mouse/char_mouse.c

    rdf8110d3 rd900699  
    7979}
    8080
    81 static void client_connection(ipc_callid_t iid, ipc_call_t *icall)
     81static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    8282{
    8383        ipc_callid_t callid;

  • uspace/srv/hid/char_mouse/chardev.c

    rdf8110d3 rd900699  
    4545#include <mouse_port.h>
    4646
    47 static void chardev_events(ipc_callid_t iid, ipc_call_t *icall);
     47static void chardev_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    4848
    4949static int dev_phone;
    … …  
    6969       
    7070        /* NB: The callback connection is slotted for removal */
    71         if (async_obsolete_connect_to_me(dev_phone, 0, 0, 0, chardev_events) != 0) {
     71        if (async_obsolete_connect_to_me(dev_phone, 0, 0, 0, chardev_events,
     72            NULL) != 0) {
    7273                printf(NAME ": Failed to create callback from device\n");
    7374                return false;
    … …  
    9091}
    9192
    92 static void chardev_events(ipc_callid_t iid, ipc_call_t *icall)
     93static void chardev_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    9394{
    9495        /* Ignore parameters, the connection is already opened */

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2006 Josef Cejka
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    3435
    3536#include <libc.h>
    36 #include <ipc/kbd.h>
     37#include <ipc/input.h>
    3738#include <io/keycode.h>
    38 #include <ipc/mouse.h>
    3939#include <ipc/fb.h>
    4040#include <ipc/services.h>
    … …  
    6060#include <io/style.h>
    6161#include <io/screenbuffer.h>
    62 #include <inttypes.h>
    6362
    6463#include "console.h"
    … …  
    6665#include "keybuffer.h"
    6766
    68 // FIXME: remove this header
    69 #include <kernel/ipc/ipc_methods.h>
    70 
    7167#define NAME       "console"
    7268#define NAMESPACE  "term"
    7369
    74 /** Interval for checking for new keyboard (1/4s). */
    75 #define HOTPLUG_WATCH_INTERVAL (1000 * 250)
    76 
    77 /* Kernel defines 32 but does not export it. */
    78 #define MAX_IPC_OUTGOING_PHONES 128
    79 
    80 /** To allow proper phone closing. */
    81 static ipc_callid_t driver_phones[MAX_IPC_OUTGOING_PHONES] = { 0 };
    82 
    83 /** Phone to the keyboard driver. */
    84 static int kbd_phone;
    85 
    86 /** Phone to the mouse driver. */
    87 static int mouse_phone;
     70/** Phone to the input server. */
     71static int input_phone;
    8872
    8973/** Information about framebuffer */
    … …  
    155139}
    156140
    157 static void kbd_yield(void)
    158 {
    159         async_obsolete_req_0_0(kbd_phone, KBD_YIELD);
    160 }
    161 
    162 static void kbd_reclaim(void)
    163 {
    164         async_obsolete_req_0_0(kbd_phone, KBD_RECLAIM);
     141static void input_yield(void)
     142{
     143        async_obsolete_req_0_0(input_phone, INPUT_YIELD);
     144}
     145
     146static void input_reclaim(void)
     147{
     148        async_obsolete_req_0_0(input_phone, INPUT_RECLAIM);
    165149}
    166150
    … …  
    343327                gcons_in_kernel();
    344328                screen_yield();
    345                 kbd_yield();
     329                input_yield();
    346330                async_obsolete_serialize_end();
    347331               
    … …  
    358342                if (active_console == kernel_console) {
    359343                        screen_reclaim();
    360                         kbd_reclaim();
     344                        input_reclaim();
    361345                        gcons_redraw_console();
    362346                }
    … …  
    413397}
    414398
    415 static void close_driver_phone(ipc_callid_t hash)
    416 {
    417         int i;
    418         for (i = 0; i < MAX_IPC_OUTGOING_PHONES; i++) {
    419                 if (driver_phones[i] == hash) {
    420                         printf("Device %" PRIxn " gone.\n", hash);
    421                         driver_phones[i] = 0;
    422                         async_obsolete_hangup(i);
    423                         return;
    424                 }
    425         }
    426 }
    427 
    428 /** Handler for keyboard */
    429 static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)
     399/** Handler for input events */
     400static void input_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    430401{
    431402        /* Ignore parameters, the connection is already opened */
    … …  
    439410                if (!IPC_GET_IMETHOD(call)) {
    440411                        /* TODO: Handle hangup */
    441                         close_driver_phone(iid);
     412                        async_obsolete_hangup(input_phone);
    442413                        return;
    443414                }
    444415               
    445416                switch (IPC_GET_IMETHOD(call)) {
    446                 case KBD_EVENT:
    447                         /* Got event from keyboard driver. */
     417                case INPUT_EVENT_KEY:
     418                        /* Got key press/release event */
    448419                        retval = 0;
    449420                        ev.type = IPC_GET_ARG1(call);
    … …  
    466437                        fibril_mutex_unlock(&input_mutex);
    467438                        break;
    468                 default:
    469                         retval = ENOENT;
    470                 }
    471                 async_answer_0(callid, retval);
    472         }
    473 }
    474 
    475 /** Handler for mouse events */
    476 static void mouse_events(ipc_callid_t iid, ipc_call_t *icall)
    477 {
    478         /* Ignore parameters, the connection is already opened */
    479         while (true) {
    480                 ipc_call_t call;
    481                 ipc_callid_t callid = async_get_call(&call);
    482                
    483                 int retval;
    484                
    485                 if (!IPC_GET_IMETHOD(call)) {
    486                         /* TODO: Handle hangup */
    487                         close_driver_phone(iid);
    488                         return;
    489                 }
    490                
    491                 switch (IPC_GET_IMETHOD(call)) {
    492                 case MEVENT_BUTTON:
     439                case INPUT_EVENT_MOVE:
     440                        /* Got pointer move event */
     441                        gcons_mouse_move((int) IPC_GET_ARG1(call),
     442                            (int) IPC_GET_ARG2(call));
     443                        retval = 0;
     444                        break;
     445                case INPUT_EVENT_BUTTON:
     446                        /* Got pointer button press/release event */
    493447                        if (IPC_GET_ARG1(call) == 1) {
    494448                                int newcon = gcons_mouse_btn((bool) IPC_GET_ARG2(call));
    … …  
    498452                        retval = 0;
    499453                        break;
    500                 case MEVENT_MOVE:
    501                         gcons_mouse_move((int) IPC_GET_ARG1(call),
    502                             (int) IPC_GET_ARG2(call));
    503                         retval = 0;
    504                         break;
    505454                default:
    506455                        retval = ENOENT;
    507456                }
    508 
    509457                async_answer_0(callid, retval);
    510458        }
    … …  
    597545
    598546/** Default thread for new connections */
    599 static void client_connection(ipc_callid_t iid, ipc_call_t *icall)
     547static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    600548{
    601549        console_t *cons = NULL;
    … …  
    747695}
    748696
    749 static int async_connect_to_me_hack(int phone, sysarg_t arg1, sysarg_t arg2,
    750     sysarg_t arg3, async_client_conn_t client_receiver, ipc_callid_t *hash)
    751 {
    752         sysarg_t task_hash;
    753         sysarg_t phone_hash;
    754         int rc = async_obsolete_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
    755             NULL, NULL, NULL, &task_hash, &phone_hash);
    756         if (rc != EOK)
    757                 return rc;
    758        
    759         if (client_receiver != NULL)
    760                 async_new_connection(task_hash, phone_hash, phone_hash, NULL,
    761                     client_receiver);
    762        
    763         if (hash != NULL)
    764                 *hash = phone_hash;
    765        
    766         return EOK;
    767 }
    768 
    769 static int connect_keyboard_or_mouse(const char *devname,
    770     async_client_conn_t handler, const char *dev)
     697static int connect_input(const char *dev_path)
    771698{
    772699        int phone;
    773700        devmap_handle_t handle;
    774701       
    775         int rc = devmap_device_get_handle(dev, &handle, 0);
     702        int rc = devmap_device_get_handle(dev_path, &handle, 0);
    776703        if (rc == EOK) {
    777704                phone = devmap_obsolete_device_connect(handle, 0);
    … …  
    780707                        return phone;
    781708                }
    782         } else
     709        } else {
    783710                return rc;
     711        }
    784712       
    785713        /* NB: The callback connection is slotted for removal */
    786         ipc_callid_t hash;
    787         rc = async_connect_to_me_hack(phone, SERVICE_CONSOLE, 0, phone,
    788             handler, &hash);
     714        rc = async_obsolete_connect_to_me(phone, SERVICE_CONSOLE, 0, 0,
     715            input_events, NULL);
     716
    789717        if (rc != EOK) {
    790718                async_obsolete_hangup(phone);
    … …  
    794722        }
    795723       
    796         driver_phones[phone] = hash;
    797         printf("%s: found %s \"%s\" (%" PRIxn ").\n", NAME, devname, dev, hash);
    798724        return phone;
    799725}
    800726
    801 static int connect_keyboard(const char *dev)
    802 {
    803         return connect_keyboard_or_mouse("keyboard", keyboard_events, dev);
    804 }
    805 
    806 static int connect_mouse(const char *dev)
    807 {
    808         return connect_keyboard_or_mouse("mouse", mouse_events, dev);
    809 }
    810 
    811 struct hid_class_info {
    812         char *classname;
    813         int (*connection_func)(const char *);
    814 };
    815 
    816 /** Periodically check for new keyboards in /dev/class/.
    817  *
    818  * @param arg Class name.
    819  *
    820  * @return This function should never exit.
    821  *
    822  */
    823 static int check_new_device_fibril(void *arg)
    824 {
    825         struct hid_class_info *dev_info = (struct hid_class_info *) arg;
    826        
    827         size_t index = 1;
    828        
    829         while (true) {
    830                 async_usleep(HOTPLUG_WATCH_INTERVAL);
    831                
    832                 char *dev;
    833                 int rc = asprintf(&dev, "class/%s\\%zu",
    834                     dev_info->classname, index);
    835                 if (rc < 0)
    836                         continue;
    837                
    838                 rc = dev_info->connection_func(dev);
    839                 if (rc > 0) {
    840                         /* We do not allow unplug. */
    841                         index++;
    842                 }
    843                
    844                 free(dev);
    845         }
    846        
    847         return EOK;
    848 }
    849 
    850 /** Start a fibril monitoring hot-plugged keyboards.
    851  */
    852 static void check_new_devices_in_background(int (*connection_func)(const char *),
    853     const char *classname)
    854 {
    855         struct hid_class_info *dev_info = malloc(sizeof(struct hid_class_info));
    856         if (dev_info == NULL) {
    857                 printf("%s: Out of memory, no hot-plug support.\n", NAME);
    858                 return;
    859         }
    860        
    861         int rc = asprintf(&dev_info->classname, "%s", classname);
    862         if (rc < 0) {
    863                 printf("%s: Failed to format classname: %s.\n", NAME,
    864                     str_error(rc));
    865                 return;
    866         }
    867        
    868         dev_info->connection_func = connection_func;
    869        
    870         fid_t fid = fibril_create(check_new_device_fibril, (void *) dev_info);
    871         if (!fid) {
    872                 printf("%s: Failed to create hot-plug fibril for %s.\n", NAME,
    873                     classname);
    874                 return;
    875         }
    876        
    877         fibril_add_ready(fid);
    878 }
    879 
    880 static bool console_srv_init(char *kdev)
    881 {
    882         /* Connect to input device */
    883         kbd_phone = connect_keyboard(kdev);
    884         if (kbd_phone < 0)
     727static bool console_srv_init(char *input_dev)
     728{
     729        /* Connect to input server */
     730        input_phone = connect_input(input_dev);
     731        if (input_phone < 0)
    885732                return false;
    886        
    887         mouse_phone = connect_mouse("hid_in/mouse");
    888         if (mouse_phone < 0) {
    889                 printf("%s: Failed to connect to mouse device %s\n", NAME,
    890                     str_error(mouse_phone));
    891         }
    892733       
    893734        /* Connect to framebuffer driver */
    … …  
    972813                printf("%s: Error registering kconsole notifications\n", NAME);
    973814       
    974         /* Start fibril for checking on hot-plugged keyboards. */
    975         check_new_devices_in_background(connect_keyboard, "keyboard");
    976         check_new_devices_in_background(connect_mouse, "mouse");
    977        
    978815        return true;
    979816}
    … …  
    981818static void usage(void)
    982819{
    983         printf("Usage: console <input>\n");
     820        printf("Usage: console <input_dev>\n");
    984821}
    985822

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

    rdf8110d3 rd900699  
    168168void gcons_change_console(size_t index)
    169169{
    170         if (!use_gcons)
    171                 return;
     170        if (!use_gcons) {
     171                active_console = index;
     172                return;
     173        }
    172174       
    173175        if (active_console == KERNEL_CONSOLE) {

  • uspace/srv/hid/fb/ega.c

    rdf8110d3 rd900699  
    256256}
    257257
    258 static void ega_client_connection(ipc_callid_t iid, ipc_call_t *icall)
     258static void ega_client_connection(ipc_callid_t iid, ipc_call_t *icall,
     259    void *arg)
    259260{
    260261        size_t intersize = 0;

  • uspace/srv/hid/fb/fb.c

    rdf8110d3 rd900699  
    15761576 *
    15771577 */
    1578 static void fb_client_connection(ipc_callid_t iid, ipc_call_t *icall)
     1578static void fb_client_connection(ipc_callid_t iid, ipc_call_t *icall,
     1579    void *arg)
    15791580{
    15801581        unsigned int vp = 0;

  • uspace/srv/hid/fb/serial_console.c

    rdf8110d3 rd900699  
    315315 * Main function of the thread serving client connections.
    316316 */
    317 void serial_client_connection(ipc_callid_t iid, ipc_call_t *icall)
     317void serial_client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    318318{
    319319        keyfield_t *interbuf = NULL;

  • uspace/srv/hid/fb/serial_console.h

    rdf8110d3 rd900699  
    5252extern void serial_set_scroll_region(sysarg_t);
    5353extern void serial_console_init(putc_function_t, sysarg_t, sysarg_t);
    54 extern void serial_client_connection(ipc_callid_t, ipc_call_t *);
     54extern void serial_client_connection(ipc_callid_t, ipc_call_t *, void *arg);
    5555
    5656#endif

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2828
    2929/** @addtogroup kbd_ctl
    30  * @ingroup kbd
     30 * @ingroup input
    3131 * @{
    3232 */
    … …  
    4040#include <io/keycode.h>
    4141#include <kbd_ctl.h>
     42#include <kbd_port.h>
     43
     44static void apple_ctl_parse_scancode(int);
     45static int apple_ctl_init(kbd_dev_t *);
     46static void apple_ctl_set_ind(kbd_dev_t *, unsigned);
     47
     48kbd_ctl_ops_t apple_ctl = {
     49        .parse_scancode = apple_ctl_parse_scancode,
     50        .init = apple_ctl_init,
     51        .set_ind = apple_ctl_set_ind
     52};
    4253
    4354#define KBD_KEY_RELEASE         0x80
    4455
     56static kbd_dev_t *kbd_dev;
     57
    4558static int scanmap[];
    4659
    47 int kbd_ctl_init(void)
     60static int apple_ctl_init(kbd_dev_t *kdev)
    4861{
     62        kbd_dev = kdev;
    4963        return 0;
    5064}
    5165
    52 void kbd_ctl_parse_scancode(int scancode)
     66static void apple_ctl_parse_scancode(int scancode)
    5367{
    5468        kbd_event_type_t type;
    … …  
    6781        key = scanmap[scancode];
    6882        if (key != 0)
    69                 kbd_push_ev(type, key);
     83                kbd_push_ev(kbd_dev, type, key);
    7084}
    7185
    72 void kbd_ctl_set_ind(unsigned mods)
     86static void apple_ctl_set_ind(kbd_dev_t *kdev, unsigned mods)
    7387{
    7488        (void) mods;

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2828
    2929/** @addtogroup kbd_ctl
    30  * @ingroup kbd
     30 * @ingroup input
    3131 * @{
    3232 */
    … …  
    4040#include <io/keycode.h>
    4141#include <kbd_ctl.h>
     42#include <kbd_port.h>
    4243#include <gsp.h>
    4344#include <stroke.h>
    4445
     46static void gxe_fb_ctl_parse_scancode(int);
     47static int gxe_fb_ctl_init(kbd_dev_t *);
     48static void gxe_fb_ctl_set_ind(kbd_dev_t *, unsigned);
     49
     50kbd_ctl_ops_t gxe_fb_ctl = {
     51        .parse_scancode = gxe_fb_ctl_parse_scancode,
     52        .init = gxe_fb_ctl_init,
     53        .set_ind = gxe_fb_ctl_set_ind
     54};
     55
     56static kbd_dev_t *kbd_dev;
     57
    4558/** Scancode parser */
    4659static gsp_t sp;
    … …  
    5164#include <stdio.h>
    5265
    53 int seq_defs[] = {
     66static int seq_defs[] = {
    5467        /* Not shifted */
    5568
    … …  
    207220};
    208221
    209 int kbd_ctl_init(void)
     222static int gxe_fb_ctl_init(kbd_dev_t *kdev)
    210223{
     224        kbd_dev = kdev;
    211225        ds = 0;
    212226
    … …  
    215229}
    216230
    217 void kbd_ctl_parse_scancode(int scancode)
     231static void gxe_fb_ctl_parse_scancode(int scancode)
    218232{
    219233        unsigned mods, key;
    … …  
    221235        ds = gsp_step(&sp, ds, scancode, &mods, &key);
    222236        if (key != 0) {
    223                 stroke_sim(mods, key);
     237                stroke_sim(kbd_dev, mods, key);
    224238        }
    225239}
    226240
    227 void kbd_ctl_set_ind(unsigned mods)
     241static void gxe_fb_ctl_set_ind(kbd_dev_t *kdev, unsigned mods)
    228242{
    229243        (void) mods;

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2828
    2929/** @addtogroup kbd_ctl
    30  * @ingroup kbd
     30 * @ingroup input
    3131 * @{
    3232 */
    … …  
    4343#include <gsp.h>
    4444
     45static void pc_ctl_parse_scancode(int);
     46static int pc_ctl_init(kbd_dev_t *);
     47static void pc_ctl_set_ind(kbd_dev_t *, unsigned);
     48
     49kbd_ctl_ops_t pc_ctl = {
     50        .parse_scancode = pc_ctl_parse_scancode,
     51        .init = pc_ctl_init,
     52        .set_ind = pc_ctl_set_ind
     53};
     54
    4555enum dec_state {
    4656        ds_s,
    … …  
    6474
    6575static enum dec_state ds;
     76static kbd_dev_t *kbd_dev;
    6677
    6778static int scanmap_simple[] = {
    … …  
    197208};
    198209
    199 int kbd_ctl_init(void)
     210static int pc_ctl_init(kbd_dev_t *kdev)
    200211{
     212        kbd_dev = kdev;
    201213        ds = ds_s;
    202214        return 0;
    203215}
    204216
    205 void kbd_ctl_parse_scancode(int scancode)
     217static void pc_ctl_parse_scancode(int scancode)
    206218{
    207219        kbd_event_type_t type;
    … …  
    250262        key = map[scancode];
    251263        if (key != 0)
    252                 kbd_push_ev(type, key);
     264                kbd_push_ev(kbd_dev, type, key);
    253265}
    254266
    255 void kbd_ctl_set_ind(unsigned mods)
     267static void pc_ctl_set_ind(kbd_dev_t *kdev, unsigned mods)
    256268{
    257269        uint8_t b;
    … …  
    265277                b = b | LI_SCROLL;
    266278
    267         kbd_port_write(KBD_CMD_SET_LEDS);
    268         kbd_port_write(b);
     279        (*kbd_dev->port_ops->write)(KBD_CMD_SET_LEDS);
     280        (*kbd_dev->port_ops->write)(b);
    269281}
    270282

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2828
    2929/** @addtogroup kbd_ctl
    30  * @ingroup kbd
     30 * @ingroup input
    3131 * @{
    3232 */
    … …  
    3939#include <io/keycode.h>
    4040#include <kbd_ctl.h>
     41#include <kbd_port.h>
    4142#include <gsp.h>
    4243#include <stroke.h>
    4344
     45static void stty_ctl_parse_scancode(int);
     46static int stty_ctl_init(kbd_dev_t *);
     47static void stty_ctl_set_ind(kbd_dev_t *, unsigned);
     48
     49kbd_ctl_ops_t stty_ctl = {
     50        .parse_scancode = stty_ctl_parse_scancode,
     51        .init = stty_ctl_init,
     52        .set_ind = stty_ctl_set_ind
     53};
     54
     55static kbd_dev_t *kbd_dev;
     56
    4457/** Scancode parser */
    4558static gsp_t sp;
    … …  
    5063#include <stdio.h>
    5164
    52 int seq_defs[] = {
     65static int seq_defs[] = {
    5366        /* Not shifted */
    5467
    … …  
    206219};
    207220
    208 int kbd_ctl_init(void)
     221static int stty_ctl_init(kbd_dev_t *kdev)
    209222{
     223        kbd_dev = kdev;
    210224        ds = 0;
    211225
    … …  
    214228}
    215229
    216 void kbd_ctl_parse_scancode(int scancode)
     230static void stty_ctl_parse_scancode(int scancode)
    217231{
    218232        unsigned mods, key;
    … …  
    220234        ds = gsp_step(&sp, ds, scancode, &mods, &key);
    221235        if (key != 0) {
    222                 stroke_sim(mods, key);
     236                stroke_sim(kbd_dev, mods, key);
    223237        }
    224238}
    225239
    226 void kbd_ctl_set_ind(unsigned mods)
     240static void stty_ctl_set_ind(kbd_dev_t *kdev, unsigned mods)
    227241{
    228242        (void) mods;

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2006 Jakub Jermar
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    2829
    2930/** @addtogroup kbd_ctl
    30  * @ingroup kbd
     31 * @ingroup input
    3132 * @{
    3233 */
    … …  
    4041#include <io/keycode.h>
    4142#include <kbd_ctl.h>
     43#include <kbd_port.h>
     44
     45static void sun_ctl_parse_scancode(int);
     46static int sun_ctl_init(kbd_dev_t *);
     47static void sun_ctl_set_ind(kbd_dev_t *, unsigned);
     48
     49kbd_ctl_ops_t sun_ctl = {
     50        .parse_scancode = sun_ctl_parse_scancode,
     51        .init = sun_ctl_init,
     52        .set_ind = sun_ctl_set_ind
     53};
     54
     55static kbd_dev_t *kbd_dev;
    4256
    4357#define KBD_KEY_RELEASE         0x80
    … …  
    4660static int scanmap_simple[];
    4761
    48 int kbd_ctl_init(void)
     62static int sun_ctl_init(kbd_dev_t *kdev)
    4963{
     64        kbd_dev = kdev;
    5065        return 0;
    5166}
    5267
    53 void kbd_ctl_parse_scancode(int scancode)
     68static void sun_ctl_parse_scancode(int scancode)
    5469{
    5570        kbd_event_type_t type;
    … …  
    7186        key = scanmap_simple[scancode];
    7287        if (key != 0)
    73                 kbd_push_ev(type, key);
     88                kbd_push_ev(kbd_dev, type, key);
    7489}
    7590
    76 void kbd_ctl_set_ind(unsigned mods)
     91static void sun_ctl_set_ind(kbd_dev_t *kdev, unsigned mods)
    7792{
    7893        (void) mods;

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

    rdf8110d3 rd900699  
    2929/**
    3030 * @addtogroup kbdgen generic
    31  * @ingroup  kbd
     31 * @ingroup  input
    3232 * @{
    3333 */

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup kbd
     29/** @addtogroup input
    3030 * @{
    3131 */
    … …  
    5252
    5353/** Simulate keystroke using sequences of key presses and releases. */
    54 void stroke_sim(unsigned mod, unsigned key)
     54void stroke_sim(kbd_dev_t *kdev, unsigned mod, unsigned key)
    5555{
    5656        int i;
    … …  
    6060        while (mods_keys[i][0] != 0) {
    6161                if (mod & mods_keys[i][0]) {
    62                         kbd_push_ev(KEY_PRESS, mods_keys[i][1]);
     62                        kbd_push_ev(kdev, KEY_PRESS, mods_keys[i][1]);
    6363                }
    6464                ++i;
    … …  
    6767        /* Simulate key press and release. */
    6868        if (key != 0) {
    69                 kbd_push_ev(KEY_PRESS, key);
    70                 kbd_push_ev(KEY_RELEASE, key);
     69                kbd_push_ev(kdev, KEY_PRESS, key);
     70                kbd_push_ev(kdev, KEY_RELEASE, key);
    7171        }
    7272
    … …  
    7575        while (mods_keys[i][0] != 0) {
    7676                if (mod & mods_keys[i][0]) {
    77                         kbd_push_ev(KEY_RELEASE, mods_keys[i][1]);
     77                        kbd_push_ev(kdev, KEY_RELEASE, mods_keys[i][1]);
    7878                }
    7979                ++i;

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

    rdf8110d3 rd900699  
    2727 */
    2828
    29 /** @addtogroup kbdgen generic
     29/** @addtogroup inputgen generic
    3030 * @brief       Generic scancode parser.
    31  * @ingroup  kbd
     31 * @ingroup  input
    3232 * @{
    33  */ 
     33 */
    3434/** @file
    3535 */

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2006 Josef Cejka
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    2728 */
    2829
    29 /** @addtogroup kbdgen generic
    30  * @brief HelenOS generic uspace keyboard handler.
    31  * @ingroup kbd
     30/** @addtogroup inputgen generic
     31 * @brief HelenOS input server.
     32 * @ingroup input
    3233 * @{
    3334 */
    … …  
    3536 */
    3637
    37 #ifndef KBD_KBD_H_
    38 #define KBD_KBD_H_
     38#ifndef INPUT_H_
     39#define INPUT_H_
    3940
    4041#include <bool.h>
     42
     43#define NAME       "input"
     44#define NAMESPACE  "hid_in"
    4145
    4246extern bool irc_service;
    4347extern int irc_phone;
    4448
    45 extern void kbd_push_scancode(int);
    46 extern void kbd_push_ev(int, unsigned int);
     49extern link_t mouse_devs;
     50
     51void input_event_move(int, int);
     52void input_event_button(int bnum, int press);
    4753
    4854#endif

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
    3  * Copyright (c) 2011 Lubos Slovak
    4  * (copied from /uspace/srv/hid/kbd/include/layout.h)
     2 * Copyright (c) 2011 Jiri Svoboda
    53 * All rights reserved.
    64 *
    … …  
    2927 */
    3028
    31 /** @addtogroup drvusbhid
     29/** @addtogroup inputgen generic
     30 * @brief       Keyboard controller driver interface.
     31 * @ingroup  input
    3232 * @{
    3333 */
    3434/** @file
    35  * Keyboard layout.
    3635 */
    3736
    38 #ifndef USB_HID_LAYOUT_H_
    39 #define USB_HID_LAYOUT_H_
     37#ifndef KBD_CTL_H_
     38#define KBD_CTL_H_
    4039
    41 #include <sys/types.h>
    42 #include <io/console.h>
     40#include <kbd_port.h>
    4341
    44 typedef struct {
    45         void (*reset)(void);
    46         wchar_t (*parse_ev)(kbd_event_t *);
    47 } layout_op_t;
     42struct kbd_dev;
    4843
    49 extern layout_op_t us_qwerty_op;
    50 extern layout_op_t us_dvorak_op;
    51 extern layout_op_t cz_op;
     44typedef struct kbd_ctl_ops {
     45        void (*parse_scancode)(int);
     46        int (*init)(struct kbd_dev *);
     47        void (*set_ind)(struct kbd_dev *, unsigned);
     48} kbd_ctl_ops_t;
     49
     50extern kbd_ctl_ops_t apple_ctl;
     51extern kbd_ctl_ops_t gxe_fb_ctl;
     52extern kbd_ctl_ops_t kbdev_ctl;
     53extern kbd_ctl_ops_t pc_ctl;
     54extern kbd_ctl_ops_t stty_ctl;
     55extern kbd_ctl_ops_t sun_ctl;
    5256
    5357#endif
    … …  
    5559/**
    5660 * @}
    57  */
     61 */
     62

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

    rdf8110d3 rd900699  
    2727 */
    2828
    29 /** @addtogroup kbdgen generic
    30  * @brief HelenOS generic uspace keyboard handler.
    31  * @ingroup kbd
     29/** @addtogroup inputgen generic
     30 * @brief Keyboard layout interface.
     31 * @ingroup input
    3232 * @{
    3333 */
    … …  
    4141#include <io/console.h>
    4242
    43 typedef struct {
    44         void (*reset)(void);
    45         wchar_t (*parse_ev)(kbd_event_t *);
    46 } layout_op_t;
     43/** Layout instance state */
     44typedef struct layout {
     45        /** Ops structure */
     46        struct layout_ops *ops;
    4747
    48 extern layout_op_t us_qwerty_op;
    49 extern layout_op_t us_dvorak_op;
    50 extern layout_op_t cz_op;
     48        /* Layout-private data */
     49        void *layout_priv;
     50} layout_t;
     51
     52/** Layout ops */
     53typedef struct layout_ops {
     54        int (*create)(layout_t *);
     55        void (*destroy)(layout_t *);
     56        wchar_t (*parse_ev)(layout_t *, kbd_event_t *);
     57} layout_ops_t;
     58
     59extern layout_ops_t us_qwerty_ops;
     60extern layout_ops_t us_dvorak_ops;
     61extern layout_ops_t cz_ops;
     62
     63extern layout_t *layout_create(layout_ops_t *);
     64extern void layout_destroy(layout_t *);
     65extern wchar_t layout_parse_ev(layout_t *, kbd_event_t *);
    5166
    5267#endif

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup kbdgen generic
    30  * @brief       HelenOS generic uspace keyboard handler.
    31  * @ingroup  kbd
     29/** @addtogroup inputgen generic
     30 * @brief Mouse device handling.
     31 * @ingroup input
    3232 * @{
    33  */ 
     33 */
    3434/** @file
    3535 */
    3636
    37 #ifndef KBD_PORT_H_
    38 #define KBD_PORT_H_
     37#ifndef MOUSE_H_
     38#define MOUSE_H_
    3939
    40 #include <sys/types.h>
     40#include <adt/list.h>
    4141
    42 extern int kbd_port_init(void);
    43 extern void kbd_port_yield(void);
    44 extern void kbd_port_reclaim(void);
    45 extern void kbd_port_write(uint8_t);
     42typedef struct mouse_dev {
     43        /** Link to mouse_devs list */
     44        link_t mouse_devs;
     45
     46        /** Path to the device */
     47        const char *dev_path;
     48} mouse_dev_t;
     49
     50int mouse_add_dev(const char *dev_path);
    4651
    4752#endif
    … …  
    4954/**
    5055 * @}
    51  */
    52 
     56 */

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup kbdgen generic
     29/** @addtogroup inputgen generic
    3030 * @brief       Generic scancode parser.
    31  * @ingroup  kbd
     31 * @ingroup  input
    3232 * @{
    3333 */
    … …  
    3838#define KBD_STROKE_H_
    3939
    40 extern void stroke_sim(unsigned, unsigned);
     40#include <kbd.h>
     41
     42extern void stroke_sim(kbd_dev_t *, unsigned, unsigned);
    4143
    4244#endif

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup kbd
     29/** @addtogroup input
    3030 * @brief Czech QWERTZ layout.
    3131 * @{
    3232 */
    3333
    34 #include <kbd.h>
     34#include <errno.h>
     35#include <input.h>
    3536#include <io/console.h>
    3637#include <io/keycode.h>
    3738#include <bool.h>
    3839#include <layout.h>
    39 
    40 static void layout_reset(void);
    41 static wchar_t layout_parse_ev(kbd_event_t *ev);
     40#include <stdlib.h>
     41
     42static int cz_create(layout_t *);
     43static void cz_destroy(layout_t *);
     44static wchar_t cz_parse_ev(layout_t *, kbd_event_t *ev);
    4245
    4346enum m_state {
    … …  
    4750};
    4851
    49 static enum m_state mstate;
    50 
    51 layout_op_t cz_op = {
    52         layout_reset,
    53         layout_parse_ev
     52typedef struct {
     53        enum m_state mstate;
     54} layout_cz_t;
     55
     56layout_ops_t cz_ops = {
     57        .create = cz_create,
     58        .destroy = cz_destroy,
     59        .parse_ev = cz_parse_ev
    5460};
    5561
    … …  
    273279}
    274280
    275 static wchar_t parse_ms_hacek(kbd_event_t *ev)
     281static wchar_t parse_ms_hacek(layout_cz_t *cz_state, kbd_event_t *ev)
    276282{
    277283        wchar_t c;
    278284
    279         mstate = ms_start;
     285        cz_state->mstate = ms_start;
    280286
    281287        /* Produce no characters when Ctrl or Alt is pressed. */
    … …  
    291297}
    292298
    293 static wchar_t parse_ms_carka(kbd_event_t *ev)
     299static wchar_t parse_ms_carka(layout_cz_t *cz_state, kbd_event_t *ev)
    294300{
    295301        wchar_t c;
    296302
    297         mstate = ms_start;
     303        cz_state->mstate = ms_start;
    298304
    299305        /* Produce no characters when Ctrl or Alt is pressed. */
    … …  
    309315}
    310316
    311 static wchar_t parse_ms_start(kbd_event_t *ev)
     317static wchar_t parse_ms_start(layout_cz_t *cz_state, kbd_event_t *ev)
    312318{
    313319        wchar_t c;
    … …  
    319325        if (ev->key == KC_EQUALS) {
    320326                if ((ev->mods & KM_SHIFT) != 0)
    321                         mstate = ms_hacek;
     327                        cz_state->mstate = ms_hacek;
    322328                else
    323                         mstate = ms_carka;
     329                        cz_state->mstate = ms_carka;
    324330
    325331                return 0;
    … …  
    379385}
    380386
    381 static void layout_reset(void)
    382 {
    383         mstate = ms_start;
    384 }
    385 
    386 static wchar_t layout_parse_ev(kbd_event_t *ev)
    387 {
     387static int cz_create(layout_t *state)
     388{
     389        layout_cz_t *cz_state;
     390
     391        cz_state = malloc(sizeof(layout_cz_t));
     392        if (cz_state == NULL) {
     393                printf(NAME ": Out of memory.\n");
     394                return ENOMEM;
     395        }
     396
     397        cz_state->mstate = ms_start;
     398        state->layout_priv = (void *) cz_state;
     399
     400        return EOK;
     401}
     402
     403static void cz_destroy(layout_t *state)
     404{
     405        free(state->layout_priv);
     406}
     407
     408static wchar_t cz_parse_ev(layout_t *state, kbd_event_t *ev)
     409{
     410        layout_cz_t *cz_state = (layout_cz_t *) state->layout_priv;
     411
    388412        if (ev->type != KEY_PRESS)
    389413                return 0;
    … …  
    392416                return 0;
    393417       
    394         switch (mstate) {
     418        switch (cz_state->mstate) {
    395419        case ms_start:
    396                 return parse_ms_start(ev);
     420                return parse_ms_start(cz_state, ev);
    397421        case ms_hacek:
    398                 return parse_ms_hacek(ev);
     422                return parse_ms_hacek(cz_state, ev);
    399423        case ms_carka:
    400                 return parse_ms_carka(ev);
     424                return parse_ms_carka(cz_state, ev);
    401425        }
    402426       

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup kbd
     29/** @addtogroup input
    3030 * @brief US Dvorak Simplified Keyboard layout.
    3131 * @{
    3232 */
    3333
     34#include <errno.h>
    3435#include <kbd.h>
    3536#include <io/console.h>
    … …  
    3738#include <layout.h>
    3839
    39 static void layout_reset(void);
    40 static wchar_t layout_parse_ev(kbd_event_t *ev);
    41 
    42 layout_op_t us_dvorak_op = {
    43         layout_reset,
    44         layout_parse_ev
     40static int us_dvorak_create(layout_t *);
     41static void us_dvorak_destroy(layout_t *);
     42static wchar_t us_dvorak_parse_ev(layout_t *, kbd_event_t *ev);
     43
     44layout_ops_t us_dvorak_ops = {
     45        .create = us_dvorak_create,
     46        .destroy = us_dvorak_destroy,
     47        .parse_ev = us_dvorak_parse_ev
    4548};
    4649
    … …  
    206209}
    207210
    208 static void layout_reset(void)
    209 {
    210 }
    211 
    212 static wchar_t layout_parse_ev(kbd_event_t *ev)
     211static int us_dvorak_create(layout_t *state)
     212{
     213        return EOK;
     214}
     215
     216static void us_dvorak_destroy(layout_t *state)
     217{
     218}
     219
     220static wchar_t us_dvorak_parse_ev(layout_t *state, kbd_event_t *ev)
    213221{
    214222        wchar_t c;

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup kbd
     29/** @addtogroup input
    3030 * @brief       US QWERTY layout.
    3131 * @{
    32  */
    33 
     32 */
     33
     34#include <errno.h>
    3435#include <kbd.h>
    3536#include <io/console.h>
    … …  
    3738#include <layout.h>
    3839
    39 static void layout_reset(void);
    40 static wchar_t layout_parse_ev(kbd_event_t *ev);
    41 
    42 layout_op_t us_qwerty_op = {
    43         layout_reset,
    44         layout_parse_ev
     40static int us_qwerty_create(layout_t *);
     41static void us_qwerty_destroy(layout_t *);
     42static wchar_t us_qwerty_parse_ev(layout_t *, kbd_event_t *ev);
     43
     44layout_ops_t us_qwerty_ops = {
     45        .create = us_qwerty_create,
     46        .destroy = us_qwerty_destroy,
     47        .parse_ev = us_qwerty_parse_ev
    4548};
    4649
    … …  
    200203}
    201204
    202 static void layout_reset(void)
    203 {
    204 }
    205 
    206 static wchar_t layout_parse_ev(kbd_event_t *ev)
     205static int us_qwerty_create(layout_t *state)
     206{
     207        return EOK;
     208}
     209
     210static void us_qwerty_destroy(layout_t *state)
     211{
     212}
     213
     214static wchar_t us_qwerty_parse_ev(layout_t *state, kbd_event_t *ev)
    207215{
    208216        wchar_t c;

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3838#include <async.h>
    3939#include <async_obsolete.h>
     40#include <input.h>
    4041#include <kbd_port.h>
    4142#include <kbd.h>
    … …  
    4647#include <devmap_obsolete.h>
    4748
    48 static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall);
     49static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    4950static void adb_kbd_reg0_data(uint16_t data);
    5051
     52static int adb_port_init(kbd_dev_t *);
     53static void adb_port_yield(void);
     54static void adb_port_reclaim(void);
     55static void adb_port_write(uint8_t data);
     56
     57kbd_port_ops_t adb_port = {
     58        .init = adb_port_init,
     59        .yield = adb_port_yield,
     60        .reclaim = adb_port_reclaim,
     61        .write = adb_port_write
     62};
     63
     64static kbd_dev_t *kbd_dev;
    5165static int dev_phone;
    5266
    53 #define NAME "kbd"
    54 
    55 int kbd_port_init(void)
     67static int adb_port_init(kbd_dev_t *kdev)
    5668{
    5769        const char *dev = "adb/kbd";
    5870        devmap_handle_t handle;
     71
     72        kbd_dev = kdev;
    5973       
    6074        int rc = devmap_device_get_handle(dev, &handle, 0);
    … …  
    6983       
    7084        /* NB: The callback connection is slotted for removal */
    71         rc = async_obsolete_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events);
     85        rc = async_obsolete_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events,
     86            NULL);
    7287        if (rc != EOK) {
    7388                printf(NAME ": Failed to create callback from device\n");
    … …  
    7893}
    7994
    80 void kbd_port_yield(void)
     95static void adb_port_yield(void)
    8196{
    8297}
    8398
    84 void kbd_port_reclaim(void)
     99static void adb_port_reclaim(void)
    85100{
    86101}
    87102
    88 void kbd_port_write(uint8_t data)
     103static void adb_port_write(uint8_t data)
    89104{
    90105        /*async_msg_1(dev_phone, CHAR_WRITE_BYTE, data);*/
    91106}
    92107
    93 static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall)
     108static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    94109{
    95110        /* Ignore parameters, the connection is already opened */
    … …  
    125140
    126141        if (b0 != 0xff)
    127                 kbd_push_scancode(b0);
     142                kbd_push_scancode(kbd_dev, b0);
    128143        if (b1 != 0xff)
    129                 kbd_push_scancode(b1);
     144                kbd_push_scancode(kbd_dev, b1);
    130145}
    131146

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

    rdf8110d3 rd900699  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3838#include <async.h>
    3939#include <async_obsolete.h>
     40#include <input.h>
    4041#include <kbd_port.h>
    4142#include <kbd.h>
    … …  
    4546#include <stdio.h>
    4647
    47 #define NAME  "kbd/chardev"
     48static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    4849
    49 static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall);
     50static int chardev_port_init(kbd_dev_t *);
     51static void chardev_port_yield(void);
     52static void chardev_port_reclaim(void);
     53static void chardev_port_write(uint8_t data);
    5054
     55kbd_port_ops_t chardev_port = {
     56        .init = chardev_port_init,
     57        .yield = chardev_port_yield,
     58        .reclaim = chardev_port_reclaim,
     59        .write = chardev_port_write
     60};
     61
     62static kbd_dev_t *kbd_dev;
    5163static int dev_phone;
    5264
    … …  
    5971static const unsigned int num_devs = sizeof(in_devs) / sizeof(in_devs[0]);
    6072
    61 int kbd_port_init(void)
     73static int chardev_port_init(kbd_dev_t *kdev)
    6274{
    6375        devmap_handle_t handle;
    6476        unsigned int i;
    6577        int rc;
     78       
     79        kbd_dev = kdev;
    6680       
    6781        for (i = 0; i < num_devs; i++) {
    … …  
    8397       
    8498        /* NB: The callback connection is slotted for removal */
    85         if (async_obsolete_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events) != 0) {
     99        if (async_obsolete_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events,
     100            NULL) != 0) {
    86101                printf(NAME ": Failed to create callback from device\n");
    87102                return -1;
    … …  
    91106}
    92107
    93 void kbd_port_yield(void)
     108static void chardev_port_yield(void)
    94109{
    95110}
    96111
    97 void kbd_port_reclaim(void)
     112static void chardev_port_reclaim(void)
    98113{
    99114}
    100115
    101 void kbd_port_write(uint8_t data)
     116static void chardev_port_write(uint8_t data)
    102117{
    103118        async_obsolete_msg_1(dev_phone, CHAR_WRITE_BYTE, data);
    104119}
    105120
    106 static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall)
     121static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    107122{
    108123        /* Ignore parameters, the connection is already opened */
    … …  
    121136                switch (IPC_GET_IMETHOD(call)) {
    122137                case CHAR_NOTIF_BYTE:
    123                         kbd_push_scancode(IPC_GET_ARG1(call));
     138                        kbd_push_scancode(kbd_dev, IPC_GET_ARG1(call));
    124139                        break;
    125140                default:

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2007 Michal Kebrt
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4243#include <errno.h>
    4344
     45static int gxemul_port_init(kbd_dev_t *);
     46static void gxemul_port_yield(void);
     47static void gxemul_port_reclaim(void);
     48static void gxemul_port_write(uint8_t data);
     49
     50kbd_port_ops_t gxemul_port = {
     51        .init = gxemul_port_init,
     52        .yield = gxemul_port_yield,
     53        .reclaim = gxemul_port_reclaim,
     54        .write = gxemul_port_write
     55};
     56
     57static kbd_dev_t *kbd_dev;
     58
    4459static irq_cmd_t gxemul_cmds[] = {
    4560        {
    … …  
    6176
    6277/** Initializes keyboard handler. */
    63 int kbd_port_init(void)
     78static int gxemul_port_init(kbd_dev_t *kdev)
    6479{
     80        kbd_dev = kdev;
     81       
    6582        sysarg_t addr;
    6683        if (sysinfo_get_value("kbd.address.virtual", &addr) != EOK)
    … …  
    7794}
    7895
    79 void kbd_port_yield(void)
     96static void gxemul_port_yield(void)
    8097{
    8198}
    8299
    83 void kbd_port_reclaim(void)
     100static void gxemul_port_reclaim(void)
    84101{
    85102}
    86103
    87 void kbd_port_write(uint8_t data)
     104static void gxemul_port_write(uint8_t data)
    88105{
    89106        (void) data;
    … …  
    101118        int scan_code = IPC_GET_ARG2(*call);
    102119
    103         kbd_push_scancode(scan_code);
     120        kbd_push_scancode(kbd_dev, scan_code);
    104121}
    105122

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2006 Josef Cejka
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4243#include <errno.h>
    4344
    44 irq_cmd_t msim_cmds[] = {
     45static int msim_port_init(kbd_dev_t *);
     46static void msim_port_yield(void);
     47static void msim_port_reclaim(void);
     48static void msim_port_write(uint8_t data);
     49
     50kbd_port_ops_t msim_port = {
     51        .init = msim_port_init,
     52        .yield = msim_port_yield,
     53        .reclaim = msim_port_reclaim,
     54        .write = msim_port_write
     55};
     56
     57static kbd_dev_t *kbd_dev;
     58
     59static irq_cmd_t msim_cmds[] = {
    4560        {
    4661                .cmd = CMD_PIO_READ_8,
    … …  
    5166                .cmd = CMD_ACCEPT
    5267        }
    53        
    5468};
    5569
    56 irq_code_t msim_kbd = {
     70static irq_code_t msim_kbd = {
    5771        sizeof(msim_cmds) / sizeof(irq_cmd_t),
    5872        msim_cmds
    … …  
    6175static void msim_irq_handler(ipc_callid_t iid, ipc_call_t *call);
    6276
    63 int kbd_port_init(void)
     77static int msim_port_init(kbd_dev_t *kdev)
    6478{
     79        kbd_dev = kdev;
     80
    6581        sysarg_t vaddr;
    6682        if (sysinfo_get_value("kbd.address.virtual", &vaddr) != EOK)
    … …  
    7894}
    7995
    80 void kbd_port_yield(void)
     96static void msim_port_yield(void)
    8197{
    8298}
    8399
    84 void kbd_port_reclaim(void)
     100static void msim_port_reclaim(void)
    85101{
    86102}
    87103
    88 void kbd_port_write(uint8_t data)
     104static void msim_port_write(uint8_t data)
    89105{
    90106        (void) data;
    … …  
    94110{
    95111        int scan_code = IPC_GET_ARG2(*call);
    96         kbd_push_scancode(scan_code);
     112        kbd_push_scancode(kbd_dev, scan_code);
    97113}
    98114

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2008 Pavel Rimsky
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4647#include <errno.h>
    4748
     49static int niagara_port_init(kbd_dev_t *);
     50static void niagara_port_yield(void);
     51static void niagara_port_reclaim(void);
     52static void niagara_port_write(uint8_t data);
     53
     54kbd_port_ops_t niagara_port = {
     55        .init = niagara_port_init,
     56        .yield = niagara_port_yield,
     57        .reclaim = niagara_port_reclaim,
     58        .write = niagara_port_write
     59};
     60
     61static kbd_dev_t *kbd_dev;
     62
    4863#define POLL_INTERVAL  10000
    4964
    … …  
    7085
    7186/* virtual address of the shared buffer */
    72 input_buffer_t input_buffer;
     87static input_buffer_t input_buffer;
    7388
    7489static volatile bool polling_disabled = false;
    … …  
    7994 * Maps the shared buffer and creates the polling thread.
    8095 */
    81 int kbd_port_init(void)
     96static int niagara_port_init(kbd_dev_t *kdev)
    8297{
     98        kbd_dev = kdev;
     99       
    83100        sysarg_t paddr;
    84101        if (sysinfo_get_value("niagara.inbuf.address", &paddr) != EOK)
    … …  
    105122}
    106123
    107 void kbd_port_yield(void)
     124static void niagara_port_yield(void)
    108125{
    109126        polling_disabled = true;
    110127}
    111128
    112 void kbd_port_reclaim(void)
     129static void niagara_port_reclaim(void)
    113130{
    114131        polling_disabled = false;
    115132}
    116133
    117 void kbd_port_write(uint8_t data)
     134static void niagara_port_write(uint8_t data)
    118135{
    119136        (void) data;
    … …  
    132149                input_buffer->read_ptr =
    133150                        ((input_buffer->read_ptr) + 1) % INPUT_BUFFER_SIZE;
    134                 kbd_push_scancode(c);
     151                kbd_push_scancode(kbd_dev, c);
    135152        }
    136153}

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2006 Josef Cejka
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    3940#include <async_obsolete.h>
    4041#include <sysinfo.h>
     42#include <input.h>
    4143#include <kbd.h>
    4244#include <kbd_port.h>
    43 #include <sun.h>
    4445#include <ddi.h>
    4546#include <errno.h>
     47
     48static int ns16550_port_init(kbd_dev_t *);
     49static void ns16550_port_yield(void);
     50static void ns16550_port_reclaim(void);
     51static void ns16550_port_write(uint8_t data);
     52
     53kbd_port_ops_t ns16550_port = {
     54        .init = ns16550_port_init,
     55        .yield = ns16550_port_yield,
     56        .reclaim = ns16550_port_reclaim,
     57        .write = ns16550_port_write
     58};
     59
     60static kbd_dev_t *kbd_dev;
    4661
    4762/* NS16550 registers */
    … …  
    91106
    92107static uintptr_t ns16550_physical;
    93 static uintptr_t ns16550_kernel; 
     108static uintptr_t ns16550_kernel;
    94109
    95 int ns16550_port_init(void)
     110static kbd_dev_t *kbd_dev;
     111
     112static int ns16550_port_init(kbd_dev_t *kdev)
    96113{
    97114        void *vaddr;
    98 
     115       
     116        kbd_dev = kdev;
     117       
     118        sysarg_t ns16550;
     119        if (sysinfo_get_value("kbd.type.ns16550", &ns16550) != EOK)
     120                return -1;
     121        if (!ns16550)
     122                return -1;
     123       
    99124        if (sysinfo_get_value("kbd.address.physical", &ns16550_physical) != EOK)
    100125                return -1;
    … …  
    116141}
    117142
     143static void ns16550_port_yield(void)
     144{
     145}
     146
     147static void ns16550_port_reclaim(void)
     148{
     149}
     150
     151static void ns16550_port_write(uint8_t data)
     152{
     153        (void) data;
     154}
     155
    118156static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    119157{
    120158        int scan_code = IPC_GET_ARG2(*call);
    121         kbd_push_scancode(scan_code);
     159        kbd_push_scancode(kbd_dev, scan_code);
    122160       
    123161        if (irc_service)

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2009 Vineeth Pillai
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4647#include <errno.h>
    4748
     49static int pl050_port_init(kbd_dev_t *);
     50static void pl050_port_yield(void);
     51static void pl050_port_reclaim(void);
     52static void pl050_port_write(uint8_t data);
     53
     54kbd_port_ops_t pl050_port = {
     55        .init = pl050_port_init,
     56        .yield = pl050_port_yield,
     57        .reclaim = pl050_port_reclaim,
     58        .write = pl050_port_write
     59};
     60
     61static kbd_dev_t *kbd_dev;
     62
    4863#define PL050_STAT_RXFULL  (1 << 4)
    4964
    … …  
    8297static void pl050_irq_handler(ipc_callid_t iid, ipc_call_t *call);
    8398
    84 int kbd_port_init(void)
     99static int pl050_port_init(kbd_dev_t *kdev)
    85100{
     101        kbd_dev = kdev;
     102       
    86103        sysarg_t addr;
    87104        if (sysinfo_get_value("kbd.address.status", &addr) != EOK)
    … …  
    105122}
    106123
    107 void kbd_port_yield(void)
     124static void pl050_port_yield(void)
    108125{
    109126}
    110127
    111 void kbd_port_reclaim(void)
     128static void pl050_port_reclaim(void)
    112129{
    113130}
    114131
    115 void kbd_port_write(uint8_t data)
     132static void pl050_port_write(uint8_t data)
    116133{
    117134        (void) data;
    … …  
    122139        int scan_code = IPC_GET_ARG2(*call);
    123140
    124         kbd_push_scancode(scan_code);
     141        kbd_push_scancode(kbd_dev, scan_code);
    125142        return;
    126143}

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2008 Pavel Rimsky
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4647#include <errno.h>
    4748
     49static int sgcn_port_init(kbd_dev_t *);
     50static void sgcn_port_yield(void);
     51static void sgcn_port_reclaim(void);
     52static void sgcn_port_write(uint8_t data);
     53
     54kbd_port_ops_t sgcn_port = {
     55        .init = sgcn_port_init,
     56        .yield = sgcn_port_yield,
     57        .reclaim = sgcn_port_reclaim,
     58        .write = sgcn_port_write
     59};
     60
     61static kbd_dev_t *kbd_dev;
     62
    4863#define POLL_INTERVAL  10000
    4964
    … …  
    101116 * Maps the physical memory (SRAM) and creates the polling thread.
    102117 */
    103 int kbd_port_init(void)
    104 {
     118static int sgcn_port_init(kbd_dev_t *kdev)
     119{
     120        kbd_dev = kdev;
     121       
    105122        sysarg_t sram_paddr;
    106123        if (sysinfo_get_value("sram.address.physical", &sram_paddr) != EOK)
    … …  
    130147}
    131148
    132 void kbd_port_yield(void)
     149static void sgcn_port_yield(void)
    133150{
    134151        polling_disabled = true;
    135152}
    136153
    137 void kbd_port_reclaim(void)
     154static void sgcn_port_reclaim(void)
    138155{
    139156        polling_disabled = false;
    140157}
    141158
    142 void kbd_port_write(uint8_t data)
     159static void sgcn_port_write(uint8_t data)
    143160{
    144161        (void) data;
    … …  
    167184                buf_ptr = (volatile char *)
    168185                        SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
    169                 kbd_push_scancode(c);
     186                kbd_push_scancode(kbd_dev, c);
    170187        }
    171188}

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2005 Jakub Jermar
    3  * Copyright (c) 2009 Jiri Svoboda
     3 * Copyright (c) 2011 Jiri Svoboda
    44 * All rights reserved.
    55 *
    … …  
    4545#include <bool.h>
    4646
     47static int ski_port_init(kbd_dev_t *);
     48static void ski_port_yield(void);
     49static void ski_port_reclaim(void);
     50static void ski_port_write(uint8_t data);
     51
     52kbd_port_ops_t ski_port = {
     53        .init = ski_port_init,
     54        .yield = ski_port_yield,
     55        .reclaim = ski_port_reclaim,
     56        .write = ski_port_write
     57};
     58
     59static kbd_dev_t *kbd_dev;
     60
    4761#define SKI_GETCHAR             21
    4862
    … …  
    5569
    5670/** Initialize Ski port driver. */
    57 int kbd_port_init(void)
     71static int ski_port_init(kbd_dev_t *kdev)
    5872{
    5973        thread_id_t tid;
    6074        int rc;
     75
     76        kbd_dev = kdev;
    6177
    6278        rc = thread_create(ski_thread_impl, NULL, "kbd_poll", &tid);
    … …  
    6884}
    6985
    70 void kbd_port_yield(void)
     86static void ski_port_yield(void)
    7187{
    7288        polling_disabled = true;
    7389}
    7490
    75 void kbd_port_reclaim(void)
     91static void ski_port_reclaim(void)
    7692{
    7793        polling_disabled = false;
    7894}
    7995
    80 void kbd_port_write(uint8_t data)
     96static void ski_port_write(uint8_t data)
    8197{
    8298        (void) data;
    … …  
    94110                        if (c == 0)
    95111                                break;
    96                         kbd_push_scancode(c);
     112                        kbd_push_scancode(kbd_dev, c);
    97113                }
    98114
    … …  
    112128        uint64_t ch;
    113129       
     130#ifdef UARCH_ia64
    114131        asm volatile (
    115132                "mov r15 = %1\n"
    … …  
    121138                : "r15", "r8"
    122139        );
    123 
     140#else
     141        ch = 0;
     142#endif
    124143        return (int32_t) ch;
    125144}

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

    rdf8110d3 rd900699  
    11/*
    22 * Copyright (c) 2006 Martin Decky
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    3940#include <async_obsolete.h>
    4041#include <sysinfo.h>
     42#include <input.h>
    4143#include <kbd.h>
    4244#include <kbd_port.h>
    43 #include <sun.h>
    4445#include <sys/types.h>
    4546#include <ddi.h>
    4647#include <errno.h>
     48
     49static int z8530_port_init(kbd_dev_t *);
     50static void z8530_port_yield(void);
     51static void z8530_port_reclaim(void);
     52static void z8530_port_write(uint8_t data);
     53
     54kbd_port_ops_t z8530_port = {
     55        .init = z8530_port_init,
     56        .yield = z8530_port_yield,
     57        .reclaim = z8530_port_reclaim,
     58        .write = z8530_port_write
     59};
     60
     61static kbd_dev_t *kbd_dev;
    4762
    4863#define CHAN_A_STATUS  4
    … …  
    7792        }
    7893};
    79        
    80 irq_code_t z8530_kbd = {
     94
     95static irq_code_t z8530_kbd = {
    8196        sizeof(z8530_cmds) / sizeof(irq_cmd_t),
    8297        z8530_cmds
    … …  
    85100static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call);
    86101
    87 int z8530_port_init(void)
     102static int z8530_port_init(kbd_dev_t *kdev)
    88103{
     104        kbd_dev = kdev;
     105       
     106        sysarg_t z8530;
     107        if (sysinfo_get_value("kbd.type.z8530", &z8530) != EOK)
     108                return -1;
     109        if (!z8530)
     110                return -1;
     111       
    89112        sysarg_t kaddr;
    90113        if (sysinfo_get_value("kbd.address.kernel", &kaddr) != EOK)
    … …  
    104127}
    105128
     129static void z8530_port_yield(void)
     130{
     131}
     132
     133static void z8530_port_reclaim(void)
     134{
     135}
     136
     137static void z8530_port_write(uint8_t data)
     138{
     139        (void) data;
     140}
     141
    106142static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    107143{
    108144        int scan_code = IPC_GET_ARG2(*call);
    109         kbd_push_scancode(scan_code);
     145        kbd_push_scancode(kbd_dev, scan_code);
    110146       
    111147        if (irc_service)

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

    rdf8110d3 rd900699  
    7373static s3c24xx_ts_t *ts;
    7474
    75 static void s3c24xx_ts_connection(ipc_callid_t iid, ipc_call_t *icall);
     75static void s3c24xx_ts_connection(ipc_callid_t iid, ipc_call_t *icall,
     76    void *arg);
    7677static void s3c24xx_ts_irq_handler(ipc_callid_t iid, ipc_call_t *call);
    7778static void s3c24xx_ts_pen_down(s3c24xx_ts_t *ts);
    … …  
    373374
    374375/** Handle mouse client connection. */
    375 static void s3c24xx_ts_connection(ipc_callid_t iid, ipc_call_t *icall)
     376static void s3c24xx_ts_connection(ipc_callid_t iid, ipc_call_t *icall,
     377    void *arg)
    376378{
    377379        ipc_callid_t callid;
Note: See TracChangeset for help on using the changeset viewer.