source: rtems/testsuites/libtests/termios01/init.c @ 1c6926c1

Last change on this file since 1c6926c1 was 1c6926c1, checked in by Kevin Kirspel <kevin-kirspel@…>, on Mar 21, 2017 at 7:39:48 PM

termios: Synchronize with latest FreeBSD headers

Adding modified FreeBSD headers to synchronize RTEMS termios with
FreeBSD. Modify termios to support dedicated input and output baud for
termios structure. Updated BSPs to use dedicated input and output baud
in termios structure. Updated tools to use dedicated input and output
baud in termios structure. Updated termios testsuites to use dedicated
input and output baud in termios structure.

Close #2897.

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