Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/tester/hw/serial/serial1.c

    r74017ce rc4c6025  
    3535 */
    3636
    37 #include <async.h>
     37#include <inttypes.h>
    3838#include <errno.h>
    39 #include <io/chardev.h>
    40 #include <io/serial.h>
    41 #include <ipc/services.h>
    42 #include <loc.h>
    4339#include <stdlib.h>
    4440#include <stdio.h>
    4541#include <stddef.h>
     42#include <async.h>
     43#include <thread.h>
     44#include <ipc/services.h>
     45#include <loc.h>
     46#include <char_dev_iface.h>
    4647#include <str.h>
    47 #include <thread.h>
     48#include <io/serial.h>
    4849#include "../../tester.h"
    4950
     
    5657        size_t cnt;
    5758        serial_t *serial;
    58         chardev_t *chardev;
    59         int rc;
    60         size_t nread;
    61         size_t nwritten;
    6259       
    6360        if (test_argc < 1)
     
    8683                return "Failed connecting to serial device";
    8784       
    88         res = chardev_open(sess, &chardev);
    89         if (res != EOK) {
    90                 async_hangup(sess);
     85        res = serial_open(sess, &serial);
     86        if (res != EOK)
    9187                return "Failed opening serial port";
    92         }
    93        
    94         res = serial_open(sess, &serial);
    95         if (res != EOK) {
    96                 chardev_close(chardev);
    97                 async_hangup(sess);
    98                 return "Failed opening serial port";
    99         }
    10088       
    10189        char *buf = (char *) malloc(cnt + 1);
    10290        if (buf == NULL) {
    103                 chardev_close(chardev);
    10491                serial_close(serial);
    10592                async_hangup(sess);
     
    116103        if (res != EOK) {
    117104                free(buf);
    118                 chardev_close(chardev);
    119105                serial_close(serial);
    120106                async_hangup(sess);
     
    125111        if (EOK != res) {
    126112                free(buf);
    127                 chardev_close(chardev);
    128113                serial_close(serial);
    129114                async_hangup(sess);
     
    136121        size_t total = 0;
    137122        while (total < cnt) {
    138                
    139                 rc = chardev_read(chardev, buf, cnt - total, &nread);
    140                 if (rc != EOK) {
     123                ssize_t read = char_dev_read(sess, buf, cnt - total);
     124               
     125                if (read < 0) {
    141126                        (void) serial_set_comm_props(serial, old_baud,
    142127                            old_par, old_word_size, old_stop);
    143128                       
    144129                        free(buf);
    145                         chardev_close(chardev);
    146130                        serial_close(serial);
    147131                        async_hangup(sess);
     
    149133                }
    150134               
    151                 if (nread > cnt - total) {
     135                if ((size_t) read > cnt - total) {
    152136                        (void) serial_set_comm_props(serial, old_baud,
    153137                            old_par, old_word_size, old_stop);
    154138                       
    155139                        free(buf);
    156                         chardev_close(chardev);
    157140                        serial_close(serial);
    158141                        async_hangup(sess);
     
    160143                }
    161144               
    162                 TPRINTF("Read %zd bytes\n", nread);
    163                
    164                 if (nread == 0)
     145                TPRINTF("Read %zd bytes\n", read);
     146               
     147                if (read == 0)
    165148                        thread_usleep(DEFAULT_SLEEP);
    166149                else {
    167                         buf[nread] = 0;
     150                        buf[read] = 0;
    168151                       
    169152                        /*
     
    171154                         * direction of data transfer.
    172155                         */
    173                         rc = chardev_write(chardev, buf, nread, &nwritten);
    174                         if (rc != EOK) {
     156                        ssize_t written = char_dev_write(sess, buf, read);
     157                       
     158                        if (written < 0) {
    175159                                (void) serial_set_comm_props(serial, old_baud,
    176160                                    old_par, old_word_size, old_stop);
    177161                               
    178162                                free(buf);
    179                                 chardev_close(chardev);
    180163                                serial_close(serial);
    181164                                async_hangup(sess);
     
    183166                        }
    184167                       
    185                         if (nwritten != nread) {
     168                        if (written != read) {
    186169                                (void) serial_set_comm_props(serial, old_baud,
    187170                                    old_par, old_word_size, old_stop);
    188171                               
    189172                                free(buf);
    190                                 chardev_close(chardev);
    191173                                serial_close(serial);
    192174                                async_hangup(sess);
     
    194176                        }
    195177                       
    196                         TPRINTF("Written %zd bytes\n", nwritten);
    197                 }
    198                
    199                 total += nread;
     178                        TPRINTF("Written %zd bytes\n", written);
     179                }
     180               
     181                total += read;
    200182        }
    201183       
     
    203185       
    204186        size_t eot_size = str_size(EOT);
    205         rc = chardev_write(chardev, (void *) EOT, eot_size, &nwritten);
     187        ssize_t written = char_dev_write(sess, (void *) EOT, eot_size);
    206188       
    207189        (void) serial_set_comm_props(serial, old_baud, old_par, old_word_size,
     
    209191       
    210192        free(buf);
    211         chardev_close(chardev);
    212193        serial_close(serial);
    213194        async_hangup(sess);
    214195       
    215         if (rc != EOK)
     196        if (written < 0)
    216197                return "Failed to write EOT banner to serial device";
    217198       
    218         if (nwritten != eot_size)
     199        if ((size_t) written != eot_size)
    219200                return "Written less data than the size of the EOT banner "
    220201                    "to serial device";
Note: See TracChangeset for help on using the changeset viewer.