/* * fs_stm32_init * This function is responsible for initializing file systems for STM32. */ void fs_stm32_init(void) { #if (defined(FS_FAT) && defined(CONFIG_MMC)) char mount_point[4] = "0:\\"; #ifdef MMC_SPI_FS /* Register MMC device with file system */ mmc_spi_fsregister(&mmc_spi, "\\mmc0"); #endif /* MMC_SPI_FS */ /* Initialize SPI device data. */ mmc_spi_stm32.device_num = 2; /* Hook-up SPI interface. */ mmc_spi.spi.baudrate = 21000000; mmc_spi.spi.cfg_flags = (SPI_CFG_MASTER | SPI_CFG_CLK_IDLE_HIGH); mmc_spi.spi.data = &mmc_spi_stm32; mmc_spi.spi.init = &spi_stm32f103_init; mmc_spi.spi.slave_select = &spi_stm32f103_slave_select; mmc_spi.spi.slave_unselect = &spi_stm32f103_slave_unselect; mmc_spi.spi.msg = &spi_stm32f103_message; /* Register this device with FatFile system. */ disk_register(&mmc_spi, &mmc_spi_init, &mmc_spi_read, &mmc_spi_write, MMC_SPI_SECTOR_SIZE, 0); /* Mount this drive later. */ f_mount(&fat_fs, mount_point, 0); #endif /* (defined(FS_FAT) && defined(CONFIG_MMC)) */ } /* fs_avr_init */
static rtems_task Init(rtems_task_argument argument) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_bdbuf_buffer *bd = NULL; dev_t dev = 0; rtems_disk_device *dd = NULL; printk("\n\n*** TEST BLOCK 9 ***\n"); sc = rtems_disk_io_initialize(); ASSERT_SC(sc); sc = disk_register(BLOCK_SIZE, BLOCK_COUNT, &dev); ASSERT_SC(sc); dd = rtems_disk_obtain(dev); assert(dd != NULL); check_read(dd, BLOCK_READ_IO_ERROR, RTEMS_IO_ERROR); check_read(dd, BLOCK_READ_UNSATISFIED, RTEMS_UNSATISFIED); check_read(dd, BLOCK_READ_SUCCESSFUL, RTEMS_SUCCESSFUL); check_read(dd, BLOCK_WRITE_IO_ERROR, RTEMS_SUCCESSFUL); /* Check write IO error */ sc = rtems_bdbuf_read(dd, BLOCK_WRITE_IO_ERROR, &bd); ASSERT_SC(sc); bd->buffer [0] = 1; sc = rtems_bdbuf_sync(bd); ASSERT_SC(sc); sc = rtems_bdbuf_read(dd, BLOCK_WRITE_IO_ERROR, &bd); ASSERT_SC(sc); assert(bd->buffer [0] == 0); sc = rtems_bdbuf_release(bd); ASSERT_SC(sc); /* Check write to deleted disk */ sc = rtems_bdbuf_read(dd, BLOCK_READ_SUCCESSFUL, &bd); ASSERT_SC(sc); sc = rtems_disk_delete(dev); ASSERT_SC(sc); sc = rtems_bdbuf_sync(bd); ASSERT_SC(sc); sc = rtems_disk_release(dd); ASSERT_SC(sc); printk("*** END OF TEST BLOCK 9 ***\n"); exit(0); }
/* * ======== ramdisk_start ======== * */ DRESULT ramdisk_start(BYTE drive, unsigned char *data, int numBytes, int mkfs) { DRESULT result; /* ensure 'drive' is a valid index */ if (drive >= _VOLUMES) { return RES_PARERR; } /* ensure this volume isn't already in use */ if (diskMem[drive] != NULL) { return RES_PARERR; } /* * Register the ramdisk functions with the diskio module. FatFS will * call these via the diskio function table. */ if ((result = disk_register(drive, ramdisk_init, ramdisk_status, ramdisk_read, ramdisk_write, ramdisk_ioctl)) != RES_OK) { return result; } /* if creating a new ramdisk, zero out 'data[]' and call f_mkfs() */ if (mkfs) { memset(data, 0, numBytes); } diskMem[drive] = data; numSectors[drive] = numBytes / SECTORSIZE; /* mount the drive */ if (f_mount(drive, &(ramdisk_filesystems[drive])) != FR_OK) { return RES_ERROR; } if (mkfs) { if (f_mkfs(drive, 0, 512) != FR_OK) { return RES_ERROR; } } return RES_OK; }
static rtems_task Init(rtems_task_argument argument) { rtems_status_code sc = RTEMS_SUCCESSFUL; unsigned i = 0; rtems_test_begink(); task_id_init = rtems_task_self(); sc = rtems_disk_io_initialize(); ASSERT_SC(sc); disk_register(BLOCK_SIZE_A, BLOCK_COUNT_A, &dd_a); disk_register(BLOCK_SIZE_B, BLOCK_COUNT_B, &dd_b); sc = rtems_task_create( rtems_build_name(' ', 'L', 'O', 'W'), PRIORITY_LOW, 0, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id_low ); ASSERT_SC(sc); sc = rtems_task_start(task_id_low, task_low, 0); ASSERT_SC(sc); sc = rtems_task_create( rtems_build_name('H', 'I', 'G', 'H'), PRIORITY_HIGH, 0, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id_high ); ASSERT_SC(sc); sc = rtems_task_start(task_id_high, task_high, 0); ASSERT_SC(sc); sc = rtems_task_create( rtems_build_name('R', 'E', 'S', 'U'), PRIORITY_RESUME, 0, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id_resume ); ASSERT_SC(sc); sc = rtems_task_start(task_id_resume, task_resume, 0); ASSERT_SC(sc); sc = rtems_task_suspend(task_id_low); ASSERT_SC(sc); sc = rtems_task_suspend(task_id_high); ASSERT_SC(sc); for (trig = SUSP; trig <= CONT; ++trig) { for (trig_get = GET; trig_get <= READ; ++trig_get) { for (low_get = GET; low_get <= READ; ++low_get) { for (high_get = GET; high_get <= READ; ++high_get) { for (trig_blk = BLK_A0; trig_blk <= BLK_B0; ++trig_blk) { for (low_blk = BLK_A0; low_blk <= BLK_B0; ++low_blk) { for (high_blk = BLK_A0; high_blk <= BLK_B0; ++high_blk) { for (trig_rel = REL; trig_rel <= SYNC; ++trig_rel) { for (low_rel = REL; low_rel <= SYNC; ++low_rel) { for (high_rel = REL; high_rel <= SYNC; ++high_rel) { execute_test(i); ++i; } } } } } } } } } } rtems_test_endk(); exit(0); }
static rtems_task Init(rtems_task_argument argument) { rtems_status_code sc = RTEMS_SUCCESSFUL; size_t i_w = 0; size_t i_ac = 0; size_t i_rel = 0; size_t i_p = 0; printk("\n\n*** TEST BLOCK 10 ***\n"); task_id_init = rtems_task_self(); sc = rtems_disk_io_initialize(); ASSERT_SC(sc); sc = disk_register(BLOCK_SIZE, BLOCK_COUNT, &dev); ASSERT_SC(sc); sc = rtems_task_create( rtems_build_name('P', 'U', 'R', 'G'), PRIORITY_HIGH, 0, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id_purger ); ASSERT_SC(sc); sc = rtems_task_start(task_id_purger, task_purger, 0); ASSERT_SC(sc); set_task_prio(task_id_purger, PRIORITY_LOW); sc = rtems_task_create( rtems_build_name('W', 'A', 'I', 'T'), PRIORITY_HIGH, 0, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id_waiter ); ASSERT_SC(sc); sc = rtems_task_start(task_id_waiter, task_waiter, 0); ASSERT_SC(sc); for (i_ac = 0; i_ac < ACCESS_COUNT; ++i_ac) { for (i_rel = 0; i_rel < RELEASE_COUNT; ++i_rel) { for (i_w = 0; i_w < WAITER_COUNT; ++i_w) { printk("test case [access]: %s and %s %s\n", access_assoc_table [i_ac], release_assoc_table [i_rel], waiter_assoc_table [i_w]); check_access(access_table [i_ac], release_table [i_rel], waiter_table [i_w]); } } } for (i_rel = 0; i_rel < RELEASE_COUNT; ++i_rel) { for (i_w = 0; i_w < WAITER_COUNT; ++i_w) { printk("test case [intermediate]: %s %s\n", release_assoc_table [i_rel], waiter_assoc_table [i_w]); check_intermediate(release_table [i_rel], waiter_table [i_w]); } } for (i_p = 0; i_p < PURGER_COUNT; ++i_p) { for (i_w = 0; i_w < WAITER_COUNT; ++i_w) { printk("test case [transfer]: %s %s\n", purger_assoc_table [i_p], waiter_assoc_table [i_w]); check_transfer(purger_table [i_p], waiter_table [i_w]); } } printk("*** END OF TEST BLOCK 10 ***\n"); exit(0); }
/* * ======== USBMSCHFatFsTiva_open ======== */ USBMSCHFatFs_Handle USBMSCHFatFsTiva_open(USBMSCHFatFs_Handle handle, unsigned char drv, USBMSCHFatFs_Params *params) { unsigned int key; DRESULT dresult; FRESULT fresult; USBMSCHFatFsTiva_Object *object = handle->object; USBMSCHFatFsTiva_HWAttrs const *hwAttrs = handle->hwAttrs; union { Task_Params taskParams; Semaphore_Params semParams; GateMutex_Params gateParams; Hwi_Params hwiParams; } paramsUnion; /* Determine if the device was already opened */ key = Hwi_disable(); if (object->driveNumber != DRIVE_NOT_MOUNTED) { Hwi_restore(key); return (NULL); } /* Mark as being used */ object->driveNumber = drv; Hwi_restore(key); /* Store the USBMSCHFatFs parameters */ if (params == NULL) { /* No params passed in, so use the defaults */ params = (USBMSCHFatFs_Params *) &USBMSCHFatFs_defaultParams; } /* Initialize the USB stack for host mode. */ USBStackModeSet(0, eUSBModeHost, NULL); /* Register host class drivers */ USBHCDRegisterDrivers(0, usbHCDDriverList, numHostClassDrivers); /* Open an instance of the MSC host driver */ object->MSCInstance = USBHMSCDriveOpen(0, USBMSCHFatFsTiva_cbMSCHandler); if (!(object->MSCInstance)) { Log_print0(Diags_USER1,"USBMSCHFatFs: Error initializing the MSC Host"); USBMSCHFatFsTiva_close(handle); return (NULL); } /* Create the Hwi object to service interrupts */ Hwi_Params_init(&(paramsUnion.hwiParams)); paramsUnion.hwiParams.priority = hwAttrs->intPriority; Hwi_construct(&(object->hwi), hwAttrs->intNum, USBMSCHFatFsTiva_hwiHandler, &(paramsUnion.hwiParams), NULL); /* Initialize USB power configuration */ USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER); /* Enable the USB stack */ USBHCDInit(0, object->memPoolHCD, HCDMEMORYPOOLSIZE); /* RTOS primitives */ Semaphore_Params_init(&(paramsUnion.semParams)); paramsUnion.semParams.mode = Semaphore_Mode_BINARY; Semaphore_construct(&(object->semUSBConnected), 0, &(paramsUnion.semParams)); GateMutex_Params_init(&(paramsUnion.gateParams)); paramsUnion.gateParams.instance->name = "USB Library Access"; GateMutex_construct(&(object->gateUSBLibAccess), &(paramsUnion.gateParams)); paramsUnion.gateParams.instance->name = "USB Wait"; GateMutex_construct(&(object->gateUSBWait), &(paramsUnion.gateParams)); /* * Note that serviceUSBHost() should not be run until the USB Stack has been * initialized!! */ Task_Params_init(&(paramsUnion.taskParams)); /* * If serviceTaskStackPtr is null, then Task_construct performs a * Memory_alloc - requiring a Heap */ paramsUnion.taskParams.stack = params->serviceTaskStackPtr; /* * If service priority passed in is higher than what is configured by the * Task module, then use the highest priority available. */ if (Task_numPriorities - 1 < params->servicePriority) { paramsUnion.taskParams.priority = (Task_numPriorities - 1); } else { paramsUnion.taskParams.priority = params->servicePriority; } /* If no stack size is passed in, then use the default task stack size */ if (params->serviceTaskStackSize) { paramsUnion.taskParams.stackSize = params->serviceTaskStackSize; } else { paramsUnion.taskParams.stackSize = Task_defaultStackSize; } Task_construct(&(object->taskHCDMain),USBMSCHFatFsTiva_serviceUSBHost, &(paramsUnion.taskParams), NULL); /* Register the new disk_*() functions */ dresult = disk_register(drv, USBMSCHFatFsTiva_diskInitialize, USBMSCHFatFsTiva_diskStatus, USBMSCHFatFsTiva_diskRead, USBMSCHFatFsTiva_diskWrite, USBMSCHFatFsTiva_diskIOctl); /* Check for drive errors */ if (dresult != RES_OK) { Log_error0("USBMSCHFatFs: disk functions not registered"); USBMSCHFatFsTiva_close(handle); return (NULL); } /* Mount the FatFs (this function does not access the SDCard yet...) */ fresult = f_mount(drv, &(object->filesystem)); if (fresult != FR_OK) { Log_error1("USBMSCHFatFs: drive %d not mounted", drv); USBMSCHFatFsTiva_close(handle); return (NULL); } Log_print1(Diags_USER1, "USBMSCHFatFs: drive %d opened", drv); return (handle); }