Changeset b0f00a9 in mainline for uspace/srv/hid/input/port


Ignore:
Timestamp:
2011-11-06T22:21:05Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
898e847
Parents:
2bdf8313 (diff), 7b5f4c9 (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/input/port
Files:
1 added
13 moved

Legend:

Unmodified
Added
Removed

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

    r2bdf8313 rb0f00a9  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3030 * @ingroup kbd
    3131 * @{
    32  */ 
     32 */
    3333/** @file
    3434 * @brief ADB keyboard port driver.
    … …  
    3737#include <ipc/adb.h>
    3838#include <async.h>
     39#include <input.h>
    3940#include <kbd_port.h>
    4041#include <kbd.h>
    … …  
    4243#include <fcntl.h>
    4344#include <errno.h>
     45#include <loc.h>
    4446
    45 static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall);
     47static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    4648static void adb_kbd_reg0_data(uint16_t data);
    4749
    48 static int dev_phone;
     50static int adb_port_init(kbd_dev_t *);
     51static void adb_port_yield(void);
     52static void adb_port_reclaim(void);
     53static void adb_port_write(uint8_t data);
    4954
    50 #define NAME "kbd"
     55kbd_port_ops_t adb_port = {
     56        .init = adb_port_init,
     57        .yield = adb_port_yield,
     58        .reclaim = adb_port_reclaim,
     59        .write = adb_port_write
     60};
    5161
    52 int kbd_port_init(void)
     62static kbd_dev_t *kbd_dev;
     63static async_sess_t *dev_sess;
     64
     65static int adb_port_init(kbd_dev_t *kdev)
    5366{
    54         const char *input = "/dev/adb/kbd";
    55         int input_fd;
    56 
    57         printf(NAME ": open %s\n", input);
    58 
    59         input_fd = open(input, O_RDONLY);
    60         if (input_fd < 0) {
    61                 printf(NAME ": Failed opening %s (%d)\n", input, input_fd);
    62                 return false;
     67        const char *dev = "adb/kbd";
     68        service_id_t service_id;
     69        async_exch_t *exch;
     70        int rc;
     71       
     72        kbd_dev = kdev;
     73       
     74        rc = loc_service_get_id(dev, &service_id, 0);
     75        if (rc != EOK)
     76                return rc;
     77       
     78        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
     79        if (dev_sess == NULL) {
     80                printf("%s: Failed to connect to device\n", NAME);
     81                return ENOENT;
    6382        }
    64 
    65         dev_phone = fd_phone(input_fd);
    66         if (dev_phone < 0) {
    67                 printf(NAME ": Failed to connect to device\n");
    68                 return false;
     83       
     84        exch = async_exchange_begin(dev_sess);
     85        if (exch == NULL) {
     86                printf("%s: Failed starting exchange with device\n", NAME);
     87                async_hangup(dev_sess);
     88                return ENOMEM;
    6989        }
    70 
     90       
    7191        /* NB: The callback connection is slotted for removal */
    72         if (async_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events) != 0) {
    73                 printf(NAME ": Failed to create callback from device\n");
    74                 return false;
     92        rc = async_connect_to_me(exch, 0, 0, 0, kbd_port_events, NULL);
     93        async_exchange_end(exch);
     94        if (rc != EOK) {
     95                printf("%s: Failed to create callback from device\n", NAME);
     96                async_hangup(dev_sess);
     97                return rc;
    7598        }
    76 
    77         return 0;
     99       
     100        return EOK;
    78101}
    79102
    80 void kbd_port_yield(void)
     103static void adb_port_yield(void)
    81104{
    82105}
    83106
    84 void kbd_port_reclaim(void)
     107static void adb_port_reclaim(void)
    85108{
    86109}
    87110
    88 void kbd_port_write(uint8_t data)
     111static void adb_port_write(uint8_t data)
    89112{
    90113        /*async_msg_1(dev_phone, CHAR_WRITE_BYTE, data);*/
    91114}
    92115
    93 static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall)
     116static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    94117{
    95118        /* Ignore parameters, the connection is already opened */
    … …  
    100123
    101124                int retval;
    102 
    103                 switch (IPC_GET_IMETHOD(call)) {
    104                 case IPC_M_PHONE_HUNGUP:
     125               
     126                if (!IPC_GET_IMETHOD(call)) {
    105127                        /* TODO: Handle hangup */
    106128                        return;
     129                }
     130               
     131                switch (IPC_GET_IMETHOD(call)) {
    107132                case ADB_REG_NOTIF:
    108133                        adb_kbd_reg0_data(IPC_GET_ARG1(call));
    … …  
    117142static void adb_kbd_reg0_data(uint16_t data)
    118143{
    119         uint8_t b0, b1;
    120 
    121         b0 = (data >> 8) & 0xff;
    122         b1 = data & 0xff;
    123 
     144        uint8_t b0 = (data >> 8) & 0xff;
     145        uint8_t b1 = data & 0xff;
     146       
    124147        if (b0 != 0xff)
    125                 kbd_push_scancode(b0);
     148                kbd_push_data(kbd_dev, b0);
     149       
    126150        if (b1 != 0xff)
    127                 kbd_push_scancode(b1);
     151                kbd_push_data(kbd_dev, b1);
    128152}
    129153

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

    r2bdf8313 rb0f00a9  
    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>
     43#include <loc.h>
     44#include <stdio.h>
    4145
    42 #include <char_mouse.h>
    43 #include <mouse_port.h>
     46static mouse_dev_t *mouse_dev;
     47static async_sess_t *dev_sess;
    4448
    45 static void chardev_events(ipc_callid_t iid, ipc_call_t *icall);
    46 
    47 static int dev_phone;
    48 
    49 #define NAME "char_mouse"
    50 
    51 int mouse_port_init(void)
    52 {
    53         const char *input = "/dev/char/ps2b";
    54         int input_fd;
    55 
    56         printf(NAME ": open %s\n", input);
    57 
    58         input_fd = open(input, O_RDONLY);
    59         if (input_fd < 0) {
    60                 printf(NAME ": Failed opening %s (%d)\n", input, input_fd);
    61                 return false;
    62         }
    63 
    64         dev_phone = fd_phone(input_fd);
    65         if (dev_phone < 0) {
    66                 printf(NAME ": Failed to connect to device\n");
    67                 return false;
    68         }
    69 
    70         /* NB: The callback connection is slotted for removal */
    71         if (async_connect_to_me(dev_phone, 0, 0, 0, chardev_events) != 0) {
    72                 printf(NAME ": Failed to create callback from device\n");
    73                 return false;
    74         }
    75 
    76         return 0;
    77 }
    78 
    79 void mouse_port_yield(void)
    80 {
    81 }
    82 
    83 void mouse_port_reclaim(void)
    84 {
    85 }
    86 
    87 void mouse_port_write(uint8_t data)
    88 {
    89         async_msg_1(dev_phone, CHAR_WRITE_BYTE, data);
    90 }
    91 
    92 static void chardev_events(ipc_callid_t iid, ipc_call_t *icall)
     49static void mouse_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    9350{
    9451        /* Ignore parameters, the connection is already opened */
    9552        while (true) {
    96 
    9753                ipc_call_t call;
    9854                ipc_callid_t callid = async_get_call(&call);
    99 
     55               
    10056                int retval;
    101 
    102                 switch (IPC_GET_IMETHOD(call)) {
    103                 case IPC_M_PHONE_HUNGUP:
     57               
     58                if (!IPC_GET_IMETHOD(call)) {
    10459                        /* TODO: Handle hangup */
    10560                        return;
    106                 case IPC_FIRST_USER_METHOD:
    107                         mouse_handle_byte(IPC_GET_ARG1(call));
     61                }
     62               
     63                switch (IPC_GET_IMETHOD(call)) {
     64                case ADB_REG_NOTIF:
     65                        mouse_push_data(mouse_dev, IPC_GET_ARG1(call));
    10866                        break;
    10967                default:
    11068                        retval = ENOENT;
    11169                }
     70               
    11271                async_answer_0(callid, retval);
    11372        }
    11473}
    11574
     75static int adb_port_init(mouse_dev_t *mdev)
     76{
     77        const char *dev = "adb/mouse";
     78       
     79        mouse_dev = mdev;
     80       
     81        service_id_t service_id;
     82        int rc = loc_service_get_id(dev, &service_id, 0);
     83        if (rc != EOK)
     84                return rc;
     85       
     86        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
     87        if (dev_sess == NULL) {
     88                printf("%s: Failed to connect to device\n", NAME);
     89                return ENOENT;
     90        }
     91       
     92        async_exch_t *exch = async_exchange_begin(dev_sess);
     93        if (exch == NULL) {
     94                printf("%s: Failed starting exchange with device\n", NAME);
     95                async_hangup(dev_sess);
     96                return ENOMEM;
     97        }
     98       
     99        /* NB: The callback connection is slotted for removal */
     100        rc = async_connect_to_me(exch, 0, 0, 0, mouse_port_events, NULL);
     101        async_exchange_end(exch);
     102        if (rc != EOK) {
     103                printf("%s: Failed to create callback from device\n", NAME);
     104                async_hangup(dev_sess);
     105                return rc;
     106        }
     107       
     108        return EOK;
     109}
     110
     111static void adb_port_yield(void)
     112{
     113}
     114
     115static void adb_port_reclaim(void)
     116{
     117}
     118
     119static void adb_port_write(uint8_t data)
     120{
     121}
     122
     123mouse_port_ops_t adb_mouse_port = {
     124        .init = adb_port_init,
     125        .yield = adb_port_yield,
     126        .reclaim = adb_port_reclaim,
     127        .write = adb_port_write
     128};
     129
    116130/**
    117131 * @}

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

    r2bdf8313 rb0f00a9  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3030 * @ingroup kbd
    3131 * @{
    32  */ 
     32 */
    3333/** @file
    3434 * @brief Chardev keyboard port driver.
    … …  
    3737#include <ipc/char.h>
    3838#include <async.h>
     39#include <input.h>
    3940#include <kbd_port.h>
    4041#include <kbd.h>
    41 #include <vfs/vfs.h>
    42 #include <sys/stat.h>
    43 #include <fcntl.h>
     42#include <loc.h>
    4443#include <errno.h>
     44#include <stdio.h>
    4545
    46 static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall);
     46static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    4747
    48 static int dev_phone;
     48static int chardev_port_init(kbd_dev_t *);
     49static void chardev_port_yield(void);
     50static void chardev_port_reclaim(void);
     51static void chardev_port_write(uint8_t data);
    4952
    50 #define NAME "kbd"
     53kbd_port_ops_t chardev_port = {
     54        .init = chardev_port_init,
     55        .yield = chardev_port_yield,
     56        .reclaim = chardev_port_reclaim,
     57        .write = chardev_port_write
     58};
     59
     60static kbd_dev_t *kbd_dev;
     61static async_sess_t *dev_sess;
    5162
    5263/** List of devices to try connecting to. */
    5364static const char *in_devs[] = {
    54         "/dev/char/ps2a",
    55         "/dev/char/s3c24ser"
     65        "char/ps2a",
     66        "char/s3c24ser"
    5667};
    5768
    58 static const int num_devs = sizeof(in_devs) / sizeof(in_devs[0]);
     69static const unsigned int num_devs = sizeof(in_devs) / sizeof(in_devs[0]);
    5970
    60 int kbd_port_init(void)
     71static int chardev_port_init(kbd_dev_t *kdev)
    6172{
    62         int input_fd;
    63         int i;
    64 
    65         input_fd = -1;
     73        service_id_t service_id;
     74        async_exch_t *exch;
     75        unsigned int i;
     76        int rc;
     77       
     78        kbd_dev = kdev;
     79       
    6680        for (i = 0; i < num_devs; i++) {
    67                 struct stat s;
    68 
    69                 if (stat(in_devs[i], &s) == EOK)
     81                rc = loc_service_get_id(in_devs[i], &service_id, 0);
     82                if (rc == EOK)
    7083                        break;
    7184        }
    72 
     85       
    7386        if (i >= num_devs) {
    74                 printf(NAME ": Could not find any suitable input device.\n");
     87                printf("%s: Could not find any suitable input device\n", NAME);
    7588                return -1;
    7689        }
    77 
    78         input_fd = open(in_devs[i], O_RDONLY);
    79         if (input_fd < 0) {
    80                 printf(NAME ": failed opening device %s (%d).\n", in_devs[i],
    81                     input_fd);
     90       
     91        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id,
     92            IPC_FLAG_BLOCKING);
     93        if (dev_sess == NULL) {
     94                printf("%s: Failed connecting to device\n", NAME);
     95                return ENOENT;
     96        }
     97       
     98        exch = async_exchange_begin(dev_sess);
     99        if (exch == NULL) {
     100                printf("%s: Failed starting exchange with device\n", NAME);
     101                async_hangup(dev_sess);
     102                return ENOMEM;
     103        }
     104       
     105        /* NB: The callback connection is slotted for removal */
     106        rc = async_connect_to_me(exch, 0, 0, 0, kbd_port_events, NULL);
     107        async_exchange_end(exch);
     108       
     109        if (rc != 0) {
     110                printf("%s: Failed to create callback from device\n", NAME);
     111                async_hangup(dev_sess);
    82112                return -1;
    83113        }
    84 
    85         dev_phone = fd_phone(input_fd);
    86         if (dev_phone < 0) {
    87                 printf(NAME ": Failed connecting to device\n");
    88                 return -1;
    89         }
    90 
    91         /* NB: The callback connection is slotted for removal */
    92         if (async_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events) != 0) {
    93                 printf(NAME ": Failed to create callback from device\n");
    94                 return -1;
    95         }
    96 
     114       
    97115        return 0;
    98116}
    99117
    100 void kbd_port_yield(void)
     118static void chardev_port_yield(void)
    101119{
    102120}
    103121
    104 void kbd_port_reclaim(void)
     122static void chardev_port_reclaim(void)
    105123{
    106124}
    107125
    108 void kbd_port_write(uint8_t data)
     126static void chardev_port_write(uint8_t data)
    109127{
    110         async_msg_1(dev_phone, CHAR_WRITE_BYTE, data);
     128        async_exch_t *exch = async_exchange_begin(dev_sess);
     129        if (exch == NULL) {
     130                printf("%s: Failed starting exchange with device\n", NAME);
     131                return;
     132        }
     133
     134        async_msg_1(exch, CHAR_WRITE_BYTE, data);
     135        async_exchange_end(exch);
    111136}
    112137
    113 static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall)
     138static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    114139{
    115140        /* Ignore parameters, the connection is already opened */
    … …  
    118143                ipc_call_t call;
    119144                ipc_callid_t callid = async_get_call(&call);
     145               
     146                if (!IPC_GET_IMETHOD(call)) {
     147                        /* TODO: Handle hangup */
     148                        return;
     149                }
    120150
    121151                int retval;
    122152
    123153                switch (IPC_GET_IMETHOD(call)) {
    124                 case IPC_M_PHONE_HUNGUP:
    125                         /* TODO: Handle hangup */
    126                         return;
    127154                case CHAR_NOTIF_BYTE:
    128                         kbd_push_scancode(IPC_GET_ARG1(call));
     155                        kbd_push_data(kbd_dev, IPC_GET_ARG1(call));
    129156                        break;
    130157                default:

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

    r2bdf8313 rb0f00a9  
    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;
    … …  
    91108
    92109/** Process data sent when a key is pressed.
    93  * 
    94  *  @param keybuffer Buffer of pressed keys.
    95  *  @param call      IPC call.
    96110 *
    97  *  @return Always 1.
     111 * @param keybuffer Buffer of pressed keys.
     112 * @param call      IPC call.
     113 *
    98114 */
    99115static void gxemul_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    100116{
    101         int scan_code = IPC_GET_ARG2(*call);
    102 
    103         kbd_push_scancode(scan_code);
     117        kbd_push_data(kbd_dev, IPC_GET_ARG2(*call));
    104118}
    105119

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

    r2bdf8313 rb0f00a9  
    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;
    … …  
    93109static void msim_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    94110{
    95         int scan_code = IPC_GET_ARG2(*call);
    96         kbd_push_scancode(scan_code);
     111        kbd_push_data(kbd_dev, IPC_GET_ARG2(*call));
    97112}
    98113
    99114/** @}
    100 */
     115 */

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

    r2bdf8313 rb0f00a9  
    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;
    … …  
    131148                c = input_buffer->data[input_buffer->read_ptr];
    132149                input_buffer->read_ptr =
    133                         ((input_buffer->read_ptr) + 1) % INPUT_BUFFER_SIZE;
    134                 kbd_push_scancode(c);
     150                    ((input_buffer->read_ptr) + 1) % INPUT_BUFFER_SIZE;
     151                kbd_push_data(kbd_dev, c);
    135152        }
    136153}
    137154
    138155/**
    139  * Thread to poll SGCN for keypresses.
     156 * Thread to poll Niagara console for keypresses.
    140157 */
    141158static void niagara_thread_impl(void *arg)

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

    r2bdf8313 rb0f00a9  
    11/*
    22 * Copyright (c) 2006 Josef Cejka
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    3839#include <async.h>
    3940#include <sysinfo.h>
     41#include <input.h>
    4042#include <kbd.h>
    4143#include <kbd_port.h>
    42 #include <sun.h>
    4344#include <ddi.h>
    4445#include <errno.h>
     46
     47static int ns16550_port_init(kbd_dev_t *);
     48static void ns16550_port_yield(void);
     49static void ns16550_port_reclaim(void);
     50static void ns16550_port_write(uint8_t data);
     51
     52kbd_port_ops_t ns16550_port = {
     53        .init = ns16550_port_init,
     54        .yield = ns16550_port_yield,
     55        .reclaim = ns16550_port_reclaim,
     56        .write = ns16550_port_write
     57};
     58
     59static kbd_dev_t *kbd_dev;
    4560
    4661/* NS16550 registers */
    … …  
    90105
    91106static uintptr_t ns16550_physical;
    92 static uintptr_t ns16550_kernel; 
     107static uintptr_t ns16550_kernel;
    93108
    94 int ns16550_port_init(void)
     109static kbd_dev_t *kbd_dev;
     110
     111static int ns16550_port_init(kbd_dev_t *kdev)
    95112{
    96113        void *vaddr;
    97 
     114       
     115        kbd_dev = kdev;
     116       
     117        sysarg_t ns16550;
     118        if (sysinfo_get_value("kbd.type.ns16550", &ns16550) != EOK)
     119                return -1;
     120        if (!ns16550)
     121                return -1;
     122       
    98123        if (sysinfo_get_value("kbd.address.physical", &ns16550_physical) != EOK)
    99124                return -1;
    … …  
    115140}
    116141
     142static void ns16550_port_yield(void)
     143{
     144}
     145
     146static void ns16550_port_reclaim(void)
     147{
     148}
     149
     150static void ns16550_port_write(uint8_t data)
     151{
     152        (void) data;
     153}
     154
    117155static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    118156{
    119         int scan_code = IPC_GET_ARG2(*call);
    120         kbd_push_scancode(scan_code);
     157        kbd_push_data(kbd_dev, IPC_GET_ARG2(*call));
    121158       
    122         if (irc_service)
    123                 async_msg_1(irc_phone, IRC_CLEAR_INTERRUPT,
    124                     IPC_GET_IMETHOD(*call));
     159        if (irc_service) {
     160                async_exch_t *exch = async_exchange_begin(irc_sess);
     161                async_msg_1(exch, IRC_CLEAR_INTERRUPT, IPC_GET_IMETHOD(*call));
     162                async_exchange_end(exch);
     163        }
    125164}
    126165

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

    r2bdf8313 rb0f00a9  
    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;
    … …  
    120137static void pl050_irq_handler(ipc_callid_t iid, ipc_call_t *call)
    121138{
    122         int scan_code = IPC_GET_ARG2(*call);
    123 
    124         kbd_push_scancode(scan_code);
    125         return;
     139        kbd_push_data(kbd_dev, IPC_GET_ARG2(*call));
    126140}
    127141
    128142/**
    129143 * @}
    130  */ 
     144 */

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

    r2bdf8313 rb0f00a9  
    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_data(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}
Note: See TracChangeset for help on using the changeset viewer.