static void disk_register( uint32_t block_size, rtems_blkdev_bnum block_count, rtems_disk_device **dd_ptr ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0; dev_t dev = 0; sc = rtems_io_register_driver(0, &disk_ops, &major); ASSERT_SC(sc); dev = rtems_filesystem_make_dev_t(major, 0); sc = rtems_disk_create_phys( dev, block_size, block_count, disk_ioctl, NULL, NULL ); ASSERT_SC(sc); *dd_ptr = rtems_disk_obtain(dev); rtems_test_assert(*dd_ptr!= NULL); }
static rtems_status_code disk_register( uint32_t block_size, rtems_blkdev_bnum block_count, dev_t *dev_ptr ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0; dev_t dev = 0; sc = rtems_io_register_driver(0, &disk_ops, &major); ASSERT_SC(sc); dev = rtems_filesystem_make_dev_t(major, 0); sc = rtems_disk_create_phys( dev, block_size, block_count, disk_ioctl, NULL, NULL ); ASSERT_SC(sc); *dev_ptr = dev; return RTEMS_SUCCESSFUL; }
static int pty_do_initialize(void) { if ( !telnet_pty_inited ) { if (RTEMS_SUCCESSFUL==rtems_io_register_driver(0, &drvPty, &pty_major)) telnet_pty_inited=TRUE; else fprintf(stderr,"WARNING: registering the PTY driver FAILED\n"); } return telnet_pty_inited; }
static bool bdbuf_tests_setup_disk (rtems_device_major_number* major) { rtems_status_code sc; /* * Register the disk driver. */ bdbuf_test_printf ("register disk driver\n"); sc = rtems_io_register_driver (RTEMS_DRIVER_AUTO_MAJOR, &bdbuf_disk_io_ops, major); return sc == RTEMS_SUCCESSFUL; }
int setup_ramdisk (const char* mntpath) { rtems_device_major_number major; rtems_status_code sc; /* * Register the RAM Disk driver. */ printf ("Register RAM Disk Driver: "); sc = rtems_io_register_driver (RTEMS_DRIVER_AUTO_MAJOR, &rtems_ramdisk_io_ops, &major); if (sc != RTEMS_SUCCESSFUL) { printf ("error: ramdisk driver not initialised: %s\n", rtems_status_text (sc)); return 1; } printf ("successful\n"); return 0; }
int setup_nvdisk (void) { rtems_device_major_number major; rtems_status_code sc; /* ** check to see if the RAM is allocated before initializing the driver */ if ( rki_nvdisk_base == 0 ) { printf("Cannot setup NVRAM disk, memory was not allocated\n"); return(1); } /* ** Assign the RAM allocated */ rtems_nv_heap_device_descriptor[0].base = rki_nvdisk_base; /* ** Register the NVRAM Disk driver. */ printf ("Register NV Disk Driver: "); sc = rtems_io_register_driver (RTEMS_DRIVER_AUTO_MAJOR, &rtems_nvdisk_io_ops, &major); if (sc != RTEMS_SUCCESSFUL) { printf ("error: nvdisk driver not initialised: %s\n", rtems_status_text (sc)); return 1; } rtems_shell_add_cmd ("nverase", "misc", "nverase driver", shell_nvram_erase); printf ("successful\n"); return 0; }
static int grtm_register_io(rtems_device_major_number *m) { rtems_status_code r; if ((r = rtems_io_register_driver(0, &grtm_driver, m)) == RTEMS_SUCCESSFUL) { DBG("GRTM driver successfully registered, major: %d\n", *m); } else { switch(r) { case RTEMS_TOO_MANY: printk("GRTM rtems_io_register_driver failed: RTEMS_TOO_MANY\n"); return -1; case RTEMS_INVALID_NUMBER: printk("GRTM rtems_io_register_driver failed: RTEMS_INVALID_NUMBER\n"); return -1; case RTEMS_RESOURCE_IN_USE: printk("GRTM rtems_io_register_driver failed: RTEMS_RESOURCE_IN_USE\n"); return -1; default: printk("GRTM rtems_io_register_driver failed\n"); return -1; } } return 0; }
static bool bdbuf_tests_setup_disk (rtems_device_major_number *major, rtems_disk_device **dd_ptr) { rtems_status_code sc; bool ok; /* * Register the disk driver. */ bdbuf_test_printf ("register disk driver\n"); sc = rtems_io_register_driver (RTEMS_DRIVER_AUTO_MAJOR, &bdbuf_disk_io_ops, major); ok = sc == RTEMS_SUCCESSFUL; if (ok) { *dd_ptr = rtems_disk_obtain (rtems_filesystem_make_dev_t (*major, 0)); ok = *dd_ptr != NULL; } return ok; }
static void test_set_attributes_error(void) { static const rtems_termios_device_handler handler = { .set_attributes = set_attributes_error }; static const char dev[] = "/foobar"; rtems_resource_snapshot snapshot; rtems_status_code sc; struct termios term; device_context ctx = { .base = RTEMS_TERMIOS_DEVICE_CONTEXT_INITIALIZER( "abc" ), .done = false }; int fd; int rv; rtems_resource_snapshot_take( &snapshot ); sc = rtems_termios_device_install( &dev[0], &handler, NULL, &ctx.base ); rtems_test_assert( sc == RTEMS_SUCCESSFUL ); fd = open( &dev[0], O_RDWR ); rtems_test_assert( fd >= 0 ); rtems_test_assert( !ctx.done ); errno = 0; rv = ioctl( fd, TIOCSETA, &term ); rtems_test_assert( rv == -1 ); rtems_test_assert( errno == EIO ); rtems_test_assert( ctx.done ); rv = close( fd ); rtems_test_assert( rv == 0 ); rv = unlink( &dev[0] ); rtems_test_assert( rv == 0 ); rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); } static void test_set_best_baud(void) { static const struct { uint32_t baud; speed_t speed; } baud_to_speed_table[] = { { 0, B0 }, { 25, B0 }, { 26, B50 }, { 50, B50 }, { 62, B50 }, { 63, B75 }, { 75, B75 }, { 110, B110 }, { 134, B134 }, { 150, B150 }, { 200, B200 }, { 300, B300 }, { 600, B600 }, { 1200, B1200 }, { 1800, B1800 }, { 2400, B2400 }, { 4800, B4800 }, { 9600, B9600 }, { 19200, B19200 }, { 38400, B38400 }, { 57600, B57600 }, { 115200, B115200 }, { 230400, B230400 }, { 460800, B460800 }, { 0xffffffff, B460800 } }; size_t n = RTEMS_ARRAY_SIZE(baud_to_speed_table); size_t i; for ( i = 0; i < n; ++i ) { struct termios term; memset( &term, 0xff, sizeof( term ) ); rtems_termios_set_best_baud( &term, baud_to_speed_table[ i ].baud ); rtems_test_assert( term.c_ispeed == baud_to_speed_table[ i ].speed ); rtems_test_assert( term.c_ospeed == baud_to_speed_table[ i ].speed ); } } static rtems_task Init( rtems_task_argument ignored ) { int rc; rtems_status_code sc; rtems_device_major_number registered; int test; struct termios t; int index = 0; TEST_BEGIN(); test_termios_baud2index(); test_termios_baud2number(); test_termios_number_to_baud(); sc = rtems_termios_bufsize( 256, 128, 64 ); directive_failed( sc, "rtems_termios_bufsize" ); /* * Register a driver */ puts( "\n" "Init - rtems_io_register_driver - Termios Test Driver - OK" ); sc = rtems_io_register_driver( 0, &test_driver, ®istered ); printf( "Init - Major slot returned = %d\n", (int) registered ); directive_failed( sc, "rtems_io_register_driver" ); /* * Test baud rate */ puts( "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - baud opening test device (%d)\n", test ); rtems_test_exit(0); } /* * tcsetattr - ERROR invalid operation */ puts( "tcsetattr - invalid operation - EINVAL" ); rc = tcsetattr( test, INT_MAX, &t ); rtems_test_assert( rc == -1 ); rtems_test_assert( errno == EINVAL ); test_termios_cfmakeraw(); test_termios_cfmakesane(); /* * tcsetattr - TCSADRAIN */ puts( "\ntcsetattr - drain - OK" ); rc = tcsetattr( test, TCSADRAIN, &t ); rtems_test_assert( rc == 0 ); test_termios_set_baud(test); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - baud close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } /* * Test character size */ puts( "\n" "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - size open test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } test_termios_set_charsize(test); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - size close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } /* * Test parity */ puts( "\n" "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - parity open test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } test_termios_set_parity(test); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - parity close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } /* * Test stop bits */ puts( "\n" "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - stop bits open test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } test_termios_set_stop_bits(test); test_termios_cfoutspeed(); test_termios_cfinspeed(); test_termios_cfsetspeed(); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - stop bits close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } puts( "Multiple open of the device" ); for( ; index < 26; ++index ) { test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); rtems_test_assert( test != -1 ); rc = close( test ); rtems_test_assert( rc == 0 ); } puts( "" ); test_device_install_remove(); test_first_open_error(); test_set_attributes_error(); test_set_best_baud(); TEST_END(); rtems_test_exit(0); }
static rtems_task Init( rtems_task_argument ignored ) { int rc; rtems_status_code sc; rtems_device_major_number registered; int test; struct termios t; int index = 0; TEST_BEGIN(); test_termios_baud2index(); test_termios_baud2number(); test_termios_number_to_baud(); sc = rtems_termios_bufsize( 256, 128, 64 ); directive_failed( sc, "rtems_termios_bufsize" ); /* * Register a driver */ puts( "\n" "Init - rtems_io_register_driver - Termios Test Driver - OK" ); sc = rtems_io_register_driver( 0, &test_driver, ®istered ); printf( "Init - Major slot returned = %d\n", (int) registered ); directive_failed( sc, "rtems_io_register_driver" ); /* * Test baud rate */ puts( "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - baud opening test device (%d)\n", test ); rtems_test_exit(0); } /* * tcsetattr - ERROR invalid operation */ puts( "tcsetattr - invalid operation - ENOTSUP" ); rc = tcsetattr( test, INT_MAX, &t ); rtems_test_assert( rc == -1 ); rtems_test_assert( errno == ENOTSUP ); test_termios_cfmakeraw(); /* * tcsetattr - TCSADRAIN */ puts( "\ntcsetattr - drain - OK" ); rc = tcsetattr( test, TCSADRAIN, &t ); rtems_test_assert( rc == 0 ); test_termios_set_baud(test); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - baud close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } /* * Test character size */ puts( "\n" "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - size open test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } test_termios_set_charsize(test); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - size close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } /* * Test parity */ puts( "\n" "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - parity open test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } test_termios_set_parity(test); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - parity close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } /* * Test stop bits */ puts( "\n" "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - stop bits open test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } test_termios_set_stop_bits(test); test_termios_cfoutspeed(); test_termios_cfinspeed(); test_termios_cfsetspeed(); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - stop bits close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } puts( "Multiple open of the device" ); for( ; index < 26; ++index ) { test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); rtems_test_assert( test != -1 ); rc = close( test ); rtems_test_assert( rc == 0 ); } puts( "" ); TEST_END(); rtems_test_exit(0); }
/* ** Create the RAM disk. ** This currently supports one RAM disk. */ int32 rtems_setup_ramdisk (char *phys_dev_name, uint32 *address, uint32 block_size, uint32 num_blocks) { rtems_device_major_number major; rtems_status_code sc; uint32 local_address; /* ** check parameters */ if ( num_blocks == 0 ) { printf("OSAL: Error: Cannot setup RAM disk, No size given.\n"); return(OS_FS_ERROR); } if ( block_size != 512 ) { printf("OSAL: Error: RAM Disk currently needs a block size of 512.\n"); return(OS_FS_ERROR); } if ( address == 0 ) { printf("OSAL: RAM disk address is zero: allocating %d bytes from heap\n", (int)(block_size * num_blocks)); local_address = (uint32) malloc (block_size * num_blocks); if (!local_address) { printf ("OSAL: Error: no memory for RAM disk 0\n"); return(OS_FS_ERROR); } /* ** Clear the memory for the disk */ memset ( (void *)local_address, 0, (block_size * num_blocks)); /* ** Assign the address */ rtems_ramdisk_configuration[0].location = (int *) local_address; } else { /* ** Assign the address */ rtems_ramdisk_configuration[0].location = (int *) address; } /* ** Assign the size */ rtems_ramdisk_configuration[0].block_size = block_size; rtems_ramdisk_configuration[0].block_num = num_blocks; /* ** Register the RAM Disk driver. */ sc = rtems_io_register_driver (RTEMS_DRIVER_AUTO_MAJOR, &rtems_ramdisk_io_ops, &major); if (sc != RTEMS_SUCCESSFUL) { printf ("OSAL: Error: RAM driver not initialized: %s\n", rtems_status_text (sc)); return (OS_FS_ERROR); } printf ("OSAL: RAM disk initialized: Address = 0x%08X\n",(unsigned int)rtems_ramdisk_configuration[0].location); return(OS_FS_SUCCESS); }
static void test_diskdevs(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0; rtems_device_minor_number minor = 0; rtems_disk_device *physical_dd = NULL; rtems_disk_device *logical_dd = NULL; rtems_disk_device *dd = NULL; dev_t physical_dev = 0; dev_t logical_dev = 0; dev_t logical_2_dev = 0; dev_t const big_major_dev = rtems_filesystem_make_dev_t((rtems_device_major_number) -2, 0); dev_t const big_minor_dev = rtems_filesystem_make_dev_t(0, (rtems_device_minor_number) -2); ramdisk *const rd = ramdisk_allocate(NULL, BLOCK_SIZE, BLOCK_COUNT, false); rtems_test_assert(rd != NULL); sc = rtems_disk_io_initialize(); ASSERT_SC(sc); sc = rtems_io_register_driver(0, &ramdisk_ops, &major); ASSERT_SC(sc); physical_dev = rtems_filesystem_make_dev_t(major, minor); logical_dev = rtems_filesystem_make_dev_t(major, minor + 1); logical_2_dev = rtems_filesystem_make_dev_t(major, minor + 2); /* Consistency checks for physical disks creation */ sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, NULL, rd, "/dev/rda"); ASSERT_SC_EQ(sc, RTEMS_INVALID_ADDRESS); sc = rtems_disk_create_phys(physical_dev, 0, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda"); ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER); sc = rtems_disk_create_phys(big_major_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda"); ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY); sc = rtems_disk_create_phys(big_minor_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda"); ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY); sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, NULL); ASSERT_SC(sc); sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, NULL); ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE); sc = rtems_disk_delete(physical_dev); ASSERT_SC(sc); /* Consistency checks for logical disks creation */ sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1"); ASSERT_SC_EQ(sc, RTEMS_INVALID_ID); sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda"); ASSERT_SC(sc); sc = rtems_disk_create_log(big_major_dev, physical_dev, 0, 1, "/dev/rda1"); ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY); sc = rtems_disk_create_log(big_minor_dev, physical_dev, 0, 1, "/dev/rda1"); ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY); sc = rtems_disk_create_log(logical_dev, physical_dev, BLOCK_COUNT, 0, "/dev/rda1"); ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER); sc = rtems_disk_create_log(logical_dev, physical_dev, 0, BLOCK_COUNT + 1, "/dev/rda1"); ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER); sc = rtems_disk_create_log(logical_dev, physical_dev, 1, BLOCK_COUNT, "/dev/rda1"); ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER); sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1"); ASSERT_SC(sc); sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1"); ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE); sc = rtems_disk_create_log(logical_2_dev, logical_dev, 0, 1, "/dev/rda1"); ASSERT_SC_EQ(sc, RTEMS_INVALID_ID); sc = rtems_disk_delete(logical_dev); ASSERT_SC(sc); /* Consistency checks delete */ sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1"); ASSERT_SC(sc); physical_dd = rtems_disk_obtain(physical_dev); rtems_test_assert(physical_dd != NULL && physical_dd->uses == 2); sc = rtems_disk_release(physical_dd); ASSERT_SC(sc); logical_dd = rtems_disk_obtain(logical_dev); rtems_test_assert(logical_dd != NULL && logical_dd->uses == 1); sc = rtems_disk_delete(physical_dev); ASSERT_SC(sc); sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda"); ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE); dd = rtems_disk_obtain(physical_dev); rtems_test_assert(dd == NULL); dd = rtems_disk_obtain(logical_dev); rtems_test_assert(dd == NULL); sc = rtems_disk_release(logical_dd); ASSERT_SC(sc); /* Cleanup */ sc = rtems_io_unregister_driver(major); ASSERT_SC(sc); ramdisk_free(rd); sc = rtems_disk_io_done(); ASSERT_SC(sc); }
void do_test_io_manager(void) { rtems_status_code status; rtems_device_major_number registered; rtems_device_major_number registered_worked; puts( "----- TESTING THE NULL DRIVER CHECKS -----" ); status = rtems_io_initialize( NO_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_initialize" ); puts( "rtems_io_initialize - NULL DRIVER RTEMS_SUCCESSFUL" ); status = rtems_io_open( NO_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_open" ); puts( "rtems_io_open - NULL DRIVER RTEMS_SUCCESSFUL" ); status = rtems_io_close( NO_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_close" ); puts( "rtems_io_close - NULL DRIVER RTEMS_SUCCESSFUL" ); status = rtems_io_read( NO_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_read" ); puts( "rtems_io_read - NULL DRIVER RTEMS_SUCCESSFUL" ); status = rtems_io_write( NO_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_write" ); puts( "rtems_io_write - NULL DRIVER RTEMS_SUCCESSFUL" ); status = rtems_io_control( NO_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_control" ); puts( "rtems_io_control - NULL DRIVER RTEMS_SUCCESSFUL" ); puts( "----- TESTING THE I/O MANAGER DIRECTIVES -----" ); status = rtems_io_initialize( STUB_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_initialize" ); puts( "rtems_io_initialize - STUB DRIVER RTEMS_SUCCESSFUL" ); status = rtems_io_open( STUB_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_open" ); puts( "rtems_io_open - STUB DRIVER RTEMS_SUCCESSFUL" ); status = rtems_io_close( STUB_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_close" ); puts( "rtems_io_close - STUB DRIVER RTEMS_SUCCESSFUL" ); status = rtems_io_read( STUB_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_read" ); puts( "rtems_io_read - STUB DRIVER RTEMS_SUCCESSFUL" ); status = rtems_io_write( STUB_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_write" ); puts( "rtems_io_write - STUB DRIVER RTEMS_SUCCESSFUL" ); status = rtems_io_control( STUB_DRIVER_MAJOR, 0, NULL ); directive_failed( status, "rtems_io_control" ); puts( "rtems_io_control - STUB DRIVER RTEMS_SUCCESSFUL" ); /* * Invalid major number */ puts( "----- RETURNING INVALID MAJOR NUMBER -----" ); status = rtems_io_initialize( INVALID_DRIVER_MAJOR, 0, NULL ); fatal_directive_status( status, RTEMS_INVALID_NUMBER, "rtems_io_initialize" ); puts( "rtems_io_initialize - RTEMS_INVALID_NUMBER" ); status = rtems_io_open( INVALID_DRIVER_MAJOR, 0, NULL ); fatal_directive_status( status, RTEMS_INVALID_NUMBER, "rtems_io_open" ); puts( "rtems_io_open - RTEMS_INVALID_NUMBER" ); /* * Exercise the io register driver directive */ puts( "----- EXERCISE DRIVER REGISTER -----" ); status = rtems_io_register_driver( 0, &GoodDriver, NULL ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_io_register_driver" ); puts( "rtems_io_register_driver - RTEMS_INVALID_ADDRESS - NULL registered" ); status = rtems_io_register_driver( 0, NULL, ®istered ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_io_register_driver" ); puts( "rtems_io_register_driver - RTEMS_INVALID_ADDRESS - NULL device" ); status = rtems_io_register_driver( 0, &BadDriver_Nothing, ®istered ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_io_register_driver" ); puts( "rtems_io_register_driver - RTEMS_INVALID_ADDRESS - no callouts" ); status = rtems_io_register_driver( INVALID_DRIVER_MAJOR, &GoodDriver, ®istered ); fatal_directive_status( status, RTEMS_INVALID_NUMBER, "rtems_io_register_driver" ); puts( "rtems_io_register_driver - RTEMS_INVALID_NUMBER - bad major" ); /* this has to succeed to overwrite NULL driver entry required above. */ status = rtems_io_register_driver( 0, &GoodDriver, ®istered_worked ); directive_failed( status, "rtems_io_register_driver" ); puts( "rtems_io_register_driver - RTEMS_SUCCESSFUL - overwrite NULL" ); status = rtems_io_register_driver( 0, &GoodDriver, ®istered ); if ( status == RTEMS_SUCCESSFUL ) printf( "registered major = %" PRIurtems_device_major_number "\n", registered ); fatal_directive_status( status, RTEMS_TOO_MANY, "rtems_io_register_driver" ); puts( "rtems_io_register_driver - RTEMS_TOO_MANY - no slots" ); /* there should be a driver at major 1 -- clock, console, or stub */ status = rtems_io_register_driver( 1, &GoodDriver, ®istered ); fatal_directive_status( status, RTEMS_RESOURCE_IN_USE, "rtems_io_register_driver" ); puts( "rtems_io_register_driver - RTEMS_RESOURCE_IN_USE - major in use" ); /* this should unregister the device driver we registered above */ status = rtems_io_unregister_driver( registered_worked ); directive_failed( status, "rtems_io_unregister_driver" ); puts( "rtems_io_unregister_driver - RTEMS_SUCCESSFUL" ); }
/* * Test the compatibility with a genuine MS Windows FAT file system. */ static void test_compatibility( void ) { int rc; rtems_status_code sc; dev_t dev; char diskpath[] = "/dev/ramdisk1"; rtems_dosfs_mount_options mount_opts; rtems_device_major_number major; FILE *fp; int buffer; unsigned int index_file = 0; unsigned int index_char; unsigned int offset; char content_buf[MAX_NAME_LENGTH + strlen( MOUNT_DIR ) + 1]; char file_path[MAX_NAME_LENGTH + strlen( MOUNT_DIR ) + 1]; DIR *dir_stream; struct dirent *dp; mount_opts.converter = rtems_dosfs_create_utf8_converter( "CP850" ); rtems_test_assert( mount_opts.converter != NULL ); sc = rtems_io_register_driver( 0, &ramdisk_ops, &major ); rtems_test_assert( sc == RTEMS_SUCCESSFUL ); dev = rtems_filesystem_make_dev_t( major, 1 ); sc = rtems_disk_create_phys( dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, &disk_image, diskpath ); rtems_test_assert( sc == RTEMS_SUCCESSFUL ); rc = mount_and_make_target_path( diskpath, MOUNT_DIR, RTEMS_FILESYSTEM_TYPE_DOSFS, RTEMS_FILESYSTEM_READ_WRITE, &mount_opts ); rtems_test_assert( rc == 0 ); dir_stream = opendir( MOUNT_DIR ); rtems_test_assert( dir_stream != NULL ); dp = readdir( dir_stream ); rtems_test_assert( dp != NULL ); while ( dp != NULL ) { index_char = 0; size_t len = strlen( filenames[index_file] ); if ( filenames[index_file][len - 1] == '.' ) rtems_test_assert( ( len - 1 ) == dp->d_namlen ); else rtems_test_assert( len == dp->d_namlen ); rtems_test_assert( 0 == memcmp( &filenames[index_file][0], &dp->d_name[0], dp->d_namlen ) ); snprintf( file_path, sizeof( file_path ), "%s/%s", MOUNT_DIR, filenames[index_file] ); fp = fopen( file_path, "r" ); rtems_test_assert( fp != NULL ); /* These files should contain their own file names. */ while ( ( buffer = fgetc( fp ) ) != EOF ) { content_buf[index_char] = buffer; ++index_char; } if ( 0 == strncmp( content_buf, UTF8_BOM, UTF8_BOM_SIZE ) ) offset = UTF8_BOM_SIZE; else offset = 0; rtems_test_assert( 0 == memcmp( filenames[index_file], &content_buf[offset], index_char - offset ) ); rc = fclose( fp ); rtems_test_assert( rc == 0 ); ++index_file; dp = readdir( dir_stream ); } rtems_test_assert( index_file == FILES_FILENAMES_NUMBER_OF ); rc = closedir( dir_stream ); rtems_test_assert( rc == 0 ); rc = unmount( MOUNT_DIR ); rtems_test_assert( rc == 0 ); }
void run_bdbuf_tests() { rtems_disk_device *disk; rtems_status_code sc; dev_t dev = -1; dev_t test_dev; unsigned int i; rtems_device_major_number major; rtems_driver_address_table testdisk = { test_disk_initialize, RTEMS_GENERIC_BLOCK_DEVICE_DRIVER_ENTRIES }; /* Create a message queue to get events from disk driver. */ sc = rtems_message_queue_create(TEST_TASK_RX_MQUEUE_NAME, TEST_TASK_RX_MQUEUE_COUNT, sizeof(bdbuf_test_msg), RTEMS_DEFAULT_ATTRIBUTES, &g_test_ctx.test_qid); if (sc != RTEMS_SUCCESSFUL) { printk("Failed to create message queue for test task: %u\n", sc); return; } /* Register a disk device that is used in tests */ sc = rtems_io_register_driver(0, &testdisk, &major); if (sc != RTEMS_SUCCESSFUL) { printk("Failed to register TEST DEVICE: %d\n", sc); return; } test_dev = -1; while ((disk = rtems_disk_next(dev)) != NULL) { printk("DEV: %s [%lu]\n", disk->name, disk->size); dev = disk->dev; if (strcmp(disk->name, TEST_DISK_NAME) == 0) test_dev = dev; rtems_disk_release(disk); } if (test_dev == (dev_t)-1) { printf("Failed to find %s disk\n", TEST_DISK_NAME); return; } test_dd = rtems_disk_obtain(test_dev); if (test_dd == NULL) { printf("Failed to obtain %s disk\n", TEST_DISK_NAME); return; } /* * On initialization test disk device driver registers * its RX message queue, so we just need to locate it. */ sc = rtems_message_queue_ident(TEST_DRV_RX_MQUEUE_NAME, RTEMS_SEARCH_ALL_NODES, &g_test_ctx.test_drv_qid); if (sc != RTEMS_SUCCESSFUL) { printf("Failed to find Test Driver Queue: %u\n", sc); return; } for (i = 0; i < ARRAY_NUM(g_test_ctx.test_sync_main); i++) { sc = rtems_semaphore_create(rtems_build_name('T', 'S', 'M', '0' + i), 0, TEST_SEM_ATTRIBS, 0, &g_test_ctx.test_sync_main[i]); if (sc != RTEMS_SUCCESSFUL) { printk("Failed to create sync sem for test task: %u\n", sc); return; } } for (i = 0; i < ARRAY_NUM(g_test_ctx.test_sync); i++) { sc = rtems_semaphore_create(rtems_build_name('T', 'S', 'T', '0' + i), 0, TEST_SEM_ATTRIBS, 0, &g_test_ctx.test_sync[i]); if (sc != RTEMS_SUCCESSFUL) { printk("Failed to create sync sem for test task #%d: %u\n", i + 1, sc); return; } } sc = rtems_semaphore_create(rtems_build_name('T', 'S', 'M', 'E'), 0, TEST_SEM_ATTRIBS, 0, &g_test_ctx.test_end_main); if (sc != RTEMS_SUCCESSFUL) { printk("Failed to create end sync sem for test task: %u\n", sc); return; } for (i = 0; i < ARRAY_NUM(g_test_ctx.test_task); i++) g_test_ctx.test_task[i] = OBJECTS_ID_NONE; for (i = 0; i < sizeof(bdbuf_tests) / sizeof(bdbuf_tests[0]); i++) { bdbuf_tests[i].main(); } }
rtems_task Init( rtems_task_argument ignored ) { int rc; rtems_status_code sc; rtems_device_major_number registered; int test; puts( "\n\n*** TEST TERMIOS 01 ***" ); test_termios_baud2index(); test_termios_baud2number(); test_termios_number_to_baud(); puts( "\n" "Init - rtems_io_register_driver - Termios Test Driver - OK" ); sc = rtems_io_register_driver( 0, &test_driver, ®istered ); printf( "Init - Major slot returned = %d\n", (int) registered ); directive_failed( sc, "rtems_io_register_driver" ); /* * Test baud rate */ puts( "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - baud opening test device (%d)\n", test ); rtems_test_exit(0); } test_termios_set_baud(test); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - baud close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } /* * Test character size */ puts( "\n" "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - size open test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } test_termios_set_charsize(test); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - size close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } /* * Test parity */ puts( "\n" "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - parity open test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } test_termios_set_parity(test); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - parity close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } /* * Test stop bits */ puts( "\n" "Init - open - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); test = open( TERMIOS_TEST_DRIVER_DEVICE_NAME, O_RDWR ); if ( test == -1 ) { printf( "ERROR - stop bits open test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } test_termios_set_stop_bits(test); puts( "Init - close - " TERMIOS_TEST_DRIVER_DEVICE_NAME " - OK" ); rc = close( test ); if ( rc != 0 ) { printf( "ERROR - stop bits close test device (%d) %s\n", test, strerror(errno) ); rtems_test_exit(0); } puts( "*** END OF TEST TERMIOS 01 ***" ); rtems_test_exit(0); }
rtems_task Init( rtems_task_argument argument ) { rtems_status_code sc; rtems_device_major_number registered; rtems_device_major_number registered_not; rtems_device_major_number invalid_major = _IO_Number_of_drivers + 1; rtems_interrupt_level level; bool do_interrupt_context_test = true; TEST_BEGIN(); /* Ensure that this test works as expected */ test_interrupt_context_enter( level ); do_interrupt_context_test = rtems_interrupt_is_in_progress(); test_interrupt_context_leave( level ); /* * Register a driver with init == NULL and open != NULL */ puts( "Init - rtems_io_register_driver - init == NULL, open != NULL OK" ); sc = rtems_io_register_driver( 0, &test_driver, ®istered ); printf( "Init - Major slot returned = %d\n", (int) registered ); directive_failed( sc, "rtems_io_register_driver" ); puts( "Init - rtems_io_register_driver - init == NULL, open != NULL OK" ); sc = rtems_io_register_driver( 0, &test_driver, ®istered_not ); printf( "Init - Major slot returned = %d\n", (int) registered_not ); fatal_directive_status( sc, RTEMS_TOO_MANY, "rtems_io_register_driver too many" ); puts( "Init - rtems_io_register_driver - used slot" ); sc = rtems_io_register_driver( registered, &test_driver, ®istered_not ); fatal_directive_status( sc, RTEMS_RESOURCE_IN_USE, "rtems_io_register_driver slot in use" ); puts( "Init - rtems_io_unregister_driver - used slot" ); sc = rtems_io_unregister_driver( registered ); directive_failed( sc, "rtems_io_unregister_driver" ); puts( "Init - rtems_io_register_driver - free slot" ); sc = rtems_io_register_driver( registered, &test_driver, ®istered ); directive_failed( sc, "rtems_io_register_driver" ); puts( "Init - rtems_io_register_driver - called from interrupt context" ); if ( do_interrupt_context_test ) { test_interrupt_context_enter( level ); sc = rtems_io_register_driver( 0, NULL, NULL ); test_interrupt_context_leave( level ); fatal_directive_status( sc, RTEMS_CALLED_FROM_ISR, "rtems_io_register_driver" ); } puts( "Init - rtems_io_register_driver - invalid registered major pointer" ); sc = rtems_io_register_driver( 0, NULL, NULL ); fatal_directive_status( sc, RTEMS_INVALID_ADDRESS, "rtems_io_register_driver" ); puts( "Init - rtems_io_register_driver - invalid driver table pointer" ); sc = rtems_io_register_driver( 0, NULL, ®istered ); fatal_directive_status( sc, RTEMS_INVALID_ADDRESS, "rtems_io_register_driver" ); puts( "Init - rtems_io_register_driver - invalid empty driver table" ); test_driver.open_entry = NULL; sc = rtems_io_register_driver( 0, &test_driver, ®istered ); test_driver.open_entry = test_open; fatal_directive_status( sc, RTEMS_INVALID_ADDRESS, "rtems_io_register_driver" ); puts( "Init - rtems_io_register_driver - invalid major" ); sc = rtems_io_register_driver( invalid_major, &test_driver, ®istered ); fatal_directive_status( sc, RTEMS_INVALID_NUMBER, "rtems_io_register_driver" ); puts( "Init - rtems_io_unregister_driver - called from interrupt context" ); if ( do_interrupt_context_test ) { test_interrupt_context_enter( level ); sc = rtems_io_unregister_driver( 0 ); test_interrupt_context_leave( level ); fatal_directive_status( sc, RTEMS_CALLED_FROM_ISR, "rtems_io_unregister_driver" ); } puts( "Init - rtems_io_unregister_driver - invalid major number" ); sc = rtems_io_unregister_driver( invalid_major ); fatal_directive_status( sc, RTEMS_UNSATISFIED, "rtems_io_unregister_driver" ); TEST_END(); rtems_test_exit( 0 ); }