source: rtems/testsuites/libtests/termios01/init.c @ a830cb8

4.115
Last change on this file since a830cb8 was a830cb8, checked in by Sebastian Huber <sebastian.huber@…>, on Oct 7, 2014 at 2:27:51 PM

termios: Separate flow control from normal handler

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