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

Ignore:
Timestamp:
2010-12-05T09:34:46Z (11 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master
Children:
75732da
Parents:
56b962d (diff), 35537a7 (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 with development/

File:
1 moved

Legend:

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

    r56b962d r84439d7  
    2727 */
    2828
    29 /** @addtogroup test_serial
    30  * @brief       test the serial port driver - read from the serial port
     29/** @addtogroup tester
     30 * @brief Test the serial port driver - loopback test
    3131 * @{
    3232 */
     
    3535 */
    3636
     37#include <inttypes.h>
    3738#include <errno.h>
    3839#include <stdlib.h>
     
    4748#include <str.h>
    4849#include <ipc/serial_ctl.h>
    49 
    50 #define NAME            "test serial"
    51 
    52 
    53 static void print_usage(void)
     50#include "../../tester.h"
     51
     52#define DEFAULT_COUNT  1024
     53#define DEFAULT_SLEEP  100000
     54#define EOT            "####> End of transfer <####\n"
     55
     56const char *test_serial1(void)
    5457{
    55         printf("Usage: \n test_serial count \n where count is the number of "
    56             "characters to be read\n");
    57 }
    58 
    59 int main(int argc, char *argv[])
    60 {
    61         if (argc != 2) {
    62                 printf(NAME ": incorrect number of arguments.\n");
    63                 print_usage();
    64                 return 0;
    65         }
    66        
    67         long int cnt = strtol(argv[1], NULL, 10);
    68        
    69         int res;
    70         res = devman_get_phone(DEVMAN_CLIENT, IPC_FLAG_BLOCKING);
     58        size_t cnt;
     59       
     60        if (test_argc < 1)
     61                cnt = DEFAULT_COUNT;
     62        else
     63                switch (str_size_t(test_argv[0], NULL, 0, true, &cnt)) {
     64                case EOK:
     65                        break;
     66                case EINVAL:
     67                        return "Invalid argument, unsigned integer expected";
     68                case EOVERFLOW:
     69                        return "Argument size overflow";
     70                default:
     71                        return "Unexpected argument error";
     72                }
     73       
     74        int res = devman_get_phone(DEVMAN_CLIENT, IPC_FLAG_BLOCKING);
     75       
    7176        devman_handle_t handle;
    72        
    7377        res = devman_device_get_handle("/hw/pci0/00:01.0/com1", &handle,
    7478            IPC_FLAG_BLOCKING);
    75         if (EOK != res) {
    76                 printf(NAME ": could not get the device handle, errno = %d.\n",
    77                     -res);
    78                 return 1;
    79         }
    80        
    81         printf(NAME ": trying to read %d characters from device with handle "
    82             "%d.\n", cnt, handle);
     79        if (res != EOK)
     80                return "Could not get serial device handle";
    8381       
    8482        int phone = devman_device_connect(handle, IPC_FLAG_BLOCKING);
    85         if (0 > phone) {
    86                 printf(NAME ": could not connect to the device, errno = %d.\n",
    87                     -res);
    88                 devman_hangup_phone(DEVMAN_CLIENT);
    89                 return 2;
     83        if (phone < 0) {
     84                devman_hangup_phone(DEVMAN_CLIENT);
     85                return "Unable to connect to serial device";
    9086        }
    9187       
    9288        char *buf = (char *) malloc(cnt + 1);
    93         if (NULL == buf) {
    94                 printf(NAME ": failed to allocate the input buffer\n");
     89        if (buf == NULL) {
    9590                ipc_hangup(phone);
    9691                devman_hangup_phone(DEVMAN_CLIENT);
    97                 return 3;
    98         }
    99        
    100         ipcarg_t old_baud, old_par, old_stop, old_word_size;
     92                return "Failed to allocate input buffer";
     93        }
     94       
     95        ipcarg_t old_baud;
     96        ipcarg_t old_par;
     97        ipcarg_t old_stop;
     98        ipcarg_t old_word_size;
    10199       
    102100        res = ipc_call_sync_0_4(phone, SERIAL_GET_COM_PROPS, &old_baud,
    103101            &old_par, &old_word_size, &old_stop);
    104         if (EOK != res) {
    105                 printf(NAME ": failed to get old communication parameters, "
    106                     "errno = %d.\n", -res);
    107                 devman_hangup_phone(DEVMAN_CLIENT);
     102        if (res != EOK) {
     103                free(buf);
    108104                ipc_hangup(phone);
    109                 free(buf);
    110                 return 4;
     105                devman_hangup_phone(DEVMAN_CLIENT);
     106                return "Failed to get old serial communication parameters";
    111107        }
    112108       
     
    114110            SERIAL_NO_PARITY, 8, 1);
    115111        if (EOK != res) {
    116                 printf(NAME ": failed to set communication parameters, errno = "
    117                     "%d.\n", -res);
    118                 devman_hangup_phone(DEVMAN_CLIENT);
     112                free(buf);
    119113                ipc_hangup(phone);
    120                 free(buf);
    121                 return 4;
    122         }
    123        
    124         int total = 0;
    125         int read = 0;
     114                devman_hangup_phone(DEVMAN_CLIENT);
     115                return "Failed to set serial communication parameters";
     116        }
     117       
     118        TPRINTF("Trying to read %zu characters from serial device "
     119            "(handle=%" PRIun ")\n", cnt, handle);
     120       
     121        size_t total = 0;
    126122        while (total < cnt) {
    127                 read = read_dev(phone, buf, cnt - total);
    128                 if (0 > read) {
    129                         printf(NAME ": failed read from device, errno = %d.\n",
    130                             -read);
     123                ssize_t read = read_dev(phone, buf, cnt - total);
     124               
     125                if (read < 0) {
    131126                        ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
    132127                            old_par, old_word_size, old_stop);
     128                        free(buf);
    133129                        ipc_hangup(phone);
    134130                        devman_hangup_phone(DEVMAN_CLIENT);
     131                        return "Failed read from serial device";
     132                }
     133               
     134                if ((size_t) read > cnt - total) {
     135                        ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     136                            old_par, old_word_size, old_stop);
    135137                        free(buf);
    136                         return 5;
    137                 }
    138                 total += read;
    139                 if (read > 0) {
     138                        ipc_hangup(phone);
     139                        devman_hangup_phone(DEVMAN_CLIENT);
     140                        return "Read more data than expected";
     141                }
     142               
     143                TPRINTF("Read %zd bytes\n", read);
     144               
     145                if (read == 0)
     146                        usleep(DEFAULT_SLEEP);
     147                else {
    140148                        buf[read] = 0;
    141                         printf(buf);
     149                       
    142150                        /*
    143151                         * Write data back to the device to test the opposite
    144152                         * direction of data transfer.
    145153                         */
    146                         write_dev(phone, buf, read);
    147                 } else {
    148                         usleep(100000);
    149                 }       
    150         }
    151        
    152         const char *the_end = "\n---------\nTHE END\n---------\n";
    153         write_dev(phone, (void *)the_end, str_size(the_end));
    154        
    155         /* restore original communication settings */
    156         ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud, old_par,
    157             old_word_size, old_stop);
     154                        ssize_t written = write_dev(phone, buf, read);
     155                       
     156                        if (written < 0) {
     157                                ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     158                                    old_par, old_word_size, old_stop);
     159                                free(buf);
     160                                ipc_hangup(phone);
     161                                devman_hangup_phone(DEVMAN_CLIENT);
     162                                return "Failed write to serial device";
     163                        }
     164                       
     165                        if (written != read) {
     166                                ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     167                                    old_par, old_word_size, old_stop);
     168                                free(buf);
     169                                ipc_hangup(phone);
     170                                devman_hangup_phone(DEVMAN_CLIENT);
     171                                return "Written less data than read from serial device";
     172                        }
     173                       
     174                        TPRINTF("Written %zd bytes\n", written);
     175                }
     176               
     177                total += read;
     178        }
     179       
     180        TPRINTF("Trying to write EOT banner to the serial device\n");
     181       
     182        size_t eot_size = str_size(EOT);
     183        ssize_t written = write_dev(phone, (void *) EOT, eot_size);
     184       
     185        ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     186            old_par, old_word_size, old_stop);
     187        free(buf);
     188        ipc_hangup(phone);
    158189        devman_hangup_phone(DEVMAN_CLIENT);
    159         ipc_hangup(phone);
    160         free(buf);
    161        
    162         return 0;
     190       
     191        if (written < 0)
     192                return "Failed to write EOT banner to serial device";
     193       
     194        if ((size_t) written != eot_size)
     195                return "Written less data than the size of the EOT banner "
     196                    "to serial device";
     197       
     198        return NULL;
    163199}
    164200
Note: See TracChangeset for help on using the changeset viewer.