Changeset ac307b2 in mainline for uspace/srv


Ignore:
Timestamp:
2017-11-25T11:12:23Z (8 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
98cb5e0d
Parents:
f571ca49 (diff), 0851a3d (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 branch 'master' into callcaps

Location:
uspace/srv
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    rf571ca49 rac307b2  
    3737 */
    3838
     39#include <adt/fifo.h>
    3940#include <adt/list.h>
    40 #include <stdbool.h>
     41#include <async.h>
     42#include <config.h>
     43#include <errno.h>
     44#include <fibril.h>
    4145#include <fibril_synch.h>
     46#include <io/chardev.h>
     47#include <io/console.h>
     48#include <io/keycode.h>
    4249#include <ipc/services.h>
    4350#include <ipc/input.h>
    44 #include <config.h>
     51#include <loc.h>
     52#include <ns.h>
     53#include <stdbool.h>
    4554#include <stdio.h>
    4655#include <stdlib.h>
    47 #include <ns.h>
    48 #include <async.h>
    49 #include <errno.h>
    50 #include <adt/fifo.h>
    51 #include <io/console.h>
    52 #include <io/keycode.h>
    53 #include <loc.h>
    5456#include <str_error.h>
    55 #include <char_dev_iface.h>
    56 #include <fibril.h>
    57 #include "layout.h"
     57
     58#include "input.h"
    5859#include "kbd.h"
    5960#include "kbd_port.h"
    6061#include "kbd_ctl.h"
     62#include "layout.h"
    6163#include "mouse.h"
    6264#include "mouse_proto.h"
    6365#include "serial.h"
    64 #include "input.h"
    6566
    6667#define NUM_LAYOUTS  4
    … …  
    536537        while (true) {
    537538                uint8_t data;
    538 
    539                 char_dev_read(sdev->sess, &data, sizeof(data));
     539                size_t nread;
     540
     541                chardev_read(sdev->chardev, &data, sizeof(data), &nread);
     542                /* XXX Handle error */
    540543                kbd_push_data(sdev->kdev, data);
    541544        }
    … …  
    552555{
    553556        bool match = false;
     557        int rc;
    554558
    555559        serial_dev_t *sdev = serial_dev_new();
    … …  
    559563        sdev->kdev->svc_id = service_id;
    560564       
    561         int rc = loc_service_get_name(service_id, &sdev->kdev->svc_name);
     565        rc = loc_service_get_name(service_id, &sdev->kdev->svc_name);
    562566        if (rc != EOK)
    563567                goto fail;
    … …  
    582586                sdev->sess = loc_service_connect(service_id, INTERFACE_DDF,
    583587                    IPC_FLAG_BLOCKING);
     588
     589                rc = chardev_open(sdev->sess, &sdev->chardev);
     590                if (rc != EOK) {
     591                        async_hangup(sdev->sess);
     592                        sdev->sess = NULL;
     593                        list_remove(&sdev->link);
     594                        goto fail;
     595                }
    584596
    585597                fid_t fid = fibril_create(serial_consumer, sdev);

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

    rf571ca49 rac307b2  
    3535 */
    3636
    37 #include <ipc/char.h>
    3837#include <async.h>
     38#include <errno.h>
     39#include <fibril.h>
     40#include <io/chardev.h>
    3941#include <loc.h>
    40 #include <errno.h>
    4142#include <stdio.h>
    4243#include "../input.h"
    … …  
    4445#include "../kbd.h"
    4546
    46 static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
     47static int kbd_port_fibril(void *);
    4748
    4849static int chardev_port_init(kbd_dev_t *);
    49 static void chardev_port_write(uint8_t data);
     50static void chardev_port_write(uint8_t);
    5051
    5152kbd_port_ops_t chardev_port = {
    … …  
    5657static kbd_dev_t *kbd_dev;
    5758static async_sess_t *dev_sess;
     59static chardev_t *chardev;
    5860
    5961/** List of devices to try connecting to. */
    … …  
    7072{
    7173        service_id_t service_id;
    72         async_exch_t *exch;
    7374        unsigned int i;
     75        fid_t fid;
    7476        int rc;
    7577       
    … …  
    9698        }
    9799       
    98         exch = async_exchange_begin(dev_sess);
    99         if (exch == NULL) {
    100                 printf("%s: Failed starting exchange with device\n", NAME);
     100        rc = chardev_open(dev_sess, &chardev);
     101        if (rc != EOK) {
     102                printf("%s: Failed opening character device\n", NAME);
    101103                async_hangup(dev_sess);
    102104                return ENOMEM;
    103105        }
    104106       
    105         port_id_t port;
    106         rc = async_create_callback_port(exch, INTERFACE_CHAR_CB, 0, 0,
    107             kbd_port_events, NULL, &port);
    108        
    109         async_exchange_end(exch);
    110        
    111         if (rc != 0) {
    112                 printf("%s: Failed to create callback from device\n", NAME);
     107        fid = fibril_create(kbd_port_fibril, NULL);
     108        if (fid == 0) {
     109                printf("%s: Failed creating fibril\n", NAME);
     110                chardev_close(chardev);
    113111                async_hangup(dev_sess);
    114                 return -1;
     112                return ENOMEM;
    115113        }
     114
     115        fibril_add_ready(fid);
    116116       
    117117        printf("%s: Found input device '%s'\n", NAME, in_devs[i]);
    … …  
    121121static void chardev_port_write(uint8_t data)
    122122{
    123         async_exch_t *exch = async_exchange_begin(dev_sess);
    124         if (exch == NULL) {
    125                 printf("%s: Failed starting exchange with device\n", NAME);
     123        int rc;
     124        size_t nwr;
     125
     126        rc = chardev_write(chardev, &data, sizeof(data), &nwr);
     127        if (rc != EOK || nwr != sizeof(data)) {
     128                printf("%s: Failed writing to character device\n", NAME);
    126129                return;
    127         }
    128 
    129         async_msg_1(exch, CHAR_WRITE_BYTE, data);
    130         async_exchange_end(exch);
    131 }
    132 
    133 static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    134 {
    135         /* Ignore parameters, the connection is already opened */
    136         while (true) {
    137 
    138                 ipc_call_t call;
    139                 ipc_callid_t callid = async_get_call(&call);
    140                
    141                 if (!IPC_GET_IMETHOD(call)) {
    142                         /* TODO: Handle hangup */
    143                         return;
    144                 }
    145 
    146                 int retval = EOK;
    147 
    148                 switch (IPC_GET_IMETHOD(call)) {
    149                 case CHAR_NOTIF_BYTE:
    150                         kbd_push_data(kbd_dev, IPC_GET_ARG1(call));
    151                         break;
    152                 default:
    153                         retval = ENOENT;
    154                 }
    155                 async_answer_0(callid, retval);
    156130        }
    157131}
    158132
     133static int kbd_port_fibril(void *arg)
     134{
     135        int rc;
     136        size_t nread;
     137        uint8_t b;
     138
     139        while (true) {
     140                rc = chardev_read(chardev, &b, sizeof(b), &nread);
     141                if (rc != EOK || nread != sizeof(b)) {
     142                        printf("%s: Error reading data", NAME);
     143                        continue;
     144                }
     145
     146                kbd_push_data(kbd_dev, b);
     147        }
     148
     149        return 0;
     150}
    159151
    160152/**

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

    rf571ca49 rac307b2  
    3939
    4040#include <async.h>
     41#include <io/chardev.h>
    4142#include "kbd.h"
    4243
    … …  
    4546        link_t link;
    4647        async_sess_t *sess;
     48        chardev_t *chardev;
    4749} serial_dev_t;
    4850

  • uspace/srv/hid/isdv4_tablet/isdv4.c

    rf571ca49 rac307b2  
    2727 */
    2828
    29 #include <char_dev_iface.h>
    3029#include <errno.h>
     30#include <io/chardev.h>
     31#include <mem.h>
    3132#include <stdbool.h>
    3233#include <stdint.h>
    3334#include <stdlib.h>
    34 #include <mem.h>
    3535#include <thread.h>
    3636
    … …  
    298298        bool reading = true;
    299299        while (reading) {
    300                 ssize_t read = char_dev_read(state->sess, state->buf + state->buf_end,
    301                     state->buf_size - state->buf_end);
    302                 if (read < 0)
     300                size_t nread;
     301                int rc;
     302
     303                rc = chardev_read(state->chardev, state->buf + state->buf_end,
     304                    state->buf_size - state->buf_end, &nread);
     305                if (rc != EOK && nread == 0)
    303306                        return EIO;
    304                 state->buf_end += read;
     307                state->buf_end += nread;
    305308
    306309                size_t i = 0;
    … …  
    357360        return EOK;
    358361}
    359 static bool write_command(async_sess_t *sess, uint8_t command)
    360 {
    361         return char_dev_write(sess, &command, 1) == 1;
     362
     363static bool write_command(chardev_t *chardev, uint8_t command)
     364{
     365        int rc;
     366        size_t nwr;
     367
     368        rc = chardev_write(chardev, &command, 1, &nwr);
     369        return rc == EOK;
    362370}
    363371
    … …  
    365373    isdv4_event_fn event_fn)
    366374{
     375        chardev_t *chardev;
     376        int rc;
     377
     378        rc = chardev_open(sess, &chardev);
     379        if (rc != EOK)
     380                return rc;
     381
    367382        memset(state, 0, sizeof(isdv4_state_t));
     383
    368384        state->sess = sess;
     385        state->chardev = chardev;
     386
    369387        state->buf = malloc(BUF_SIZE);
    370         if (state->buf == NULL)
     388        if (state->buf == NULL) {
     389                chardev_close(chardev);
    371390                return ENOMEM;
     391        }
     392
    372393        state->buf_size = BUF_SIZE;
    373394        state->emit_event_fn = event_fn;
    … …  
    377398int isdv4_init_tablet(isdv4_state_t *state)
    378399{
    379         if (!write_command(state->sess, CMD_STOP))
     400        if (!write_command(state->chardev, CMD_STOP))
    380401                return EIO;
    381402
    … …  
    383404
    384405        // FIXME: Read all possible garbage before sending commands
    385         if (!write_command(state->sess, CMD_QUERY_STYLUS))
     406        if (!write_command(state->chardev, CMD_QUERY_STYLUS))
    386407                return EIO;
    387408
    … …  
    390411                return rc;
    391412
    392         if (!write_command(state->sess, CMD_QUERY_TOUCH))
     413        if (!write_command(state->chardev, CMD_QUERY_TOUCH))
    393414                return EIO;
    394415
    … …  
    397418                return rc;
    398419
    399         if (!write_command(state->sess, CMD_START))
     420        if (!write_command(state->chardev, CMD_START))
    400421                return EIO;
    401422

  • uspace/srv/hid/isdv4_tablet/isdv4.h

    rf571ca49 rac307b2  
    3131
    3232#include <async.h>
     33#include <io/chardev.h>
    3334
    3435typedef struct isdv4_event isdv4_event_t;
    … …  
    5859        bool finger1_pressed; /* Reported as touch button 1 */
    5960
    60         /* Session to the serial device */
     61        /** Session with the serial device */
    6162        async_sess_t *sess;
     63        /** Character device */
     64        chardev_t *chardev;
    6265
    6366        /* Receive buffer state */
    … …  
    6669        size_t buf_end;
    6770
    68         /* Callbacks */
     71        /** Callbacks */
    6972        isdv4_event_fn emit_event_fn;
    7073} isdv4_state_t;

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

    rf571ca49 rac307b2  
    3030 */
    3131
     32#include <async.h>
     33#include <config.h>
     34#include <errno.h>
     35#include <fibril_synch.h>
     36#include <io/chardev.h>
     37#include <loc.h>
    3238#include <stddef.h>
    3339#include <stdint.h>
    34 #include <char_dev_iface.h>
    3540#include <stdio.h>
    3641#include <stdlib.h>
    37 #include <async.h>
    38 #include <fibril_synch.h>
    39 #include <loc.h>
    40 #include <errno.h>
    4142#include <str.h>
    42 #include <config.h>
    4343#include "../ctl/serial.h"
    4444#include "../output.h"
    … …  
    4848
    4949static async_sess_t *sess;
     50static chardev_t *chardev;
    5051static service_id_t serial_cat_id;
    5152
    … …  
    5758{
    5859        uint8_t byte = (uint8_t) ch;
    59         char_dev_write(sess, &byte, 1);
     60        size_t nwr;
     61        chardev_write(chardev, &byte, 1, &nwr);
     62        /* XXX Handle error */
    6063}
    6164
    6265static void chardev_control_puts(const char *str)
    6366{
    64         char_dev_write(sess, (void *) str, str_size(str));
     67        size_t nwr;
     68        chardev_write(chardev, (void *) str, str_size(str), &nwr);
     69        /* XXX Handle error */
    6570}
    6671
    … …  
    126131                return;
    127132        }
     133
     134        rc = chardev_open(sess, &chardev);
     135        if (rc != EOK) {
     136                fibril_mutex_unlock(&discovery_lock);
     137                printf("%s: Failed opening character device\n", NAME);
     138                return;
     139        }
     140
    128141        serial_init(chardev_putchar, chardev_control_puts);
    129142

  • uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c

    rf571ca49 rac307b2  
    2727 */
    2828
    29 /** @addtogroup driver_serial
    30  * @{
    31  */
    3229/**
    3330 * @file
    … …  
    3734 */
    3835
     36#include <async.h>
    3937#include <ddi.h>
     38#include <errno.h>
     39#include <inttypes.h>
     40#include <io/chardev_srv.h>
    4041#include <loc.h>
    41 #include <ipc/char.h>
    42 #include <async.h>
    4342#include <stdio.h>
    4443#include <stdlib.h>
    4544#include <sysinfo.h>
    46 #include <errno.h>
    47 #include <inttypes.h>
    4845#include "s3c24xx_uart.h"
    4946
    … …  
    7269static void s3c24xx_uart_sendb(s3c24xx_uart_t *, uint8_t);
    7370
     71static int s3c24xx_uart_read(chardev_srv_t *, void *, size_t, size_t *);
     72static int s3c24xx_uart_write(chardev_srv_t *, const void *, size_t, size_t *);
     73
     74static chardev_ops_t s3c24xx_uart_chardev_ops = {
     75        .read = s3c24xx_uart_read,
     76        .write = s3c24xx_uart_write
     77};
     78
    7479int main(int argc, char *argv[])
    7580{
    7681        printf("%s: S3C24xx on-chip UART driver\n", NAME);
    7782       
    78         async_set_fallback_port_handler(s3c24xx_uart_connection, NULL);
     83        async_set_fallback_port_handler(s3c24xx_uart_connection, uart);
    7984        int rc = loc_server_register(NAME);
    8085        if (rc != EOK) {
    … …  
    111116    void *arg)
    112117{
    113         /* Answer the IPC_M_CONNECT_ME_TO call. */
    114         async_answer_0(iid, EOK);
    115        
    116         while (true) {
    117                 ipc_call_t call;
    118                 ipc_callid_t callid = async_get_call(&call);
    119                 sysarg_t method = IPC_GET_IMETHOD(call);
    120                
    121                 if (!method) {
    122                         /* The other side has hung up. */
    123                         async_answer_0(callid, EOK);
    124                         return;
    125                 }
    126                
    127                 async_sess_t *sess =
    128                     async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
    129                 if (sess != NULL) {
    130                         if (uart->client_sess == NULL) {
    131                                 uart->client_sess = sess;
    132                                 async_answer_0(callid, EOK);
    133                         } else
    134                                 async_answer_0(callid, ELIMIT);
    135                 } else {
    136                         switch (method) {
    137                         case CHAR_WRITE_BYTE:
    138                                 printf(NAME ": write %" PRIun " to device\n",
    139                                     IPC_GET_ARG1(call));
    140                                 s3c24xx_uart_sendb(uart, (uint8_t) IPC_GET_ARG1(call));
    141                                 async_answer_0(callid, EOK);
    142                                 break;
    143                         default:
    144                                 async_answer_0(callid, EINVAL);
    145                         }
    146                 }
    147         }
    148 }
     118        s3c24xx_uart_t *uart = (s3c24xx_uart_t *) arg;
     119
     120        chardev_conn(iid, icall, &uart->cds);
     121}
     122
    149123
    150124static void s3c24xx_uart_irq_handler(ipc_callid_t iid, ipc_call_t *call,
    151125    void *arg)
    152126{
     127        int rc;
     128
    153129        (void) iid;
    154130        (void) call;
    … …  
    159135                uint32_t status = pio_read_32(&uart->io->uerstat);
    160136
    161                 if (uart->client_sess != NULL) {
    162                         async_exch_t *exch = async_exchange_begin(uart->client_sess);
    163                         async_msg_1(exch, CHAR_NOTIF_BYTE, data);
    164                         async_exchange_end(exch);
    165                 }
     137                fibril_mutex_lock(&uart->buf_lock);
     138
     139                rc = circ_buf_push(&uart->cbuf, &data);
     140                if (rc != EOK)
     141                        printf(NAME ": Buffer overrun\n");
     142
     143                fibril_mutex_unlock(&uart->buf_lock);
     144                fibril_condvar_broadcast(&uart->buf_cv);
    166145
    167146                if (status != 0)
    … …  
    176155        sysarg_t inr;
    177156
     157        circ_buf_init(&uart->cbuf, uart->buf, s3c24xx_uart_buf_size, 1);
     158        fibril_mutex_initialize(&uart->buf_lock);
     159        fibril_condvar_initialize(&uart->buf_cv);
     160
    178161        if (sysinfo_get_value("s3c24xx_uart.address.physical",
    179162            &uart->paddr) != EOK)
    … …  
    188171
    189172        uart->io = vaddr;
    190         uart->client_sess = NULL;
    191173
    192174        printf(NAME ": device at physical address %p, inr %" PRIun ".\n",
    … …  
    203185            pio_read_32(&uart->io->ucon) & ~UCON_RX_INT_LEVEL);
    204186
     187        chardev_srvs_init(&uart->cds);
     188        uart->cds.ops = &s3c24xx_uart_chardev_ops;
     189        uart->cds.sarg = uart;
     190
    205191        return EOK;
    206192}
    … …  
    216202}
    217203
     204static int s3c24xx_uart_read(chardev_srv_t *srv, void *buf, size_t size,
     205    size_t *nread)
     206{
     207        s3c24xx_uart_t *uart = (s3c24xx_uart_t *) srv->srvs->sarg;
     208        size_t p;
     209        uint8_t *bp = (uint8_t *) buf;
     210        int rc;
     211
     212        fibril_mutex_lock(&uart->buf_lock);
     213
     214        while (circ_buf_nused(&uart->cbuf) == 0)
     215                fibril_condvar_wait(&uart->buf_cv, &uart->buf_lock);
     216
     217        p = 0;
     218        while (p < size) {
     219                rc = circ_buf_pop(&uart->cbuf, &bp[p]);
     220                if (rc != EOK)
     221                        break;
     222                ++p;
     223        }
     224
     225        fibril_mutex_unlock(&uart->buf_lock);
     226
     227        *nread = p;
     228        return EOK;
     229}
     230
     231static int s3c24xx_uart_write(chardev_srv_t *srv, const void *data, size_t size,
     232    size_t *nwr)
     233{
     234        s3c24xx_uart_t *uart = (s3c24xx_uart_t *) srv->srvs->sarg;
     235        size_t i;
     236        uint8_t *dp = (uint8_t *) data;
     237
     238        for (i = 0; i < size; i++)
     239                s3c24xx_uart_sendb(uart, dp[i]);
     240
     241        *nwr = size;
     242        return EOK;
     243}
     244
     245
    218246/** @}
    219247 */

  • uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.h

    rf571ca49 rac307b2  
    3838#define S3C24XX_UART_H_
    3939
     40#include <adt/circ_buf.h>
     41#include <async.h>
     42#include <fibril_synch.h>
     43#include <io/chardev_srv.h>
    4044#include <stdint.h>
    41 #include <async.h>
    4245
    4346/** S3C24xx UART I/O */
    … …  
    7679#define UFCON_FIFO_ENABLE               0x01
    7780
     81enum {
     82        s3c24xx_uart_buf_size = 64
     83};
    7884
    7985/** S3C24xx UART instance */
    … …  
    8591        s3c24xx_uart_io_t *io;
    8692
    87         /** Callback session to the client */
    88         async_sess_t *client_sess;
     93        /** Character device service */
     94        chardev_srvs_t cds;
    8995
    9096        /** Service ID */
    9197        service_id_t service_id;
     98
     99        /** Circular buffer */
     100        circ_buf_t cbuf;
     101        /** Buffer */
     102        uint8_t buf[s3c24xx_uart_buf_size];
     103        /** Buffer lock */
     104        fibril_mutex_t buf_lock;
     105        /** Signal newly added data in buffer */
     106        fibril_condvar_t buf_cv;
    92107} s3c24xx_uart_t;
    93108

  • uspace/srv/net/slip/slip.c

    rf571ca49 rac307b2  
    4040#include <inet/addr.h>
    4141#include <inet/iplink_srv.h>
    42 #include <char_dev_iface.h>
     42#include <io/chardev.h>
    4343#include <io/log.h>
    4444#include <errno.h>
    … …  
    9696}
    9797
    98 static void write_flush(async_sess_t *sess)
     98static void write_flush(chardev_t *chardev)
    9999{
    100100        size_t written = 0;
    101101
    102102        while (slip_send_pending > 0) {
    103                 ssize_t size;
    104 
    105                 size = char_dev_write(sess, &slip_send_buf[written],
    106                     slip_send_pending);
    107                 if (size < 0) {
     103                int rc;
     104                size_t nwr;
     105
     106                rc = chardev_write(chardev, &slip_send_buf[written],
     107                    slip_send_pending, &nwr);
     108                if (rc != EOK) {
    108109                        log_msg(LOG_DEFAULT, LVL_ERROR,
    109                             "char_dev_write() returned %d",
    110                             (int) size);
     110                            "chardev_write() returned %d", rc);
    111111                        slip_send_pending = 0;
    112112                        break;
    113113                }
    114                 written += size;
    115                 slip_send_pending -= size;
    116         }
    117 }
    118 
    119 static void write_buffered(async_sess_t *sess, uint8_t ch)
     114                written += nwr;
     115                slip_send_pending -= nwr;
     116        }
     117}
     118
     119static void write_buffered(chardev_t *chardev, uint8_t ch)
    120120{
    121121        if (slip_send_pending == sizeof(slip_send_buf))
    122                 write_flush(sess);
     122                write_flush(chardev);
    123123        slip_send_buf[slip_send_pending++] = ch;
    124124}
    … …  
    128128        log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_send()");
    129129       
    130         async_sess_t *sess = (async_sess_t *) srv->arg;
     130        chardev_t *chardev = (chardev_t *) srv->arg;
    131131        uint8_t *data = sdu->data;
    132132       
    … …  
    136136         * measure for dealing with previous possible noise on the line.
    137137         */
    138         write_buffered(sess, SLIP_END);
     138        write_buffered(chardev, SLIP_END);
    139139       
    140140        for (size_t i = 0; i < sdu->size; i++) {
    141141                switch (data[i]) {
    142142                case SLIP_END:
    143                         write_buffered(sess, SLIP_ESC);
    144                         write_buffered(sess, SLIP_ESC_END);
     143                        write_buffered(chardev, SLIP_ESC);
     144                        write_buffered(chardev, SLIP_ESC_END);
    145145                        break;
    146146                case SLIP_ESC:
    147                         write_buffered(sess, SLIP_ESC);
    148                         write_buffered(sess, SLIP_ESC_ESC);
     147                        write_buffered(chardev, SLIP_ESC);
     148                        write_buffered(chardev, SLIP_ESC_ESC);
    149149                        break;
    150150                default:
    151                         write_buffered(sess, data[i]);
     151                        write_buffered(chardev, data[i]);
    152152                        break;
    153153                }
    154154        }
    155155       
    156         write_buffered(sess, SLIP_END);
    157         write_flush(sess);
     156        write_buffered(chardev, SLIP_END);
     157        write_flush(chardev);
    158158       
    159159        return EOK;
    … …  
    203203}
    204204
    205 static uint8_t read_buffered(async_sess_t *sess)
     205static uint8_t read_buffered(chardev_t *chardev)
    206206{
    207207        while (slip_recv_pending == 0) {
    208                 ssize_t size;
    209 
    210                 size = char_dev_read(sess, slip_recv_buf,
    211                     sizeof(slip_recv_buf));
    212                 if (size < 0) {
     208                int rc;
     209                size_t nread;
     210
     211                rc = chardev_read(chardev, slip_recv_buf,
     212                    sizeof(slip_recv_buf), &nread);
     213                if (rc != EOK) {
    213214                        log_msg(LOG_DEFAULT, LVL_ERROR,
    214                             "char_dev_read() returned %d", (int) size);
     215                            "char_dev_read() returned %d", rc);
     216                }
     217
     218                if (nread == 0)
    215219                        return SLIP_END;
    216                 }
    217                 slip_recv_pending = size;
     220
     221                slip_recv_pending = nread;
    218222                slip_recv_read = 0;
    219223        }
    … …  
    224228static int slip_recv_fibril(void *arg)
    225229{
    226         async_sess_t *sess = (async_sess_t *) arg;
     230        chardev_t *chardev = (chardev_t *) arg;
    227231        static uint8_t recv_final[SLIP_MTU];
    228232        iplink_recv_sdu_t sdu;
    … …  
    234238        while (true) {
    235239                for (sdu.size = 0; sdu.size < sizeof(recv_final); /**/) {
    236                         ch = read_buffered(sess);
     240                        ch = read_buffered(chardev);
    237241                        switch (ch) {
    238242                        case SLIP_END:
    … …  
    246250
    247251                        case SLIP_ESC:
    248                                 ch = read_buffered(sess);
     252                                ch = read_buffered(chardev);
    249253                                if (ch == SLIP_ESC_END) {
    250254                                        recv_final[sdu.size++] = SLIP_END;
    251255                                        break;
    252                                 } else if (ch ==  SLIP_ESC_ESC) {
     256                                } else if (ch == SLIP_ESC_ESC) {
    253257                                        recv_final[sdu.size++] = SLIP_ESC;
    254258                                        break;
    … …  
    295299        async_sess_t *sess_in = NULL;
    296300        async_sess_t *sess_out = NULL;
     301        chardev_t *chardev_in = NULL;
     302        chardev_t *chardev_out = NULL;
    297303        fid_t fid;
    298304        int rc;
    … …  
    336342                return ENOENT;
    337343        }
    338         slip_iplink.arg = sess_out;
     344
     345        rc = chardev_open(sess_out, &chardev_out);
     346        if (rc != EOK) {
     347                log_msg(LOG_DEFAULT, LVL_ERROR,
     348                    "Failed opening character device.");
     349                return ENOENT;
     350        }
     351
     352        slip_iplink.arg = chardev_out;
    339353
    340354        sess_in = loc_service_connect(svcid, INTERFACE_DDF, 0);
    … …  
    347361        }
    348362
     363        rc = chardev_open(sess_in, &chardev_in);
     364        if (rc != EOK) {
     365                log_msg(LOG_DEFAULT, LVL_ERROR,
     366                    "Failed opening character device.");
     367                return ENOENT;
     368        }
     369
    349370        rc = loc_service_register(linkstr, &linksid);
    350371        if (rc != EOK) {
    … …  
    363384        }
    364385
    365         fid = fibril_create(slip_recv_fibril, sess_in);
     386        fid = fibril_create(slip_recv_fibril, chardev_in);
    366387        if (!fid) {
    367388                log_msg(LOG_DEFAULT, LVL_ERROR,
    … …  
    375396
    376397fail:
     398        chardev_close(chardev_out);
    377399        if (sess_out)
    378400                async_hangup(sess_out);
     401        chardev_close(chardev_in);
    379402        if (sess_in)
    380403                async_hangup(sess_in);
Note: See TracChangeset for help on using the changeset viewer.