Changes in uspace/app/tester/hw/serial/serial1.c [f300523:8d2dd7f2] in mainline

File:

• uspace/app/tester/hw/serial/serial1.c (modified) (5 diffs)

uspace/app/tester/hw/serial/serial1.c

@@ -35 +35 @@
  */
 
-#include <async.h>
+#include <inttypes.h>
 #include <errno.h>
-#include <io/chardev.h>
-#include <io/serial.h>
-#include <ipc/services.h>
-#include <loc.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stddef.h>
+#include <async.h>
+#include <thread.h>
+#include <ipc/services.h>
+#include <loc.h>
+#include <char_dev_iface.h>
 #include <str.h>
+#include <ipc/serial_ctl.h>
 #include "../../tester.h"
 
@@ -54 +56 @@
 {
         size_t cnt;
-        serial_t *serial;
-        chardev_t *chardev;
-        int rc;
-        size_t nread;
-        size_t nwritten;
         
         if (test_argc < 1)
@@ -82 +79 @@
         async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
             IPC_FLAG_BLOCKING);
-        if (sess == NULL)
+        if (!sess)
                 return "Failed connecting to serial device";
-        
-        res = chardev_open(sess, &chardev);
-        if (res != EOK) {
-                async_hangup(sess);
-                return "Failed opening serial port";
-        }
-        
-        res = serial_open(sess, &serial);
-        if (res != EOK) {
-                chardev_close(chardev);
-                async_hangup(sess);
-                return "Failed opening serial port";
-        }
         
         char *buf = (char *) malloc(cnt + 1);
         if (buf == NULL) {
-                chardev_close(chardev);
-                serial_close(serial);
                 async_hangup(sess);
                 return "Failed allocating input buffer";
         }
         
-        unsigned old_baud;
-        serial_parity_t old_par;
-        unsigned old_stop;
-        unsigned old_word_size;
-        
-        res = serial_get_comm_props(serial, &old_baud, &old_par,
-            &old_word_size, &old_stop);
+        sysarg_t old_baud;
+        sysarg_t old_par;
+        sysarg_t old_stop;
+        sysarg_t old_word_size;
+        
+        async_exch_t *exch = async_exchange_begin(sess);
+        res = async_req_0_4(exch, SERIAL_GET_COM_PROPS, &old_baud,
+            &old_par, &old_word_size, &old_stop);
+        async_exchange_end(exch);
+        
         if (res != EOK) {
                 free(buf);
-                chardev_close(chardev);
-                serial_close(serial);
                 async_hangup(sess);
                 return "Failed to get old serial communication parameters";
         }
         
-        res = serial_set_comm_props(serial, 1200, SERIAL_NO_PARITY, 8, 1);
+        exch = async_exchange_begin(sess);
+        res = async_req_4_0(exch, SERIAL_SET_COM_PROPS, 1200,
+            SERIAL_NO_PARITY, 8, 1);
+        async_exchange_end(exch);
+        
         if (EOK != res) {
                 free(buf);
-                chardev_close(chardev);
-                serial_close(serial);
                 async_hangup(sess);
                 return "Failed setting serial communication parameters";
@@ -135 +120 @@
         size_t total = 0;
         while (total < cnt) {
-                
-                rc = chardev_read(chardev, buf, cnt - total, &nread);
-                if (rc != EOK) {
-                        (void) serial_set_comm_props(serial, old_baud,
+                ssize_t read = char_dev_read(sess, buf, cnt - total);
+                
+                if (read < 0) {
+                        exch = async_exchange_begin(sess);
+                        async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
                             old_par, old_word_size, old_stop);
+                        async_exchange_end(exch);
                         
                         free(buf);
-                        chardev_close(chardev);
-                        serial_close(serial);
                         async_hangup(sess);
                         return "Failed reading from serial device";
                 }
                 
-                if (nread > cnt - total) {
-                        (void) serial_set_comm_props(serial, old_baud,
+                if ((size_t) read > cnt - total) {
+                        exch = async_exchange_begin(sess);
+                        async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
                             old_par, old_word_size, old_stop);
+                        async_exchange_end(exch);
                         
                         free(buf);
-                        chardev_close(chardev);
-                        serial_close(serial);
                         async_hangup(sess);
                         return "Read more data than expected";
                 }
                 
-                TPRINTF("Read %zd bytes\n", nread);
-                
-                buf[nread] = 0;
-                
-                /*
-                 * Write data back to the device to test the opposite
-                 * direction of data transfer.
-                 */
-                rc = chardev_write(chardev, buf, nread, &nwritten);
-                if (rc != EOK) {
-                        (void) serial_set_comm_props(serial, old_baud,
-                            old_par, old_word_size, old_stop);
-                        
-                        free(buf);
-                        chardev_close(chardev);
-                        serial_close(serial);
-                        async_hangup(sess);
-                        return "Failed writing to serial device";
-                }
-                
-                if (nwritten != nread) {
-                        (void) serial_set_comm_props(serial, old_baud,
-                            old_par, old_word_size, old_stop);
-                        
-                        free(buf);
-                        chardev_close(chardev);
-                        serial_close(serial);
-                        async_hangup(sess);
-                        return "Written less data than read from serial device";
-                }
-                
-                TPRINTF("Written %zd bytes\n", nwritten);
-                
-                total += nread;
+                TPRINTF("Read %zd bytes\n", read);
+                
+                if (read == 0)
+                        thread_usleep(DEFAULT_SLEEP);
+                else {
+                        buf[read] = 0;
+                        
+                        /*
+                         * Write data back to the device to test the opposite
+                         * direction of data transfer.
+                         */
+                        ssize_t written = char_dev_write(sess, buf, read);
+                        
+                        if (written < 0) {
+                                exch = async_exchange_begin(sess);
+                                async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
+                                    old_par, old_word_size, old_stop);
+                                async_exchange_end(exch);
+                                
+                                free(buf);
+                                async_hangup(sess);
+                                return "Failed writing to serial device";
+                        }
+                        
+                        if (written != read) {
+                                exch = async_exchange_begin(sess);
+                                async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
+                                    old_par, old_word_size, old_stop);
+                                async_exchange_end(exch);
+                                
+                                free(buf);
+                                async_hangup(sess);
+                                return "Written less data than read from serial device";
+                        }
+                        
+                        TPRINTF("Written %zd bytes\n", written);
+                }
+                
+                total += read;
         }
         
@@ -198 +188 @@
         
         size_t eot_size = str_size(EOT);
-        rc = chardev_write(chardev, (void *) EOT, eot_size, &nwritten);
-        
-        (void) serial_set_comm_props(serial, old_baud, old_par, old_word_size,
-            old_stop);
+        ssize_t written = char_dev_write(sess, (void *) EOT, eot_size);
+        
+        exch = async_exchange_begin(sess);
+        async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
+            old_par, old_word_size, old_stop);
+        async_exchange_end(exch);
         
         free(buf);
-        chardev_close(chardev);
-        serial_close(serial);
         async_hangup(sess);
         
-        if (rc != EOK)
+        if (written < 0)
                 return "Failed to write EOT banner to serial device";
         
-        if (nwritten != eot_size)
+        if ((size_t) written != eot_size)
                 return "Written less data than the size of the EOT banner "
                     "to serial device";