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

File:

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

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

@@ -35 +35 @@
  */
 
-#include <inttypes.h>
+#include <async.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"
 
@@ -56 +54 @@
 {
         size_t cnt;
+        serial_t *serial;
+        chardev_t *chardev;
+        int rc;
+        size_t nread;
+        size_t nwritten;
         
         if (test_argc < 1)
@@ -79 +82 @@
         async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
             IPC_FLAG_BLOCKING);
-        if (!sess)
+        if (sess == NULL)
                 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";
         }
         
-        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);
-        
+        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);
         if (res != EOK) {
                 free(buf);
+                chardev_close(chardev);
+                serial_close(serial);
                 async_hangup(sess);
                 return "Failed to get old serial communication parameters";
         }
         
-        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);
-        
+        res = serial_set_comm_props(serial, 1200, SERIAL_NO_PARITY, 8, 1);
         if (EOK != res) {
                 free(buf);
+                chardev_close(chardev);
+                serial_close(serial);
                 async_hangup(sess);
                 return "Failed setting serial communication parameters";
@@ -120 +135 @@
         size_t total = 0;
         while (total < cnt) {
-                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);
+                
+                rc = chardev_read(chardev, buf, cnt - total, &nread);
+                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 reading from serial device";
                 }
                 
-                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);
+                if (nread > cnt - total) {
+                        (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 "Read more data than expected";
                 }
                 
-                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;
+                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;
         }
         
@@ -188 +198 @@
         
         size_t eot_size = str_size(EOT);
-        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);
+        rc = chardev_write(chardev, (void *) EOT, eot_size, &nwritten);
+        
+        (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);
         
-        if (written < 0)
+        if (rc != EOK)
                 return "Failed to write EOT banner to serial device";
         
-        if ((size_t) written != eot_size)
+        if (nwritten != eot_size)
                 return "Written less data than the size of the EOT banner "
                     "to serial device";