source: rtems/testsuites/libtests/termios01/init.c @ 93726e5

4.115
Last change on this file since 93726e5 was 93726e5, checked in by Sebastian Huber <sebastian.huber@…>, on Jul 9, 2014 at 1:44:13 PM

termios: Add rtems_termios_set_best_baud()

  • Property mode set to 100644
File size: 23.4 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 );
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( NULL, major, minor, &handler, NULL );
571  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
572
573  sc = rtems_termios_device_install( NULL, major, minor, &handler, NULL );
574  rtems_test_assert( sc == RTEMS_RESOURCE_IN_USE );
575
576  sc = rtems_termios_device_remove( NULL, major, minor );
577  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
578
579  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
580
581  sc = rtems_termios_device_install( "/", major, minor, &handler, NULL );
582  rtems_test_assert( sc == RTEMS_UNSATISFIED );
583
584  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
585
586  sc = rtems_termios_device_remove( NULL, major, minor );
587  rtems_test_assert( sc == RTEMS_INVALID_ID );
588
589  sc = rtems_termios_device_install( &dev[0], major, minor, &handler, NULL );
590  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
591
592  sc = rtems_termios_device_remove( "/barfoo", major, minor );
593  rtems_test_assert( sc == RTEMS_UNSATISFIED );
594
595  sc = rtems_termios_device_open( major, minor, &args );
596  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
597
598  sc = rtems_termios_device_remove( &dev[0], major, minor );
599  rtems_test_assert( sc == RTEMS_RESOURCE_IN_USE );
600
601  sc = rtems_termios_device_close( &args );
602  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
603
604  sc = rtems_termios_device_remove( &dev[0], major, minor );
605  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
606
607  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
608}
609
610static bool first_open_error(
611  rtems_termios_tty *tty,
612  rtems_libio_open_close_args_t *args
613)
614{
615  bool *done = rtems_termios_get_device_context( tty );
616
617  (void) args;
618
619  *done = true;
620
621  return false;
622}
623
624static void test_first_open_error(void)
625{
626  static const rtems_termios_device_handler handler = {
627    .first_open = first_open_error
628  };
629  static const rtems_device_major_number major = 123456789;
630  static const rtems_device_minor_number minor = 0xdeadbeef;
631  static const char dev[] = "/foobar";
632
633  rtems_resource_snapshot snapshot;
634  rtems_status_code sc;
635  rtems_libio_t iop;
636  rtems_libio_open_close_args_t args;
637  bool done = false;
638
639  rtems_resource_snapshot_take( &snapshot );
640
641  sc = rtems_termios_device_install( &dev[0], major, minor, &handler, &done );
642  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
643
644  memset( &iop, 0, sizeof( iop ) );
645  memset( &args, 0, sizeof( args ) );
646  args.iop = &iop;
647
648  rtems_test_assert( !done );
649  sc = rtems_termios_device_open( major, minor, &args );
650  rtems_test_assert( sc == RTEMS_NO_MEMORY );
651  rtems_test_assert( done );
652
653  sc = rtems_termios_device_remove( &dev[0], major, minor );
654  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
655
656  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
657}
658
659static bool set_attributes_error(
660  rtems_termios_tty *tty,
661  const struct termios *term
662)
663{
664  bool *done = rtems_termios_get_device_context( tty );
665
666  (void) term;
667
668  *done = true;
669
670  return false;
671}
672
673static void test_set_attributes_error(void)
674{
675  static const rtems_termios_device_handler handler = {
676    .set_attributes = set_attributes_error
677  };
678  static const rtems_device_major_number major = 123456789;
679  static const rtems_device_minor_number minor = 0xdeadbeef;
680  static const char dev[] = "/foobar";
681
682  rtems_resource_snapshot snapshot;
683  rtems_status_code sc;
684  rtems_libio_t iop;
685  rtems_libio_open_close_args_t oc_args;
686  rtems_libio_ioctl_args_t io_args;
687  struct termios term;
688  bool done = false;
689
690  rtems_resource_snapshot_take( &snapshot );
691
692  sc = rtems_termios_device_install( &dev[0], major, minor, &handler, &done );
693  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
694
695  memset( &iop, 0, sizeof( iop ) );
696  memset( &oc_args, 0, sizeof( oc_args ) );
697  oc_args.iop = &iop;
698
699  sc = rtems_termios_device_open( major, minor, &oc_args );
700  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
701
702  memset( &io_args, 0, sizeof( io_args ) );
703  io_args.iop = &iop;
704  io_args.command = RTEMS_IO_SET_ATTRIBUTES;
705  io_args.buffer = &term;
706
707  rtems_test_assert( !done );
708  sc = rtems_termios_ioctl( &io_args );
709  rtems_test_assert( sc == RTEMS_IO_ERROR );
710  rtems_test_assert( done );
711
712  sc = rtems_termios_device_close( &oc_args );
713  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
714
715  sc = rtems_termios_device_remove( &dev[0], major, minor );
716  rtems_test_assert( sc == RTEMS_SUCCESSFUL );
717
718  rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) );
719}
720
721static void test_set_best_baud(void)
722{
723  static const struct {
724    uint32_t baud;
725    tcflag_t cflag;
726  } baud_to_cflag_table[] = {
727    { 0,          B0 },
728    { 25,         B0 },
729    { 26,         B50 },
730    { 50,         B50 },
731    { 62,         B50 },
732    { 63,         B75 },
733    { 75,         B75 },
734    { 110,        B110 },
735    { 134,        B134 },
736    { 150,        B150 },
737    { 200,        B200 },
738    { 300,        B300 },
739    { 600,        B600 },
740    { 1200,       B1200 },
741    { 1800,       B1800 },
742    { 2400,       B2400 },
743    { 4800,       B4800 },
744    { 9600,       B9600 },
745    { 19200,      B19200 },
746    { 38400,      B38400 },
747    { 57600,      B57600 },
748    { 115200,     B115200 },
749    { 230400,     B230400 },
750    { 460800,     B460800 },
751    { 0xffffffff, B460800 }
752  };
753
754  size_t n = RTEMS_ARRAY_SIZE(baud_to_cflag_table);
755  size_t i;
756
757  for ( i = 0; i < n; ++i ) {
758    rtems_termios_tty tty;
759    struct termios *term = rtems_termios_get_termios( &tty );
760    tcflag_t cbaud_mask = CBAUD;
761
762    memset( &tty, 0xff, sizeof( tty ) );
763    rtems_termios_set_best_baud( &tty, baud_to_cflag_table[ i ].baud );
764
765    rtems_test_assert(
766      (term->c_cflag & cbaud_mask) == baud_to_cflag_table[ i ].cflag
767    );
768  }
769}
770
771static rtems_task Init(
772  rtems_task_argument ignored
773)
774{
775  int                       rc;
776  rtems_status_code         sc;
777  rtems_device_major_number registered;
778  int                       test;
779  struct termios            t;
780  int index = 0;
781
782  TEST_BEGIN();
783
784  test_termios_baud2index();
785  test_termios_baud2number();
786  test_termios_number_to_baud();
787
788  sc = rtems_termios_bufsize( 256, 128, 64 );
789  directive_failed( sc, "rtems_termios_bufsize" );
790
791  /*
792   * Register a driver
793   */
794  puts(
795    "\n"
796    "Init - rtems_io_register_driver - Termios Test Driver - OK"
797  );
798  sc = rtems_io_register_driver( 0, &test_driver, &registered );
799  printf( "Init - Major slot returned = %d\n", (int) registered );
800  directive_failed( sc, "rtems_io_register_driver" );
801
802  /*
803   * Test baud rate
804   */
805  puts( "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" );
806  test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR );
807  if ( test == -1 ) {
808    printf( "ERROR - baud opening test device (%d)\n", test );
809    rtems_test_exit(0);
810  }
811
812  /*
813   * tcsetattr - ERROR invalid operation
814   */
815  puts( "tcsetattr - invalid operation - ENOTSUP" );
816  rc = tcsetattr( test, INT_MAX, &t );
817  rtems_test_assert( rc == -1 );
818  rtems_test_assert( errno == ENOTSUP );
819
820  test_termios_cfmakeraw();
821 
822  /*
823   * tcsetattr - TCSADRAIN
824   */
825  puts( "\ntcsetattr - drain - OK" );
826  rc = tcsetattr( test, TCSADRAIN, &t );
827  rtems_test_assert( rc == 0 );
828
829  test_termios_set_baud(test);
830
831  puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" );
832  rc = close( test );
833  if ( rc != 0 ) {
834    printf( "ERROR - baud close test device (%d) %s\n", test, strerror(errno) );
835    rtems_test_exit(0);
836  }
837
838  /*
839   * Test character size
840   */
841  puts(
842    "\n"
843    "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK"
844  );
845  test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR );
846  if ( test == -1 ) {
847    printf( "ERROR - size open test device (%d) %s\n", test, strerror(errno) );
848    rtems_test_exit(0);
849  }
850
851  test_termios_set_charsize(test);
852
853  puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" );
854  rc = close( test );
855  if ( rc != 0 ) {
856    printf( "ERROR - size close test device (%d) %s\n", test, strerror(errno) );
857    rtems_test_exit(0);
858  }
859
860  /*
861   * Test parity
862   */
863  puts(
864    "\n"
865    "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK"
866  );
867  test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR );
868  if ( test == -1 ) {
869    printf( "ERROR - parity open test device (%d) %s\n",
870      test, strerror(errno) );
871    rtems_test_exit(0);
872  }
873
874  test_termios_set_parity(test);
875
876  puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" );
877  rc = close( test );
878  if ( rc != 0 ) {
879    printf( "ERROR - parity close test device (%d) %s\n",
880      test, strerror(errno) );
881    rtems_test_exit(0);
882  }
883
884  /*
885   * Test stop bits
886   */
887  puts(
888    "\n"
889    "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK"
890  );
891  test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR );
892  if ( test == -1 ) {
893    printf( "ERROR - stop bits open test device (%d) %s\n",
894      test, strerror(errno) );
895    rtems_test_exit(0);
896  }
897
898  test_termios_set_stop_bits(test);
899
900  test_termios_cfoutspeed();
901
902  test_termios_cfinspeed();
903
904  test_termios_cfsetspeed();
905
906  puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" );
907  rc = close( test );
908  if ( rc != 0 ) {
909    printf( "ERROR - stop bits close test device (%d) %s\n",
910      test, strerror(errno) );
911    rtems_test_exit(0);
912  }
913
914
915  puts( "Multiple open of the device" );
916  for( ; index < 26; ++index ) {
917    test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR );
918    rtems_test_assert( test != -1 );
919    rc = close( test );
920    rtems_test_assert( rc == 0 );
921  }
922  puts( "" );
923
924  test_device_install_remove();
925  test_first_open_error();
926  test_set_attributes_error();
927  test_set_best_baud();
928
929  TEST_END();
930  rtems_test_exit(0);
931}
932
933/* configuration information */
934
935#define CONFIGURE_APPLICATION_PREREQUISITE_DRIVERS \
936  { .initialization_entry = test_early_device_install_remove }
937
938#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
939#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
940
941/* include an extra slot for registering the termios one dynamically */
942#define CONFIGURE_MAXIMUM_DRIVERS 4
943
944/* one for the console and one for the test port */
945#define CONFIGURE_NUMBER_OF_TERMIOS_PORTS 3
946
947/* we need to be able to open the test device */
948#define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 4
949
950#define CONFIGURE_MAXIMUM_TASKS         1
951#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
952
953#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
954
955#define CONFIGURE_INIT
956#include <rtems/confdefs.h>
957
958/* global variables */
Note: See TracBrowser for help on using the repository browser.