source: rtems/testsuites/libtests/termios01/init.c @ 55e0be36

Last change on this file since 55e0be36 was 55e0be36, checked in by Sebastian Huber <sebastian.huber@…>, on Sep 16, 2016 at 10:58:06 AM

termios: Use IMFS nodes for new Termios devices

This makes the new Termios devices independent of device major/minor
numbers. It enables BSP independent Termios device drivers which may
reside in the cpukit domain. These drivers require an IMFS and do not
work with the device file system. However, the device file system
should go away in the future.

  • Property mode set to 100644
File size: 21.8 KB
RevLine 
[4d5b156]1/*
[8cd0bb0f]2 *  COPYRIGHT (c) 1989-2010.
[4d5b156]3 *  On-Line Applications Research Corporation (OAR).
4 *
5 *  The license and distribution terms for this file may be
6 *  found in the file LICENSE in this distribution or at
[c499856]7 *  http://www.rtems.org/license/LICENSE.
[4d5b156]8 */
9
[7d3f9c6]10#ifdef HAVE_CONFIG_H
11#include "config.h"
12#endif
13
[4d5b156]14#include "tmacros.h"
15#include <termios.h>
[ef8c00bc]16#include <rtems/libcsupport.h>
17#include <rtems/malloc.h>
[4d5b156]18#include <rtems/termiostypes.h>
19#include <fcntl.h>
[a9127a2e]20#include <limits.h>
[55e0be36]21#include <unistd.h>
[4d5b156]22#include <sys/errno.h>
[55e0be36]23#include <sys/stat.h>
[4d5b156]24
[f8b2eb03]25const char rtems_test_name[] = "TERMIOS 1";
26
[1466425]27/* rtems_termios_baud_t is a typedefs to int32_t */
28#define PRIdrtems_termios_baud_t PRId32
29
[4d5b156]30/*
31 *  Termios Test Driver
32 */
33#include "termios_testdriver.h"
34
[f55595e]35static const rtems_driver_address_table test_driver =
36  TERMIOS_TEST_DRIVER_TABLE_ENTRY;
[4d5b156]37
38/*
39 *  Baud Rate Constant Mapping Entry
40 */
41typedef struct {
[f55595e]42  tcflag_t constant;
[009dfd0]43  rtems_termios_baud_t baud;
[4d5b156]44} termios_baud_test_r;
45
[f55595e]46#define INVALID_CONSTANT ((tcflag_t) -2)
47
48#define INVALID_BAUD ((rtems_termios_baud_t) -2)
[4d5b156]49/*
50 *  Baud Rate Constant Mapping Table
51 */
[f55595e]52static const termios_baud_test_r baud_table[] = {
[4d5b156]53  { B0,           0 },
54  { B50,         50 },
55  { B75,         75 },
56  { B110,       110 },
57  { B134,       134 },
58  { B150,       150 },
59  { B200,       200 },
60  { B300,       300 },
61  { B600,       600 },
62  { B1200,     1200 },
63  { B1800,     1800 },
64  { B2400,     2400 },
65  { B4800,     4800 },
66  { B9600,     9600 },
67  { B19200,   19200 },
68  { B38400,   38400 },
69  { B57600,   57600 },
70  { B115200, 115200 },
71  { B230400, 230400 },
72  { B460800, 460800 },
[f55595e]73  { INVALID_CONSTANT, INVALID_BAUD }
[4d5b156]74};
75
76/*
77 *  Character Size Constant Mapping Entry
78 */
79typedef struct {
[f55595e]80  tcflag_t constant;
[4d5b156]81  int bits;
82} termios_character_size_test_r;
83
84/*
85 *  Character Size Constant Mapping Table
86 */
[f55595e]87static const termios_character_size_test_r char_size_table[] = {
[4d5b156]88  { CS5,      5 },
89  { CS6,      6 },
90  { CS7,      7 },
91  { CS8,      8 },
[f55595e]92  { INVALID_CONSTANT, -1 }
[4d5b156]93};
94
95/*
96 *  Parity Constant Mapping Entry
97 */
98typedef struct {
[f55595e]99  tcflag_t constant;
[1466425]100  const char *parity;
[4d5b156]101} termios_parity_test_r;
102
103/*
104 *  Parity Constant Mapping Table
105 */
[f55595e]106static const termios_parity_test_r parity_table[] = {
[4d5b156]107  { 0,                "none" },
108  { PARENB,           "even" },
109  { PARENB | PARODD,  "odd" },
[f55595e]110  { INVALID_CONSTANT, NULL }
[4d5b156]111};
112
113/*
114 *  Stop Bit Constant Mapping Entry
115 */
116typedef struct {
[f55595e]117  tcflag_t constant;
118  int stop;
[4d5b156]119} termios_stop_bits_test_r;
120
121/*
122 *  Stop Bit Constant Mapping Table
123 */
[f55595e]124static const termios_stop_bits_test_r stop_bits_table[] = {
[4d5b156]125  { 0,       1 },
126  { CSTOPB,  2 },
[f55595e]127  { INVALID_CONSTANT, -1 }
[4d5b156]128};
129
130/*
131 *  Test converting baud rate into an index
132 */
[f55595e]133static void test_termios_baud2index(void)
[4d5b156]134{
135  int i;
136  int index;
137
[8cd0bb0f]138  puts( "Test termios_baud2index..." );
[e958d79b]139  puts( "termios_baud_to_index(-2) - NOT OK" );
[f55595e]140  i = rtems_termios_baud_to_index( INVALID_CONSTANT );
[500fcd5]141  rtems_test_assert( i == -1 );
[e958d79b]142
[f55595e]143  for (i=0 ; baud_table[i].constant != INVALID_CONSTANT ; i++ ) {
[ab59de45]144    printf(
145      "termios_baud_to_index(B%" PRIdrtems_termios_baud_t ") - OK\n",
146      baud_table[i].baud
147    );
148    index = rtems_termios_baud_to_index( baud_table[i].constant );
149    if ( index != i ) {
150      printf( "ERROR - returned %d should be %d\n", index, i );
151      rtems_test_exit(0);
[4d5b156]152    }
[ab59de45]153  }
[4d5b156]154}
155
156/*
157 *  Test converting termios baud constant to baud number
158 */
[f55595e]159static void test_termios_baud2number(void)
[4d5b156]160{
161  int i;
[f55595e]162  rtems_termios_baud_t number;
[4d5b156]163
164  puts(
165    "\n"
166    "Test termios_baud2number..."
167  );
[e958d79b]168  puts( "termios_baud_to_number(-2) - NOT OK" );
[f55595e]169  number = rtems_termios_baud_to_number( INVALID_CONSTANT );
170  rtems_test_assert( number == 0 );
[e958d79b]171
[f55595e]172  for (i=0 ; baud_table[i].constant != INVALID_CONSTANT ; i++ ) {
[8cd0bb0f]173    printf(
174      "termios_baud_to_number(B%" PRIdrtems_termios_baud_t ") - OK\n",
175      baud_table[i].baud
176    );
[009dfd0]177    number = rtems_termios_baud_to_number( baud_table[i].constant );
[4d5b156]178    if ( number != baud_table[i].baud ) {
179      printf(
[f55595e]180        "ERROR - returned %" PRIdrtems_termios_baud_t
181        " should be %" PRIdrtems_termios_baud_t "\n",
[4d5b156]182        number,
183        baud_table[i].baud
184      );
185      rtems_test_exit(0);
186    }
187  }
188}
189
190/*
191 *  Test converting baud number to termios baud constant
192 */
[f55595e]193static void test_termios_number_to_baud(void)
[4d5b156]194{
195  int i;
[f55595e]196  tcflag_t termios_baud;
[4d5b156]197
198  puts(
199    "\n"
200    "Test termios_number_to_baud..."
201  );
[e958d79b]202  puts( "termios_number_to_baud(-2) - NOT OK" );
[f55595e]203  termios_baud = rtems_termios_number_to_baud( INVALID_BAUD );
204  rtems_test_assert( termios_baud == 0 );
[e958d79b]205
[f55595e]206  for (i=0 ; baud_table[i].constant != INVALID_CONSTANT ; i++ ) {
[8cd0bb0f]207    printf(
208      "termios_number_to_baud(B%" PRIdrtems_termios_baud_t ") - OK\n",
209      baud_table[i].baud
210    );
[009dfd0]211    termios_baud = rtems_termios_number_to_baud( baud_table[i].baud );
[4d5b156]212    if ( termios_baud != baud_table[i].constant ) {
213      printf(
214        "ERROR - returned %d should be %d\n",
215        termios_baud,
216        baud_table[i].constant
217      );
218      rtems_test_exit(0);
219    }
220  }
221}
222
223/*
224 *  Test all the baud rate options
225 */
[f55595e]226static void test_termios_set_baud(
[4d5b156]227  int test
228)
229{
230  int             sc;
231  int             i;
232  struct termios  attr;
233
234  puts( "Test termios setting device baud rate..." );
[f55595e]235  for (i=0 ; baud_table[i].constant != INVALID_CONSTANT ; i++ ) {
236    tcflag_t cbaud = CBAUD;
237
[4d5b156]238    sc = tcgetattr( test, &attr );
239    if ( sc != 0 ) {
240      printf( "ERROR - return %d\n", sc );
241      rtems_test_exit(0);
242    }
243
[f55595e]244    attr.c_cflag &= ~cbaud;
[4d5b156]245    attr.c_cflag |= baud_table[i].constant;
246
[8cd0bb0f]247    printf(
248      "tcsetattr(TCSANOW, B%" PRIdrtems_termios_baud_t ") - OK\n",
249      baud_table[i].baud
250    );
[4d5b156]251    sc = tcsetattr( test, TCSANOW, &attr );
252    if ( sc != 0 ) {
253      printf( "ERROR - return %d\n", sc );
254      rtems_test_exit(0);
255    }
256
[8cd0bb0f]257    printf(
258      "tcsetattr(TCSADRAIN, B%" PRIdrtems_termios_baud_t ") - OK\n",
259      baud_table[i].baud
260    );
[4d5b156]261    sc = tcsetattr( test, TCSANOW, &attr );
262    if ( sc != 0 ) {
263      printf( "ERROR - return %d\n", sc );
264      rtems_test_exit(0);
265    }
266  }
267}
268
269/*
270 *  Test all the character size options
271 */
[f55595e]272static void test_termios_set_charsize(
[4d5b156]273  int test
274)
275{
276  int             sc;
277  int             i;
278  struct termios  attr;
279
280  puts(
281    "\n"
282    "Test termios setting device character size ..."
283  );
[f55595e]284  for (i=0 ; char_size_table[i].constant != INVALID_CONSTANT ; i++ ) {
285    tcflag_t csize = CSIZE;
286
[4d5b156]287    sc = tcgetattr( test, &attr );
288    if ( sc != 0 ) {
289      printf( "ERROR - return %d\n", sc );
290      rtems_test_exit(0);
291    }
292
[f55595e]293    attr.c_cflag &= ~csize;
[4d5b156]294    attr.c_cflag |= char_size_table[i].constant;
295
296    printf( "tcsetattr(TCSANOW, CS%d) - OK\n", char_size_table[i].bits );
297    sc = tcsetattr( test, TCSANOW, &attr );
298    if ( sc != 0 ) {
299      printf( "ERROR - return %d\n", sc );
300      rtems_test_exit(0);
301    }
302
303    printf( "tcsetattr(TCSADRAIN, CS%d) - OK\n", char_size_table[i].bits );
304    sc = tcsetattr( test, TCSANOW, &attr );
305    if ( sc != 0 ) {
306      printf( "ERROR - return %d\n", sc );
307      rtems_test_exit(0);
308    }
309  }
310}
311
312/*
313 *  Test all the parity options
314 */
[f55595e]315static void test_termios_set_parity(
[4d5b156]316  int test
317)
318{
319  int             sc;
320  int             i;
321  struct termios  attr;
322
323  puts(
324    "\n"
325    "Test termios setting device parity ..."
326  );
[f55595e]327  for (i=0 ; parity_table[i].constant != INVALID_CONSTANT ; i++ ) {
328    tcflag_t par = PARENB | PARODD;
329
[4d5b156]330    sc = tcgetattr( test, &attr );
331    if ( sc != 0 ) {
332      printf( "ERROR - return %d\n", sc );
333      rtems_test_exit(0);
334    }
335
[f55595e]336    attr.c_cflag &= ~par;
[4d5b156]337    attr.c_cflag |= parity_table[i].constant;
338
339    printf( "tcsetattr(TCSANOW, %s) - OK\n", parity_table[i].parity );
340    sc = tcsetattr( test, TCSANOW, &attr );
341    if ( sc != 0 ) {
342      printf( "ERROR - return %d\n", sc );
343      rtems_test_exit(0);
344    }
345
346    printf( "tcsetattr(TCSADRAIN, %s) - OK\n", parity_table[i].parity );
347    sc = tcsetattr( test, TCSANOW, &attr );
348    if ( sc != 0 ) {
349      printf( "ERROR - return %d\n", sc );
350      rtems_test_exit(0);
351    }
352  }
353}
354
355/*
356 *  Test all the stop bit options
357 */
[f55595e]358static void test_termios_set_stop_bits(
[4d5b156]359  int test
360)
361{
362  int             sc;
363  int             i;
364  struct termios  attr;
365
366  puts(
367    "\n"
368    "Test termios setting device character size ..."
369  );
[f55595e]370  for (i=0 ; stop_bits_table[i].constant != INVALID_CONSTANT ; i++ ) {
371    tcflag_t cstopb = CSTOPB;
372
[4d5b156]373    sc = tcgetattr( test, &attr );
374    if ( sc != 0 ) {
375      printf( "ERROR - return %d\n", sc );
376      rtems_test_exit(0);
377    }
378
[f55595e]379    attr.c_cflag &= ~cstopb;
[4d5b156]380    attr.c_cflag |= stop_bits_table[i].constant;
381
382    printf( "tcsetattr(TCSANOW, %d bit%s) - OK\n",
383      stop_bits_table[i].stop,
384      ((stop_bits_table[i].stop == 1) ? "" : "s")
385    );
386    sc = tcsetattr( test, TCSANOW, &attr );
387    if ( sc != 0 ) {
388      printf( "ERROR - return %d\n", sc );
389      rtems_test_exit(0);
390    }
391
392    printf( "tcsetattr(TCSADRAIN, %d bits) - OK\n", stop_bits_table[i].stop );
393    sc = tcsetattr( test, TCSANOW, &attr );
394    if ( sc != 0 ) {
395      printf( "ERROR - return %d\n", sc );
396      rtems_test_exit(0);
397    }
398  }
399}
400
[f55595e]401static void test_termios_cfoutspeed(void)
[9f5f6f53]402{
403  int i;
404  int sc;
405  speed_t speed;
406  struct termios term;
407  tcflag_t        bad;
408
409  bad = CBAUD << 1;
410  memset( &term, '\0', sizeof(term) );
411  puts( "cfsetospeed(BAD BAUD) - EINVAL" );
412  sc = cfsetospeed( &term, bad );
413  rtems_test_assert( sc == -1 );
414  rtems_test_assert( errno == EINVAL );
415
[f55595e]416  for (i=0 ; baud_table[i].constant != INVALID_CONSTANT ; i++ ) {
[9f5f6f53]417    memset( &term, '\0', sizeof(term) );
418    printf(
419      "cfsetospeed(B%" PRIdrtems_termios_baud_t ") - OK\n",
420      baud_table[i].baud
421    );
422    sc = cfsetospeed( &term, baud_table[i].constant );
423    rtems_test_assert( !sc );
424    printf(
425      "cfgetospeed(B%" PRIdrtems_termios_baud_t ") - OK\n",
426      baud_table[i].baud
427    );
428    speed = cfgetospeed( &term );
429    rtems_test_assert( speed == baud_table[i].constant );
430  }
431}
432
[f55595e]433static void test_termios_cfinspeed(void)
[9f5f6f53]434{
435  int             i;
436  int             sc;
437  speed_t         speed;
438  struct termios  term;
439  tcflag_t        bad;
440
441  bad = CBAUD << 1;
442  memset( &term, '\0', sizeof(term) );
443  puts( "cfsetispeed(BAD BAUD) - EINVAL" );
444  sc = cfsetispeed( &term, bad );
445  rtems_test_assert( sc == -1 );
446  rtems_test_assert( errno == EINVAL );
447
[f55595e]448  for (i=0 ; baud_table[i].constant != INVALID_CONSTANT ; i++ ) {
[9f5f6f53]449    memset( &term, '\0', sizeof(term) );
450    printf(
451      "cfsetispeed(B%" PRIdrtems_termios_baud_t ") - OK\n",
452      baud_table[i].baud
453    );
454    sc = cfsetispeed( &term, baud_table[i].constant );
455    rtems_test_assert( !sc );
456
457    printf(
458      "cfgetispeed(B%" PRIdrtems_termios_baud_t ") - OK\n",
459      baud_table[i].baud
460    );
461    speed = cfgetispeed( &term );
462    rtems_test_assert( speed == baud_table[i].constant );
463  }
464}
465
[3096f5c9]466static void test_termios_cfsetspeed(void)
467{
468  int             i;
469  int             status;
470  speed_t         speed;
471  struct termios  term;
472  tcflag_t        bad;
473
474  bad = CBAUD << 1;
475  memset( &term, '\0', sizeof(term) );
476  puts( "cfsetspeed(BAD BAUD) - EINVAL" );
477  status = cfsetspeed( &term, bad );
478  rtems_test_assert( status == -1 );
479  rtems_test_assert( errno == EINVAL );
480
481  for (i=0 ; baud_table[i].constant != INVALID_CONSTANT ; i++ ) {
482    memset( &term, '\0', sizeof(term) );
483    printf(
484      "cfsetspeed(B%" PRIdrtems_termios_baud_t ") - OK\n",
485      baud_table[i].baud
486    );
487    status = cfsetspeed( &term, baud_table[i].constant );
488    rtems_test_assert( !status );
489
490    printf(
491      "cfgetspeed(B%" PRIdrtems_termios_baud_t ") - checking both inspeed and outspeed - OK\n",
492      baud_table[i].baud
493    );
494    speed = cfgetispeed( &term );
495    rtems_test_assert( speed == baud_table[i].constant );
496
497    speed = cfgetospeed( &term );
498    rtems_test_assert( speed == baud_table[i].constant );
499  }
500}
501
502static void test_termios_cfmakeraw(void)
503{
504  struct termios  term;
505
506  memset( &term, '\0', sizeof(term) );
507  cfmakeraw( &term );
508  puts( "cfmakeraw - OK" );
509
510  /* Check that all of the flags were set correctly */
511  rtems_test_assert( ~(term.c_iflag & (IMAXBEL|IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON)) );
512
513  rtems_test_assert( ~(term.c_oflag & OPOST) );
514
515  rtems_test_assert( ~(term.c_lflag & (ECHO|ECHONL|ICANON|ISIG|IEXTEN)) );
516
517  rtems_test_assert( ~(term.c_cflag & (CSIZE|PARENB)) );
518
519  rtems_test_assert( term.c_cflag & CS8 );
520}
521
[7fd5e89]522typedef struct {
523  rtems_termios_device_context base;
524  bool done;
525} device_context;
526
[55e0be36]527static rtems_status_code test_early_device_install(
[ef8c00bc]528  rtems_device_major_number major,
529  rtems_device_minor_number minor,
530  void *arg
531)
532{
[55e0be36]533  static const rtems_termios_device_handler handler;
534  static const char dev[] = "/foobar";
535
[ef8c00bc]536  rtems_resource_snapshot snapshot;
537  rtems_status_code sc;
[55e0be36]538  int fd;
539  int rv;
[ef8c00bc]540
541  rtems_resource_snapshot_take( &snapshot );
542
[55e0be36]543  sc = rtems_termios_device_install( &dev[0], &handler, NULL, NULL );
544  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
545
546  errno = 0;
547  fd = open( &dev[0], O_RDWR );
548  rtems_test_assert( fd == -1 );
549  rtems_test_assert( errno == ENXIO );
[ef8c00bc]550
[55e0be36]551  rv = unlink( &dev[0] );
552  rtems_test_assert( rv == 0 );
[ef8c00bc]553
554  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
[93726e5]555
556  return RTEMS_SUCCESSFUL;
[ef8c00bc]557}
558
559static void test_device_install_remove(void)
560{
561  static const rtems_termios_device_handler handler;
562  static const char dev[] = "/foobar";
563
564  rtems_resource_snapshot snapshot;
565  rtems_status_code sc;
566  void *greedy;
[55e0be36]567  int rv;
[ef8c00bc]568
569  rtems_resource_snapshot_take( &snapshot );
570
571  greedy = rtems_heap_greedy_allocate( NULL, 0 );
572
[55e0be36]573  sc = rtems_termios_device_install( "/", &handler, NULL, NULL );
[ef8c00bc]574  rtems_test_assert( sc == RTEMS_NO_MEMORY );
575
576  rtems_heap_greedy_free( greedy );
577
578  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
579
[55e0be36]580  sc = rtems_termios_device_install( "/", &handler, NULL, NULL );
[ef8c00bc]581  rtems_test_assert( sc == RTEMS_UNSATISFIED );
582
583  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
584
[55e0be36]585  sc = rtems_termios_device_install( &dev[0], &handler, NULL, NULL );
[ef8c00bc]586  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
587
[55e0be36]588  rv = unlink( &dev[0] );
589  rtems_test_assert( rv == 0 );
[ef8c00bc]590
591  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
592}
593
[a0fb29f]594static bool first_open_error(
595  rtems_termios_tty *tty,
[7fd5e89]596  rtems_termios_device_context *base,
597  struct termios *term,
[a0fb29f]598  rtems_libio_open_close_args_t *args
599)
600{
[7fd5e89]601  device_context *ctx = (device_context *) base;
[a0fb29f]602
[7fd5e89]603  (void) tty;
604  (void) term;
[a0fb29f]605  (void) args;
606
[7fd5e89]607  ctx->done = true;
[a0fb29f]608
609  return false;
610}
611
612static void test_first_open_error(void)
613{
614  static const rtems_termios_device_handler handler = {
615    .first_open = first_open_error
616  };
617  static const char dev[] = "/foobar";
618
619  rtems_resource_snapshot snapshot;
620  rtems_status_code sc;
[55e0be36]621  int fd;
622  int rv;
[7fd5e89]623  device_context ctx = {
624    .base = RTEMS_TERMIOS_DEVICE_CONTEXT_INITIALIZER( "abc" ),
625    .done = false
626  };
[a0fb29f]627
628  rtems_resource_snapshot_take( &snapshot );
629
[55e0be36]630  sc = rtems_termios_device_install( &dev[0], &handler, NULL, &ctx.base );
[a0fb29f]631  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
632
[7fd5e89]633  rtems_test_assert( !ctx.done );
[55e0be36]634  errno = 0;
635  fd = open( &dev[0], O_RDWR );
636  rtems_test_assert( fd == -1 );
637  rtems_test_assert( errno == ENOMEM );
[7fd5e89]638  rtems_test_assert( ctx.done );
[a0fb29f]639
[55e0be36]640  rv = unlink( &dev[0] );
641  rtems_test_assert( rv == 0 );
[a0fb29f]642
643  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
644}
645
[32fc6a3]646static bool set_attributes_error(
[7fd5e89]647  rtems_termios_device_context *base,
[32fc6a3]648  const struct termios *term
649)
650{
[7fd5e89]651  device_context *ctx = (device_context *) base;
[32fc6a3]652
653  (void) term;
654
[7fd5e89]655  ctx->done = true;
[32fc6a3]656
657  return false;
658}
659
660static void test_set_attributes_error(void)
661{
662  static const rtems_termios_device_handler handler = {
663    .set_attributes = set_attributes_error
664  };
665  static const char dev[] = "/foobar";
666
667  rtems_resource_snapshot snapshot;
668  rtems_status_code sc;
669  struct termios term;
[7fd5e89]670  device_context ctx = {
671    .base = RTEMS_TERMIOS_DEVICE_CONTEXT_INITIALIZER( "abc" ),
672    .done = false
673  };
[55e0be36]674  int fd;
675  int rv;
[32fc6a3]676
677  rtems_resource_snapshot_take( &snapshot );
678
[55e0be36]679  sc = rtems_termios_device_install( &dev[0], &handler, NULL, &ctx.base );
[32fc6a3]680  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
681
[55e0be36]682  fd = open( &dev[0], O_RDWR );
683  rtems_test_assert( fd >= 0 );
[32fc6a3]684
[7fd5e89]685  rtems_test_assert( !ctx.done );
[55e0be36]686  errno = 0;
687  rv = ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, &term );
688  rtems_test_assert( rv == -1 );
689  rtems_test_assert( errno == EIO );
[7fd5e89]690  rtems_test_assert( ctx.done );
[32fc6a3]691
[55e0be36]692  rv = close( fd );
693  rtems_test_assert( rv == 0 );
[32fc6a3]694
[55e0be36]695  rv = unlink( &dev[0] );
696  rtems_test_assert( rv == 0 );
[32fc6a3]697
698  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
699}
700
[93726e5]701static void test_set_best_baud(void)
702{
703  static const struct {
704    uint32_t baud;
705    tcflag_t cflag;
706  } baud_to_cflag_table[] = {
707    { 0,          B0 },
708    { 25,         B0 },
709    { 26,         B50 },
710    { 50,         B50 },
711    { 62,         B50 },
712    { 63,         B75 },
713    { 75,         B75 },
714    { 110,        B110 },
715    { 134,        B134 },
716    { 150,        B150 },
717    { 200,        B200 },
718    { 300,        B300 },
719    { 600,        B600 },
720    { 1200,       B1200 },
721    { 1800,       B1800 },
722    { 2400,       B2400 },
723    { 4800,       B4800 },
724    { 9600,       B9600 },
725    { 19200,      B19200 },
726    { 38400,      B38400 },
727    { 57600,      B57600 },
728    { 115200,     B115200 },
729    { 230400,     B230400 },
730    { 460800,     B460800 },
731    { 0xffffffff, B460800 }
732  };
733
734  size_t n = RTEMS_ARRAY_SIZE(baud_to_cflag_table);
735  size_t i;
736
737  for ( i = 0; i < n; ++i ) {
[7fd5e89]738    struct termios term;
[93726e5]739    tcflag_t cbaud_mask = CBAUD;
740
[7fd5e89]741    memset( &term, 0xff, sizeof( term ) );
742    rtems_termios_set_best_baud( &term, baud_to_cflag_table[ i ].baud );
[93726e5]743
744    rtems_test_assert(
[7fd5e89]745      (term.c_cflag & cbaud_mask) == baud_to_cflag_table[ i ].cflag
[93726e5]746    );
747  }
748}
749
[f55595e]750static rtems_task Init(
[4d5b156]751  rtems_task_argument ignored
752)
753{
754  int                       rc;
755  rtems_status_code         sc;
756  rtems_device_major_number registered;
757  int                       test;
[8cd0bb0f]758  struct termios            t;
[d539f2b]759  int index = 0;
[4d5b156]760
[f8b2eb03]761  TEST_BEGIN();
[4d5b156]762
763  test_termios_baud2index();
764  test_termios_baud2number();
765  test_termios_number_to_baud();
766
[c8615dcf]767  sc = rtems_termios_bufsize( 256, 128, 64 );
[2e54cdc4]768  directive_failed( sc, "rtems_termios_bufsize" );
769
[8cd0bb0f]770  /*
771   * Register a driver
772   */
[4d5b156]773  puts(
774    "\n"
775    "Init - rtems_io_register_driver - Termios Test Driver - OK"
776  );
777  sc = rtems_io_register_driver( 0, &test_driver, &registered );
778  printf( "Init - Major slot returned = %d\n", (int) registered );
779  directive_failed( sc, "rtems_io_register_driver" );
780
781  /*
782   * Test baud rate
783   */
784  puts( "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" );
785  test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR );
786  if ( test == -1 ) {
787    printf( "ERROR - baud opening test device (%d)\n", test );
788    rtems_test_exit(0);
789  }
790
[2e54cdc4]791  /*
792   * tcsetattr - ERROR invalid operation
793   */
794  puts( "tcsetattr - invalid operation - ENOTSUP" );
[a263ce5c]795  rc = tcsetattr( test, INT_MAX, &t );
[2e54cdc4]796  rtems_test_assert( rc == -1 );
797  rtems_test_assert( errno == ENOTSUP );
[3096f5c9]798
799  test_termios_cfmakeraw();
[2e54cdc4]800 
801  /*
802   * tcsetattr - TCSADRAIN
803   */
804  puts( "\ntcsetattr - drain - OK" );
805  rc = tcsetattr( test, TCSADRAIN, &t );
806  rtems_test_assert( rc == 0 );
807
[4d5b156]808  test_termios_set_baud(test);
809
810  puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" );
811  rc = close( test );
812  if ( rc != 0 ) {
813    printf( "ERROR - baud close test device (%d) %s\n", test, strerror(errno) );
814    rtems_test_exit(0);
815  }
816
817  /*
818   * Test character size
[b1274bd9]819   */
[4d5b156]820  puts(
821    "\n"
822    "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK"
823  );
824  test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR );
825  if ( test == -1 ) {
826    printf( "ERROR - size open test device (%d) %s\n", test, strerror(errno) );
827    rtems_test_exit(0);
828  }
829
830  test_termios_set_charsize(test);
831
832  puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" );
833  rc = close( test );
834  if ( rc != 0 ) {
835    printf( "ERROR - size close test device (%d) %s\n", test, strerror(errno) );
836    rtems_test_exit(0);
837  }
838
839  /*
840   * Test parity
[b1274bd9]841   */
[4d5b156]842  puts(
843    "\n"
844    "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK"
845  );
846  test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR );
847  if ( test == -1 ) {
848    printf( "ERROR - parity open test device (%d) %s\n",
849      test, strerror(errno) );
850    rtems_test_exit(0);
851  }
852
853  test_termios_set_parity(test);
854
855  puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" );
856  rc = close( test );
857  if ( rc != 0 ) {
858    printf( "ERROR - parity close test device (%d) %s\n",
859      test, strerror(errno) );
860    rtems_test_exit(0);
861  }
862
863  /*
864   * Test stop bits
[b1274bd9]865   */
[4d5b156]866  puts(
867    "\n"
868    "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK"
869  );
870  test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR );
871  if ( test == -1 ) {
872    printf( "ERROR - stop bits open test device (%d) %s\n",
873      test, strerror(errno) );
874    rtems_test_exit(0);
875  }
876
877  test_termios_set_stop_bits(test);
878
[9f5f6f53]879  test_termios_cfoutspeed();
880
881  test_termios_cfinspeed();
882
[3096f5c9]883  test_termios_cfsetspeed();
884
[4d5b156]885  puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" );
886  rc = close( test );
887  if ( rc != 0 ) {
888    printf( "ERROR - stop bits close test device (%d) %s\n",
889      test, strerror(errno) );
890    rtems_test_exit(0);
891  }
892
[2e54cdc4]893
894  puts( "Multiple open of the device" );
895  for( ; index < 26; ++index ) {
896    test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR );
897    rtems_test_assert( test != -1 );
898    rc = close( test );
899    rtems_test_assert( rc == 0 );
900  }
901  puts( "" );
[d539f2b]902
[ef8c00bc]903  test_device_install_remove();
[a0fb29f]904  test_first_open_error();
[32fc6a3]905  test_set_attributes_error();
[93726e5]906  test_set_best_baud();
[ef8c00bc]907
[f8b2eb03]908  TEST_END();
[4d5b156]909  rtems_test_exit(0);
910}
911
912/* configuration information */
913
[ef8c00bc]914#define CONFIGURE_APPLICATION_PREREQUISITE_DRIVERS \
[55e0be36]915  { .initialization_entry = test_early_device_install }
[ef8c00bc]916
[4d5b156]917#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
918#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
919
920/* include an extra slot for registering the termios one dynamically */
[ef8c00bc]921#define CONFIGURE_MAXIMUM_DRIVERS 4
[4d5b156]922
923/* one for the console and one for the test port */
[e8e38481]924#define CONFIGURE_NUMBER_OF_TERMIOS_PORTS 3
[4d5b156]925
926/* we need to be able to open the test device */
927#define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 4
928
929#define CONFIGURE_MAXIMUM_TASKS         1
[f8b2eb03]930#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
931
[4d5b156]932#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
933
934#define CONFIGURE_INIT
935#include <rtems/confdefs.h>
936
937/* global variables */
Note: See TracBrowser for help on using the repository browser.