Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 15c5418 in mainline


Ignore:
Timestamp:
2017-11-18T20:06:15Z (4 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
75fcf9b
Parents:
efb9fd08
Message:

chardev_open, chardev_close.

Location:
uspace
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/hid/adb-kbd/adb-kbd.c

    refb9fd08 r15c5418  
    3434#include <ddf/log.h>
    3535#include <errno.h>
     36#include <io/chardev.h>
    3637#include <io/console.h>
    3738#include <ipc/adb.h>
  • uspace/drv/hid/atkbd/atkbd.c

    refb9fd08 r15c5418  
    11/*
     2 * Copyright (c) 2017 Jiri Svoboda
    23 * Copyright (c) 2011 Jan Vesely
    34 * Copyright (c) 2009 Vineeth Pillai
     
    201202static int polling(void *arg)
    202203{
    203         const at_kbd_t *kbd = arg;
    204        
    205         assert(kbd);
    206         assert(kbd->parent_sess);
    207        
    208         async_exch_t *parent_exch = async_exchange_begin(kbd->parent_sess);
     204        at_kbd_t *kbd = arg;
    209205       
    210206        while (true) {
    211                 if (!parent_exch)
    212                         parent_exch = async_exchange_begin(kbd->parent_sess);
    213 
    214207                uint8_t code = 0;
    215                 ssize_t size = chardev_read(parent_exch, &code, 1);
     208                ssize_t size = chardev_read(kbd->chardev, &code, 1);
    216209                if (size != 1)
    217210                        return EIO;
     
    224217                        map_size = sizeof(scanmap_e0) / sizeof(unsigned int);
    225218                       
    226                         size = chardev_read(parent_exch, &code, 1);
     219                        size = chardev_read(kbd->chardev, &code, 1);
    227220                        if (size != 1)
    228221                                return EIO;
    229222                } else if (code == KBD_SCANCODE_SET_EXTENDED_SPECIAL) {
    230                         size = chardev_read(parent_exch, &code, 1);
     223                        size = chardev_read(kbd->chardev, &code, 1);
    231224                        if (size != 1)
    232225                                return EIO;
     
    234227                                continue;
    235228
    236                         size = chardev_read(parent_exch, &code, 1);
     229                        size = chardev_read(kbd->chardev, &code, 1);
    237230                        if (size != 1)
    238231                                return EIO;
     
    240233                                continue;
    241234
    242                         size = chardev_read(parent_exch, &code, 1);
     235                        size = chardev_read(kbd->chardev, &code, 1);
    243236                        if (size != 1)
    244237                                return EIO;
     
    246239                                continue;
    247240
    248                         size = chardev_read(parent_exch, &code, 1);
     241                        size = chardev_read(kbd->chardev, &code, 1);
    249242                        if (size != 1)
    250243                                return EIO;
     
    252245                                continue;
    253246
    254                         size = chardev_read(parent_exch, &code, 1);
     247                        size = chardev_read(kbd->chardev, &code, 1);
    255248                        if (size != 1)
    256249                                return EIO;
     
    258251                                continue;
    259252
    260                         size = chardev_read(parent_exch, &code, 1);
     253                        size = chardev_read(kbd->chardev, &code, 1);
    261254                        if (size != 1)
    262255                                return EIO;
     
    264257                                continue;
    265258
    266                         size = chardev_read(parent_exch, &code, 1);
     259                        size = chardev_read(kbd->chardev, &code, 1);
    267260                        if (size != 1)
    268261                                return EIO;
     
    279272                if (code == KBD_SCANCODE_KEY_RELEASE) {
    280273                        type = KEY_RELEASE;
    281                         size = chardev_read(parent_exch, &code, 1);
     274                        size = chardev_read(kbd->chardev, &code, 1);
    282275                        if (size != 1)
    283276                                return EIO;
     
    362355int at_kbd_init(at_kbd_t *kbd, ddf_dev_t *dev)
    363356{
     357        async_sess_t *parent_sess;
     358        int rc;
     359       
    364360        assert(kbd);
    365361        assert(dev);
    366362       
    367363        kbd->client_sess = NULL;
    368         kbd->parent_sess = ddf_dev_parent_sess_get(dev);
    369        
    370         if (!kbd->parent_sess) {
     364        parent_sess = ddf_dev_parent_sess_get(dev);
     365        if (parent_sess == NULL) {
    371366                ddf_msg(LVL_ERROR, "Failed creating parent session.");
     367                rc = EIO;
     368                goto error;
     369        }
     370       
     371        rc = chardev_open(parent_sess, &kbd->chardev);
     372        if (rc != EOK) {
     373                ddf_msg(LVL_ERROR, "Failed opening character device.");
    372374                return EIO;
    373375        }
     
    407409        fibril_add_ready(kbd->polling_fibril);
    408410        return EOK;
     411error:
     412        chardev_close(kbd->chardev);
     413        kbd->chardev = NULL;
     414        return rc;
    409415}
  • uspace/drv/hid/atkbd/atkbd.h

    refb9fd08 r15c5418  
    11/*
    22 * Copyright (c) 2011 Jan Vesely
     3 * Copyright (c) 2017 Jiri Svoboda
    34 * All rights reserved.
    45 *
     
    3435 */
    3536
    36 #ifndef _AT_KBD_H_
    37 #define _AT_KBD_H_
     37#ifndef AT_KBD_H_
     38#define AT_KBD_H_
    3839
    3940#include <ddf/driver.h>
    4041#include <fibril.h>
     42#include <io/chardev.h>
    4143
    4244/** PC/AT keyboard driver structure. */
    4345typedef struct {
    44         ddf_fun_t *kbd_fun;        /**< Keyboard function. */
    45         async_sess_t *parent_sess; /**< Connection to device providing data. */
    46         async_sess_t *client_sess; /**< Callback connection to client. */
    47         fid_t polling_fibril;      /**< Fibril retrieving an parsing data. */
     46        /** Keyboard function */
     47        ddf_fun_t *kbd_fun;
     48        /** Device providing keyboard connection */
     49        chardev_t *chardev;
     50        /** Callback connection to client */
     51        async_sess_t *client_sess;
     52        /** Fibril retrieving and parsing data */
     53        fid_t polling_fibril;
    4854} at_kbd_t;
    4955
  • uspace/drv/hid/ps2mouse/main.c

    refb9fd08 r15c5418  
    3030 */
    3131/** @file
    32  * @brief ps/2 mouse driver
     32 * @brief PS/2 mouse driver
    3333 */
    3434
  • uspace/drv/hid/ps2mouse/ps2mouse.c

    refb9fd08 r15c5418  
    11/*
    22 * Copyright (c) 2011 Jan Vesely
     3 * Copyright (c) 2017 Jiri Svoboda
    34 * All rights reserved.
    45 *
     
    3031 */
    3132/** @file
    32  * @brief ps2 mouse driver.
     33 * @brief PS/2 mouse driver.
    3334 */
    3435
     
    7071#define PS2_BUTTON_MASK(button) (1 << button)
    7172
    72 #define MOUSE_READ_BYTE_TEST(sess, value_) \
     73#define MOUSE_READ_BYTE_TEST(mouse, value_) \
    7374do { \
    7475        uint8_t value = (value_); \
    7576        uint8_t data = 0; \
    76         const ssize_t size = chardev_read(sess, &data, 1); \
     77        const ssize_t size = chardev_read((mouse)->chardev, &data, 1); \
    7778        if (size != 1) { \
    7879                ddf_msg(LVL_ERROR, "Failed reading byte: %zd)", size);\
     
    8687} while (0)
    8788
    88 #define MOUSE_WRITE_BYTE(sess, value_) \
     89#define MOUSE_WRITE_BYTE(mouse, value_) \
    8990do { \
    9091        uint8_t value = (value_); \
    9192        uint8_t data = (value); \
    92         const ssize_t size = chardev_write(sess, &data, 1); \
     93        const ssize_t size = chardev_write((mouse)->chardev, &data, 1); \
    9394        if (size < 0 ) { \
    9495                ddf_msg(LVL_ERROR, "Failed writing byte: %hhx", value); \
     
    99100static int polling_ps2(void *);
    100101static int polling_intellimouse(void *);
    101 static int probe_intellimouse(async_exch_t *, bool);
     102static int probe_intellimouse(ps2_mouse_t *, bool);
    102103static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
    103104
     
    108109
    109110/** Initialize mouse driver structure.
     111 *
     112 * Connects to parent, creates keyboard function, starts polling fibril.
     113 *
    110114 * @param kbd Mouse driver structure to initialize.
    111115 * @param dev DDF device structure.
    112116 *
    113  * Connects to parent, creates keyboard function, starts polling fibril.
     117 * @return EOK on success or non-zero error code
    114118 */
    115119int ps2_mouse_init(ps2_mouse_t *mouse, ddf_dev_t *dev)
    116120{
     121        async_sess_t *parent_sess;
     122        bool bound = false;
     123        int rc;
     124
    117125        mouse->client_sess = NULL;
    118         mouse->parent_sess = ddf_dev_parent_sess_get(dev);
    119         if (!mouse->parent_sess)
    120                 return ENOMEM;
     126
     127        parent_sess = ddf_dev_parent_sess_get(dev);
     128        if (parent_sess == NULL) {
     129                ddf_msg(LVL_ERROR, "Failed getting parent session.");
     130                rc = ENOMEM;
     131                goto error;
     132        }
     133
     134        rc = chardev_open(parent_sess, &mouse->chardev);
     135        if (rc != EOK) {
     136                ddf_msg(LVL_ERROR, "Failed opening character device.");
     137                goto error;
     138        }
    121139
    122140        mouse->mouse_fun = ddf_fun_create(dev, fun_exposed, "mouse");
    123         if (!mouse->mouse_fun) {
    124                 return ENOMEM;
    125         }
     141        if (mouse->mouse_fun == NULL) {
     142                ddf_msg(LVL_ERROR, "Error creating mouse function.");
     143                rc = ENOMEM;
     144                goto error;
     145        }
     146
    126147        ddf_fun_set_ops(mouse->mouse_fun, &mouse_ops);
    127148
    128         int ret = ddf_fun_bind(mouse->mouse_fun);
    129         if (ret != EOK) {
    130                 ddf_fun_destroy(mouse->mouse_fun);
    131                 return ENOMEM;
    132         }
    133 
    134         ret = ddf_fun_add_to_category(mouse->mouse_fun, "mouse");
    135         if (ret != EOK) {
    136                 ddf_fun_unbind(mouse->mouse_fun);
    137                 ddf_fun_destroy(mouse->mouse_fun);
    138                 return ENOMEM;
    139         }
     149        rc = ddf_fun_bind(mouse->mouse_fun);
     150        if (rc != EOK) {
     151                ddf_msg(LVL_ERROR, "Failed binding mouse function.");
     152                goto error;
     153        }
     154
     155        bound = true;
     156
     157        rc = ddf_fun_add_to_category(mouse->mouse_fun, "mouse");
     158        if (rc != EOK) {
     159                ddf_msg(LVL_ERROR, "Failed adding mouse function to category.");
     160                goto error;
     161        }
     162
    140163        /* Probe IntelliMouse extensions. */
    141164        int (*polling_f)(void*) = polling_ps2;
    142         async_exch_t *exch = async_exchange_begin(mouse->parent_sess);
    143         if (probe_intellimouse(exch, false) == EOK) {
     165        if (probe_intellimouse(mouse, false) == EOK) {
    144166                ddf_msg(LVL_NOTE, "Enabled IntelliMouse extensions");
    145167                polling_f = polling_intellimouse;
    146                 if (probe_intellimouse(exch, true) == EOK)
     168                if (probe_intellimouse(mouse, true) == EOK)
    147169                        ddf_msg(LVL_NOTE, "Enabled 4th and 5th button.");
    148170        }
     171
    149172        /* Enable mouse data reporting. */
    150173        uint8_t report = PS2_MOUSE_ENABLE_DATA_REPORT;
    151         ssize_t size = chardev_write(exch, &report, 1);
     174        ssize_t size = chardev_write(mouse->chardev, &report, 1);
    152175        if (size != 1) {
    153176                ddf_msg(LVL_ERROR, "Failed to enable data reporting.");
    154                 async_exchange_end(exch);
    155                 ddf_fun_unbind(mouse->mouse_fun);
    156                 ddf_fun_destroy(mouse->mouse_fun);
    157                 return EIO;
    158         }
    159 
    160         size = chardev_read(exch, &report, 1);
    161         async_exchange_end(exch);
     177                rc = EIO;
     178                goto error;
     179        }
     180
     181        size = chardev_read(mouse->chardev, &report, 1);
    162182        if (size != 1 || report != PS2_MOUSE_ACK) {
    163183                ddf_msg(LVL_ERROR, "Failed to confirm data reporting: %hhx.",
    164184                    report);
    165                 ddf_fun_unbind(mouse->mouse_fun);
    166                 ddf_fun_destroy(mouse->mouse_fun);
    167                 return EIO;
     185                rc = EIO;
     186                goto error;
    168187        }
    169188
    170189        mouse->polling_fibril = fibril_create(polling_f, mouse);
    171         if (!mouse->polling_fibril) {
    172                 ddf_fun_unbind(mouse->mouse_fun);
    173                 ddf_fun_destroy(mouse->mouse_fun);
    174                 return ENOMEM;
    175         }
     190        if (mouse->polling_fibril == 0) {
     191                rc = ENOMEM;
     192                goto error;
     193        }
     194
    176195        fibril_add_ready(mouse->polling_fibril);
    177196        return EOK;
     197error:
     198        if (bound)
     199                ddf_fun_unbind(mouse->mouse_fun);
     200        if (mouse->mouse_fun != NULL) {
     201                ddf_fun_destroy(mouse->mouse_fun);
     202                mouse->mouse_fun = NULL;
     203        }
     204
     205        chardev_close(mouse->chardev);
     206        mouse->chardev = NULL;
     207        return rc;
    178208}
    179209
     
    184214int polling_ps2(void *arg)
    185215{
    186         assert(arg);
    187         const ps2_mouse_t *mouse = arg;
    188 
    189         assert(mouse->parent_sess);
     216        ps2_mouse_t *mouse = (ps2_mouse_t *) arg;
     217
    190218        bool buttons[PS2_BUTTON_COUNT] = {};
    191         async_exch_t *parent_exch = async_exchange_begin(mouse->parent_sess);
    192219        while (1) {
    193 
    194220                uint8_t packet[PS2_BUFSIZE] = {};
    195221                const ssize_t size =
    196                     chardev_read(parent_exch, packet, PS2_BUFSIZE);
     222                    chardev_read(mouse->chardev, packet, PS2_BUFSIZE);
    197223
    198224                if (size != PS2_BUFSIZE) {
     
    232258                async_exchange_end(exch);
    233259        }
    234         async_exchange_end(parent_exch);
     260
     261        return 0;
    235262}
    236263
     
    241268static int polling_intellimouse(void *arg)
    242269{
    243         assert(arg);
    244         const ps2_mouse_t *mouse = arg;
    245 
    246         assert(mouse->parent_sess);
     270        ps2_mouse_t *mouse = (ps2_mouse_t *) arg;
     271
    247272        bool buttons[INTELLIMOUSE_BUTTON_COUNT] = {};
    248         async_exch_t *parent_exch = NULL;
    249273        while (1) {
    250                 if (!parent_exch)
    251                         parent_exch = async_exchange_begin(mouse->parent_sess);
    252 
    253274                uint8_t packet[INTELLIMOUSE_BUFSIZE] = {};
    254275                const ssize_t size = chardev_read(
    255                     parent_exch, packet, INTELLIMOUSE_BUFSIZE);
     276                    mouse->chardev, packet, INTELLIMOUSE_BUFSIZE);
    256277
    257278                if (size != INTELLIMOUSE_BUFSIZE) {
     
    310331                async_exchange_end(exch);
    311332        }
    312         async_exchange_end(parent_exch);
     333
     334        return 0;
    313335}
    314336
     
    319341 * See http://www.computer-engineering.org/ps2mouse/ for details.
    320342 */
    321 static int probe_intellimouse(async_exch_t *exch, bool buttons)
     343static int probe_intellimouse(ps2_mouse_t *mouse, bool buttons)
    322344{
    323         assert(exch);
    324 
    325         MOUSE_WRITE_BYTE(exch, PS2_MOUSE_SET_SAMPLE_RATE);
    326         MOUSE_READ_BYTE_TEST(exch, PS2_MOUSE_ACK);
    327         MOUSE_WRITE_BYTE(exch, 200);
    328         MOUSE_READ_BYTE_TEST(exch, PS2_MOUSE_ACK);
    329 
    330         MOUSE_WRITE_BYTE(exch, PS2_MOUSE_SET_SAMPLE_RATE);
    331         MOUSE_READ_BYTE_TEST(exch, PS2_MOUSE_ACK);
    332         MOUSE_WRITE_BYTE(exch, buttons ? 200 : 100);
    333         MOUSE_READ_BYTE_TEST(exch, PS2_MOUSE_ACK);
    334 
    335         MOUSE_WRITE_BYTE(exch, PS2_MOUSE_SET_SAMPLE_RATE);
    336         MOUSE_READ_BYTE_TEST(exch, PS2_MOUSE_ACK);
    337         MOUSE_WRITE_BYTE(exch, 80);
    338         MOUSE_READ_BYTE_TEST(exch, PS2_MOUSE_ACK);
    339 
    340         MOUSE_WRITE_BYTE(exch, PS2_MOUSE_GET_DEVICE_ID);
    341         MOUSE_READ_BYTE_TEST(exch, PS2_MOUSE_ACK);
    342         MOUSE_READ_BYTE_TEST(exch, buttons ? 4 : 3);
     345        MOUSE_WRITE_BYTE(mouse, PS2_MOUSE_SET_SAMPLE_RATE);
     346        MOUSE_READ_BYTE_TEST(mouse, PS2_MOUSE_ACK);
     347        MOUSE_WRITE_BYTE(mouse, 200);
     348        MOUSE_READ_BYTE_TEST(mouse, PS2_MOUSE_ACK);
     349
     350        MOUSE_WRITE_BYTE(mouse, PS2_MOUSE_SET_SAMPLE_RATE);
     351        MOUSE_READ_BYTE_TEST(mouse, PS2_MOUSE_ACK);
     352        MOUSE_WRITE_BYTE(mouse, buttons ? 200 : 100);
     353        MOUSE_READ_BYTE_TEST(mouse, PS2_MOUSE_ACK);
     354
     355        MOUSE_WRITE_BYTE(mouse, PS2_MOUSE_SET_SAMPLE_RATE);
     356        MOUSE_READ_BYTE_TEST(mouse, PS2_MOUSE_ACK);
     357        MOUSE_WRITE_BYTE(mouse, 80);
     358        MOUSE_READ_BYTE_TEST(mouse, PS2_MOUSE_ACK);
     359
     360        MOUSE_WRITE_BYTE(mouse, PS2_MOUSE_GET_DEVICE_ID);
     361        MOUSE_READ_BYTE_TEST(mouse, PS2_MOUSE_ACK);
     362        MOUSE_READ_BYTE_TEST(mouse, buttons ? 4 : 3);
    343363
    344364        return EOK;
  • uspace/drv/hid/ps2mouse/ps2mouse.h

    refb9fd08 r15c5418  
    11/*
    22 * Copyright (c) 2011 Jan Vesely
     3 * Copyright (c) 2017 Jiri Svoboda
    34 * All rights reserved.
    45 *
     
    3031 */
    3132/** @file
    32  * @brief ps/2 mouse driver.
     33 * @brief PS/2 mouse driver.
    3334 */
    3435
    35 #ifndef _PS2MOUSE_H_
    36 #define _PS2MOUSE_H_
     36#ifndef PS2MOUSE_H_
     37#define PS2MOUSE_H_
    3738
    3839#include <ddf/driver.h>
    3940#include <fibril.h>
     41#include <io/chardev.h>
    4042
    4143/** PS/2 mouse driver structure. */
    4244typedef struct {
    43         ddf_fun_t *mouse_fun;      /**< Mouse function. */
    44         async_sess_t *parent_sess; /**< Connection to device providing data. */
    45         async_sess_t *client_sess;  /**< Callback connection to client. */
    46         fid_t polling_fibril;      /**< Fibril retrieving an parsing data. */
     45        /** Mouse function. */
     46        ddf_fun_t *mouse_fun;
     47        /** Device providing mouse connection */
     48        chardev_t *chardev;
     49        /** Callback connection to client. */
     50        async_sess_t *client_sess;
     51        /** Fibril retrieving an parsing data. */
     52        fid_t polling_fibril;
    4753} ps2_mouse_t;
    4854
    49 int ps2_mouse_init(ps2_mouse_t *, ddf_dev_t *);
     55extern int ps2_mouse_init(ps2_mouse_t *, ddf_dev_t *);
    5056
    5157#endif
     58
    5259/**
    5360 * @}
  • uspace/drv/hid/xtkbd/xtkbd.c

    refb9fd08 r15c5418  
    11/*
    22 * Copyright (c) 2011 Jan Vesely
     3 * Copyright (c) 2017 Jiri Svoboda
    34 * All rights reserved.
    45 *
     
    206207static int polling(void *arg)
    207208{
    208         const xt_kbd_t *kbd = arg;
    209        
    210         assert(kbd);
    211         assert(kbd->parent_sess);
    212        
    213         async_exch_t *parent_exch = async_exchange_begin(kbd->parent_sess);
     209        xt_kbd_t *kbd = arg;
    214210       
    215211        while (true) {
    216                 if (!parent_exch)
    217                         parent_exch = async_exchange_begin(kbd->parent_sess);
    218                
    219212                const unsigned int *map = scanmap_simple;
    220213                size_t map_size = sizeof(scanmap_simple) / sizeof(unsigned int);
    221214               
    222215                uint8_t code = 0;
    223                 ssize_t size = chardev_read(parent_exch, &code, 1);
     216                ssize_t size = chardev_read(kbd->chardev, &code, 1);
    224217                if (size != 1)
    225218                        return EIO;
     
    234227                        map_size = sizeof(scanmap_e0) / sizeof(unsigned int);
    235228                       
    236                         size = chardev_read(parent_exch, &code, 1);
     229                        size = chardev_read(kbd->chardev, &code, 1);
    237230                        if (size != 1)
    238231                                return EIO;
     
    241234                       
    242235                        if (code == 0x2a) {  /* Print Screen */
    243                                 size = chardev_read(parent_exch, &code, 1);
     236                                size = chardev_read(kbd->chardev, &code, 1);
    244237                                if (size != 1)
    245238                                        return EIO;
     
    248241                                        continue;
    249242                               
    250                                 size = chardev_read(parent_exch, &code, 1);
     243                                size = chardev_read(kbd->chardev, &code, 1);
    251244                                if (size != 1)
    252245                                        return EIO;
     
    259252                       
    260253                        if (code == 0x46) {  /* Break */
    261                                 size = chardev_read(parent_exch, &code, 1);
     254                                size = chardev_read(kbd->chardev, &code, 1);
    262255                                if (size != 1)
    263256                                        return EIO;
     
    266259                                        continue;
    267260                               
    268                                 size = chardev_read(parent_exch, &code, 1);
     261                                size = chardev_read(kbd->chardev, &code, 1);
    269262                                if (size != 1)
    270263                                        return EIO;
     
    279272                /* Extended special set */
    280273                if (code == KBD_SCANCODE_SET_EXTENDED_SPECIAL) {
    281                         size = chardev_read(parent_exch, &code, 1);
     274                        size = chardev_read(kbd->chardev, &code, 1);
    282275                        if (size != 1)
    283276                                return EIO;
     
    286279                                continue;
    287280                       
    288                         size = chardev_read(parent_exch, &code, 1);
     281                        size = chardev_read(kbd->chardev, &code, 1);
    289282                        if (size != 1)
    290283                                return EIO;
     
    293286                                continue;
    294287                       
    295                         size = chardev_read(parent_exch, &code, 1);
     288                        size = chardev_read(kbd->chardev, &code, 1);
    296289                        if (size != 1)
    297290                                return EIO;
     
    300293                                continue;
    301294                       
    302                         size = chardev_read(parent_exch, &code, 1);
     295                        size = chardev_read(kbd->chardev, &code, 1);
    303296                        if (size != 1)
    304297                                return EIO;
     
    307300                                continue;
    308301                       
    309                         size = chardev_read(parent_exch, &code, 1);
     302                        size = chardev_read(kbd->chardev, &code, 1);
    310303                        if (size != 1)
    311304                                return EIO;
     
    357350                uint8_t cmds[] = { KBD_CMD_SET_LEDS, status };
    358351               
    359                 async_exch_t *exch = async_exchange_begin(kbd->parent_sess);
    360                 const ssize_t size = chardev_write(exch, cmds, sizeof(cmds));
    361                 async_exchange_end(exch);
     352                ssize_t size = chardev_write(kbd->chardev, cmds, sizeof(cmds));
    362353               
    363354                async_answer_0(icallid, size < 0 ? size : EOK);
     
    413404int xt_kbd_init(xt_kbd_t *kbd, ddf_dev_t *dev)
    414405{
    415         assert(kbd);
    416         assert(dev);
     406        async_sess_t *parent_sess;
     407        bool bound = false;
     408        int rc;
    417409       
    418410        kbd->client_sess = NULL;
    419         kbd->parent_sess = ddf_dev_parent_sess_get(dev);
    420        
    421         if (!kbd->parent_sess) {
     411       
     412        parent_sess = ddf_dev_parent_sess_get(dev);
     413        if (parent_sess == NULL) {
    422414                ddf_msg(LVL_ERROR, "Failed creating parent session.");
    423                 return EIO;
     415                rc = EIO;
     416                goto error;
     417        }
     418       
     419        rc = chardev_open(parent_sess, &kbd->chardev);
     420        if (rc != EOK) {
     421                ddf_msg(LVL_ERROR, "Failed opening character device.");
     422                goto error;
    424423        }
    425424       
    426425        kbd->kbd_fun = ddf_fun_create(dev, fun_exposed, "kbd");
    427         if (!kbd->kbd_fun) {
     426        if (kbd->kbd_fun == NULL) {
    428427                ddf_msg(LVL_ERROR, "Failed creating function 'kbd'.");
    429                 return ENOMEM;
     428                rc = ENOMEM;
     429                goto error;
    430430        }
    431431       
    432432        ddf_fun_set_ops(kbd->kbd_fun, &kbd_ops);
    433433       
    434         int ret = ddf_fun_bind(kbd->kbd_fun);
    435         if (ret != EOK) {
     434        rc = ddf_fun_bind(kbd->kbd_fun);
     435        if (rc != EOK) {
    436436                ddf_msg(LVL_ERROR, "Failed binding function 'kbd'.");
    437                 ddf_fun_destroy(kbd->kbd_fun);
    438                 return EEXIST;
    439         }
    440        
    441         ret = ddf_fun_add_to_category(kbd->kbd_fun, "keyboard");
    442         if (ret != EOK) {
     437                goto error;
     438        }
     439       
     440        rc = ddf_fun_add_to_category(kbd->kbd_fun, "keyboard");
     441        if (rc != EOK) {
    443442                ddf_msg(LVL_ERROR, "Failed adding function 'kbd' to category "
    444443                    "'keyboard'.");
    445                 ddf_fun_unbind(kbd->kbd_fun);
    446                 ddf_fun_destroy(kbd->kbd_fun);
    447                 return ENOMEM;
     444                goto error;
    448445        }
    449446       
    450447        kbd->polling_fibril = fibril_create(polling, kbd);
    451         if (!kbd->polling_fibril) {
     448        if (kbd->polling_fibril == 0) {
    452449                ddf_msg(LVL_ERROR, "Failed creating polling fibril.");
    453                 ddf_fun_unbind(kbd->kbd_fun);
    454                 ddf_fun_destroy(kbd->kbd_fun);
    455                 return ENOMEM;
     450                rc = ENOMEM;
     451                goto error;
    456452        }
    457453       
    458454        fibril_add_ready(kbd->polling_fibril);
    459455        return EOK;
     456error:
     457        if (bound)
     458                ddf_fun_unbind(kbd->kbd_fun);
     459        if (kbd->kbd_fun != NULL)
     460                ddf_fun_destroy(kbd->kbd_fun);
     461        chardev_close(kbd->chardev);
     462        return rc;
    460463}
  • uspace/drv/hid/xtkbd/xtkbd.h

    refb9fd08 r15c5418  
    11/*
    22 * Copyright (c) 2011 Jan Vesely
     3 * Copyright (c) 2017 Jiri Svoboda
    34 * All rights reserved.
    45 *
     
    3435 */
    3536
    36 #ifndef _XT_KBD_H_
    37 #define _XT_KBD_H_
     37#ifndef XT_KBD_H_
     38#define XT_KBD_H_
    3839
     40#include <async.h>
    3941#include <ddf/driver.h>
    4042#include <fibril.h>
     43#include <io/chardev.h>
    4144
    42 /** PC/XT keyboard driver structure. */
     45/** PC/XT keyboard driver structure */
    4346typedef struct {
    44         ddf_fun_t *kbd_fun;        /**< Keyboard function. */
    45         async_sess_t *parent_sess; /**< Connection to device providing data. */
    46         async_sess_t *client_sess; /**< Callback connection to client. */
    47         fid_t polling_fibril;      /**< Fibril retrieving an parsing data. */
     47        /** Keyboard function */
     48        ddf_fun_t *kbd_fun;
     49        /** Device providing keyboard connection */
     50        chardev_t *chardev;
     51        /** Callback connection to client */
     52        async_sess_t *client_sess;
     53        /** Fibril retrieving an parsing data */
     54        fid_t polling_fibril;
    4855} xt_kbd_t;
    4956
  • uspace/lib/c/generic/io/chardev.c

    refb9fd08 r15c5418  
    11/*
    22 * Copyright (c) 2011 Jan Vesely
     3 * Copyright (c) 2017 Jiri Svoboda
    34 * All rights reserved.
    45 *
     
    2728 */
    2829
     30/** @addtogroup libc
     31 * @{
     32 */
     33/**
     34 * @file
     35 * @brief Character device client interface
     36 */
     37
    2938#include <errno.h>
    3039#include <mem.h>
    3140#include <io/chardev.h>
    3241#include <ipc/chardev.h>
     42#include <stdlib.h>
    3343
    34 ssize_t chardev_read(async_exch_t *exch, void *data, size_t size)
     44/** Open character device.
     45 *
     46 * @param sess Session with the character device
     47 * @param rchardev Place to store pointer to the new character device structure
     48 *
     49 * @return EOK on success, ENOMEM if out of memory, EIO on I/O error
     50 */
     51int chardev_open(async_sess_t *sess, chardev_t **rchardev)
    3552{
    36         if (!exch)
    37                 return EBADMEM;
     53        chardev_t *chardev;
     54
     55        chardev = calloc(1, sizeof(chardev_t));
     56        if (chardev == NULL)
     57                return ENOMEM;
     58
     59        chardev->sess = sess;
     60        *rchardev = chardev;
     61
     62        /* EIO might be used in a future implementation */
     63        return EOK;
     64}
     65
     66/** Close character device.
     67 *
     68 * Frees the character device structure. The underlying session is
     69 * not affected.
     70 *
     71 * @param chardev Character device or @c NULL
     72 */
     73void chardev_close(chardev_t *chardev)
     74{
     75        free(chardev);
     76}
     77
     78ssize_t chardev_read(chardev_t *chardev, void *data, size_t size)
     79{
    3880        if (size > 4 * sizeof(sysarg_t))
    3981                return ELIMIT;
    4082
     83        async_exch_t *exch = async_exchange_begin(chardev->sess);
    4184        sysarg_t message[4] = { 0 };
    4285        const ssize_t ret = async_req_1_4(exch, CHARDEV_READ, size,
    4386            &message[0], &message[1], &message[2], &message[3]);
     87        async_exchange_end(exch);
    4488        if (ret > 0 && (size_t)ret <= size)
    4589                memcpy(data, message, size);
     
    4791}
    4892
    49 ssize_t chardev_write(async_exch_t *exch, const void *data, size_t size)
     93ssize_t chardev_write(chardev_t *chardev, const void *data, size_t size)
    5094{
    51         if (!exch)
    52                 return EBADMEM;
     95        int ret;
     96
    5397        if (size > 3 * sizeof(sysarg_t))
    5498                return ELIMIT;
    5599
     100        async_exch_t *exch = async_exchange_begin(chardev->sess);
    56101        sysarg_t message[3] = { 0 };
    57102        memcpy(message, data, size);
    58         return async_req_4_0(exch, CHARDEV_WRITE, size,
     103        ret = async_req_4_0(exch, CHARDEV_WRITE, size,
    59104            message[0], message[1], message[2]);
     105        async_exchange_end(exch);
     106        return ret;
    60107}
     108
     109/** @}
     110 */
  • uspace/lib/c/include/io/chardev.h

    refb9fd08 r15c5418  
    11/*
    22 * Copyright (c) 2011 Jan Vesely
     3 * Copyright (c) 2017 Jiri Svoboda
    34 * All rights reserved.
    45 *
     
    3334#define LIBC_IO_CHARDEV_H_
    3435
     36#include <async.h>
    3537#include <types/common.h>
    36 #include <async.h>
    3738
    38 ssize_t chardev_read(async_exch_t *, void *, size_t);
    39 ssize_t chardev_write(async_exch_t *, const void *, size_t);
     39typedef struct {
     40        async_sess_t *sess;
     41} chardev_t;
     42
     43extern int chardev_open(async_sess_t *, chardev_t **);
     44extern void chardev_close(chardev_t *);
     45extern ssize_t chardev_read(chardev_t *, void *, size_t);
     46extern ssize_t chardev_write(chardev_t *, const void *, size_t);
    4047
    4148#endif
Note: See TracChangeset for help on using the changeset viewer.