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

Changeset c4c6025 in mainline


Ignore:
Timestamp:
2017-11-21T18:40:27Z (4 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
74017ce, d51a0d6, ee44809
Parents:
afec1be
Message:

Add C API for serial port control.

Location:
uspace
Files:
2 added
6 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/sportdmp/sportdmp.c

    rafec1be rc4c6025  
    2929#include <char_dev_iface.h>
    3030#include <errno.h>
    31 #include <ipc/serial_ctl.h>
     31#include <io/serial.h>
    3232#include <loc.h>
    3333#include <stdio.h>
     
    4444        sysarg_t baud = 9600;
    4545        service_id_t svc_id;
     46        serial_t *serial;
    4647
    4748        int arg = 1;
     
    113114        async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
    114115            IPC_FLAG_BLOCKING);
    115         if (!sess) {
     116        if (sess == NULL) {
    116117                fprintf(stderr, "Failed connecting to service\n");
     118                return 2;
    117119        }
    118120
    119         async_exch_t *exch = async_exchange_begin(sess);
    120         rc = async_req_4_0(exch, SERIAL_SET_COM_PROPS, baud,
    121             SERIAL_NO_PARITY, 8, 1);
    122         async_exchange_end(exch);
     121        rc = serial_open(sess, &serial);
     122        if (rc != EOK) {
     123                fprintf(stderr, "Failed opening serial port\n");
     124                return 2;
     125        }
    123126
     127        rc = serial_set_comm_props(serial, baud, SERIAL_NO_PARITY, 8, 1);
    124128        if (rc != EOK) {
    125129                fprintf(stderr, "Failed setting serial properties\n");
     
    147151
    148152        free(buf);
     153        serial_close(serial);
     154        async_hangup(sess);
    149155        return 0;
    150156}
  • uspace/app/tester/hw/serial/serial1.c

    rafec1be rc4c6025  
    4646#include <char_dev_iface.h>
    4747#include <str.h>
    48 #include <ipc/serial_ctl.h>
     48#include <io/serial.h>
    4949#include "../../tester.h"
    5050
     
    5656{
    5757        size_t cnt;
     58        serial_t *serial;
    5859       
    5960        if (test_argc < 1)
     
    7980        async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
    8081            IPC_FLAG_BLOCKING);
    81         if (!sess)
     82        if (sess == NULL)
    8283                return "Failed connecting to serial device";
     84       
     85        res = serial_open(sess, &serial);
     86        if (res != EOK)
     87                return "Failed opening serial port";
    8388       
    8489        char *buf = (char *) malloc(cnt + 1);
    8590        if (buf == NULL) {
     91                serial_close(serial);
    8692                async_hangup(sess);
    8793                return "Failed allocating input buffer";
    8894        }
    8995       
    90         sysarg_t old_baud;
    91         sysarg_t old_par;
    92         sysarg_t old_stop;
    93         sysarg_t old_word_size;
    94        
    95         async_exch_t *exch = async_exchange_begin(sess);
    96         res = async_req_0_4(exch, SERIAL_GET_COM_PROPS, &old_baud,
    97             &old_par, &old_word_size, &old_stop);
    98         async_exchange_end(exch);
    99        
     96        unsigned old_baud;
     97        serial_parity_t old_par;
     98        unsigned old_stop;
     99        unsigned old_word_size;
     100       
     101        res = serial_get_comm_props(serial, &old_baud, &old_par,
     102            &old_word_size, &old_stop);
    100103        if (res != EOK) {
    101104                free(buf);
     105                serial_close(serial);
    102106                async_hangup(sess);
    103107                return "Failed to get old serial communication parameters";
    104108        }
    105109       
    106         exch = async_exchange_begin(sess);
    107         res = async_req_4_0(exch, SERIAL_SET_COM_PROPS, 1200,
    108             SERIAL_NO_PARITY, 8, 1);
    109         async_exchange_end(exch);
    110        
     110        res = serial_set_comm_props(serial, 1200, SERIAL_NO_PARITY, 8, 1);
    111111        if (EOK != res) {
    112112                free(buf);
     113                serial_close(serial);
    113114                async_hangup(sess);
    114115                return "Failed setting serial communication parameters";
     
    123124               
    124125                if (read < 0) {
    125                         exch = async_exchange_begin(sess);
    126                         async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
     126                        (void) serial_set_comm_props(serial, old_baud,
    127127                            old_par, old_word_size, old_stop);
    128                         async_exchange_end(exch);
    129128                       
    130129                        free(buf);
     130                        serial_close(serial);
    131131                        async_hangup(sess);
    132132                        return "Failed reading from serial device";
     
    134134               
    135135                if ((size_t) read > cnt - total) {
    136                         exch = async_exchange_begin(sess);
    137                         async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
     136                        (void) serial_set_comm_props(serial, old_baud,
    138137                            old_par, old_word_size, old_stop);
    139                         async_exchange_end(exch);
    140138                       
    141139                        free(buf);
     140                        serial_close(serial);
    142141                        async_hangup(sess);
    143142                        return "Read more data than expected";
     
    158157                       
    159158                        if (written < 0) {
    160                                 exch = async_exchange_begin(sess);
    161                                 async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
     159                                (void) serial_set_comm_props(serial, old_baud,
    162160                                    old_par, old_word_size, old_stop);
    163                                 async_exchange_end(exch);
    164161                               
    165162                                free(buf);
     163                                serial_close(serial);
    166164                                async_hangup(sess);
    167165                                return "Failed writing to serial device";
     
    169167                       
    170168                        if (written != read) {
    171                                 exch = async_exchange_begin(sess);
    172                                 async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
     169                                (void) serial_set_comm_props(serial, old_baud,
    173170                                    old_par, old_word_size, old_stop);
    174                                 async_exchange_end(exch);
    175171                               
    176172                                free(buf);
     173                                serial_close(serial);
    177174                                async_hangup(sess);
    178175                                return "Written less data than read from serial device";
     
    190187        ssize_t written = char_dev_write(sess, (void *) EOT, eot_size);
    191188       
    192         exch = async_exchange_begin(sess);
    193         async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
    194             old_par, old_word_size, old_stop);
    195         async_exchange_end(exch);
     189        (void) serial_set_comm_props(serial, old_baud, old_par, old_word_size,
     190            old_stop);
    196191       
    197192        free(buf);
     193        serial_close(serial);
    198194        async_hangup(sess);
    199195       
  • uspace/lib/c/Makefile

    rafec1be rc4c6025  
    118118        generic/io/kio.c \
    119119        generic/io/klog.c \
     120        generic/io/serial.c \
    120121        generic/io/snprintf.c \
    121122        generic/io/vprintf.c \
  • uspace/srv/hid/isdv4_tablet/isdv4.c

    rafec1be rc4c6025  
    2929#include <char_dev_iface.h>
    3030#include <errno.h>
     31#include <stdbool.h>
     32#include <stdint.h>
    3133#include <stdlib.h>
    3234#include <mem.h>
  • uspace/srv/hid/isdv4_tablet/isdv4.h

    rafec1be rc4c6025  
    2727 */
    2828
    29 #ifndef __ISDV4_H__
    30 #define __ISDV4_H__
     29#ifndef ISDV4_H_
     30#define ISDV4_H_
     31
     32#include <async.h>
    3133
    3234typedef struct isdv4_event isdv4_event_t;
  • uspace/srv/hid/isdv4_tablet/main.c

    rafec1be rc4c6025  
    2727 */
    2828
    29 #include <char_dev_iface.h>
     29#include <async.h>
    3030#include <errno.h>
    31 #include <ipc/serial_ctl.h>
     31#include <fibril_synch.h>
     32#include <io/serial.h>
     33#include <ipc/mouseev.h>
    3234#include <loc.h>
     35#include <stddef.h>
    3336#include <stdio.h>
    34 #include <fibril_synch.h>
    35 #include <abi/ipc/methods.h>
    36 #include <ipc/mouseev.h>
    37 #include <inttypes.h>
    3837#include <task.h>
    3938
     
    179178        sysarg_t baud = 38400;
    180179        service_id_t svc_id;
     180        serial_t *serial;
    181181        char *serial_port_name = NULL;
    182182
     
    268268        if (!sess) {
    269269                fprintf(stderr, "Failed connecting to service\n");
    270         }
    271 
    272         async_exch_t *exch = async_exchange_begin(sess);
    273         rc = async_req_4_0(exch, SERIAL_SET_COM_PROPS, baud,
    274             SERIAL_NO_PARITY, 8, 1);
    275         async_exchange_end(exch);
    276 
     270                return 2;
     271        }
     272
     273        rc = serial_open(sess, &serial);
     274        if (rc != EOK) {
     275                fprintf(stderr, "Failed opening serial port\n");
     276                return 2;
     277        }
     278
     279        rc = serial_set_comm_props(serial, baud, SERIAL_NO_PARITY, 8, 1);
    277280        if (rc != EOK) {
    278281                fprintf(stderr, "Failed setting serial properties\n");
Note: See TracChangeset for help on using the changeset viewer.