Denwis La
sd-driver 1.2.0 from github
Revision 0:f72b3e7f1ec8, committed 2018-04-12
- Comitter:
- SDesign2018
- Date:
- Thu Apr 12 01:36:31 2018 +0000
- Commit message:
- Same stuff;
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/README.md Thu Apr 12 01:36:31 2018 +0000
@@ -0,0 +1,690 @@
+# mbed OS SDCard Driver (sd-driver) for FAT32 Filesystem Support
+
+
+Simon Hughes
+
+20170329
+
+Version 0.1.1
+
+
+# Executive Summary
+
+The purpose of this document is to describe how to use the mbed OS SDCard
+driver (sd-driver) so applications can read/write
+data to flash storage cards using the standard POSIX File API
+programming interface. The sd-driver uses the SDCard SPI-mode of operation
+which is a subset of possible SDCard functionality.
+
+This repository contains the mbed-os SDCard driver for generic SPI
+SDCard support and other resources, as outlined below:
+
+- `SDBlockDevice.h` and `SDBlockDevice.cpp`. This is the SDCard driver module presenting
+ a Block Device API (derived from BlockDevice) to the underlying SDCard.
+- POSIX File API test cases for testing the FAT32 filesystem on SDCard.
+ - basic.cpp, a basic set of functional test cases.
+ - fopen.cpp, more functional tests reading/writing greater volumes of data to SDCard, for example.
+- `mbed_lib.json` mbed-os application configuration file with SPI pin configurations for the CI shield and overrides for specific targets.
+ This file allows the SPI pins to be specified for the target without having to edit the implementation files.
+- This README which includes [Summary of POSIX File API Documentation](#summary-posix-api-documentation)
+ including detailed instruction on how to use the FAT filesystem and SDBlockDevice driver.
+
+The SDCard driver is maintained in this repository as a component separate from the main mbed OS repository.
+Hence the 2 repositories (mbed-os and sd-driver) have to be used together
+to deliver the FAT32 Filesystem/SDCard support. This document explains how to do this.
+
+
+# Introduction
+
+### Overview
+
+The scope of this document is to describe how applications use the FAT filesystem and sd-driver
+components to persistently store data on SDCards. The document is intended to help developers adopt the
+mbed OS POSIX File API support, and in particular to help explain:
+
+- How the software components work together to deliver the storage functionality.
+- How to work with the sd-driver and mbed OS to build the examples. The example code can easily
+ be copied into your new application code.
+- How to work with the CI Test Shield, which adds an SDCard slot to those targets that do not have already have one.
+- How to run the POSIX File API mbed Greentea test cases, which provide further example code of how to use
+ the POSIX File API.
+
+Section 1 provides an Executive Summary, describing the purpose of the sd-driver, the supporting
+software, examples, test cases and documentation.
+
+Section 2 provides an an overview of the material covered including descriptions of the major sections.
+
+Section 3 provides an overview of the mbed OS filesystem software components,
+including the inter-relationships between the application, POSIX file API, the standard c-library,
+the mbed OS filesystem and the SDCard driver (sd-driver).
+
+Section 4 describes how to build and run an example application for reading
+and writing data to an SDCard using the POSIX File API. The example begins by describing
+the procedure for building and testing on the K64F target. The final sub-sections
+describe how to use the test shield to add an SDCard slot to any mbed target,
+and hence enable the persistent storage of data on any supported target.
+
+Section 5 describes an example application which uses the raw
+BlockDevice API to read and write data to the SDCard.
+
+Section 6 describes how to build and run the SDCard POSIX File API mbed Greentea test cases.
+There are a number of functional test cases demonstrating how to use the
+mbed OS POSIX File API.
+
+Section 7 describes the POSIX File API and provides links to useful API documentation web pages.
+
+
+### Known mbed-os and sd-driver Compatible Versions
+
+The following versions of the mbed-os and sd-driver repositories are known to work together:
+
+- {mbed-os, sd-driver} = {mbed-os-5.4.0-rc2, sd-driver-0.0.1-mbed-os-5.4.0-rc2}.
+ `K64F`, `NUCLEO_F429ZI` and `UBLOX_EVK_ODIN_W2` fopen and basic filesystem tests working.
+- {mbed-os, sd-driver} = {mbed-os-5.4.0, sd-driver-0.0.2-mbed-os-5.4.0}.
+ `K64F`, `NUCLEO_F429ZI` and `UBLOX_EVK_ODIN_W2` fopen and basic filesystem tests working.
+- {mbed-os, sd-driver} = {mbed-os-5.4.1, sd-driver-0.0.3-mbed-os-5.4.1}.
+- {mbed-os, sd-driver} = {mbed-os-5.5.1, sd-driver-0.1.0-mbed-os-5.5.1}.
+- {mbed-os, sd-driver} = {mbed-os-5.5.4, sd-driver-0.1.1-mbed-os-5.5.4}.
+- {mbed-os, sd-driver} = {mbed-os-5.6.1, sd-driver-0.1.2-mbed-os-5.6.1}.
+
+To find the latest compatible versions, use the following command to see the messages attached to the tags
+in the sd-driver repository:
+
+ ex_app7/$ cd sd-driver
+ ex_app7/sd-driver$ git tag -n
+ sd-driver-0.0.1-mbed-os-5.3.4 Version compatible with mbed-os-5.3.4, and private_mbedos_filesystems-0.0.1-mbed-os-5.3.4.
+ sd-driver-0.0.2-mbed-os-5.4.0 Updated README.md to include worked exmaples and restructuring of information.
+ sd-driver-0.0.3-mbed-os-5.4.1 Version compatible with mbed-os-5.4.1.
+ sd-driver-0.1.1-mbed-os-5.5.4 Version compatible with mbed-os-5.5.4
+ sd-driver-0.1.2-mbed-os-5.6.1 Version compatible with mbed-os-5.6.1
+
+
+### Known Issues With This Document
+
+There are no known issues with this document.
+
+
+# Overview of mbed OS Filesystem Software Component Stack
+
+
+ ------------------------
+ | |
+ | Application | // This application uses the POSIX File API
+ | | // to read/write data to persistent storage backends.
+ ------------------------
+
+ ------------------------ // POSIX File API (ISO).
+
+ ------------------------
+ | |
+ | libc | // The standard c library implementation
+ | | // e.g. newlib.
+ ------------------------
+
+ ------------------------ // sys_xxx equivalent API.
+
+ ------------------------
+ | |
+ | mbed_retarget.cpp | // Target specific mapping layer.
+ | |
+ ------------------------
+
+ ------------------------ // Filesystem Upper Edge API.
+
+ ------------------------
+ | |
+ | File System | // File system wrappers and implementation.
+ | |
+ ------------------------
+
+ ------------------------ // FS Lower Edge API (Block Store Interface).
+
+ ------------------------
+ | Block API |
+ | Device Driver | // The SDCard driver, for example.
+ | e.g. sd-driver |
+ ------------------------
+
+ ------------------------ // SPI.h interface.
+
+ ------------------------
+ | |
+ | SPI | // SPI subsystem (C++ classes and C-HAL implementation).
+ | |
+ ------------------------
+
+ Figure 1. mbedOS generic architecture of filesystem software stack.
+
+The figure above shows the mbed OS software component stack used for data
+storage on SDCard:
+
+- At the top level is the application component which uses the standard POSIX File API
+ to read and write application data to persistent storage.
+- The newlib standard library (libc) stdio.h interface (POSIX File API)
+ implementation is used as it's optimised for resource limited embedded systems.
+- mbed_retarget.cpp implements the libc back-end file OS handlers and maps them
+ to the FileSystem.
+- The File System code (hosted in mbed-os) is composed of 2 parts:
+ - The mbed OS file system wrapper classes (e.g. FileSystem, File, FileBase classes)
+ which are used to present a consistent API to the retarget module for different
+ (third-party) file system implementations.
+ - The FAT filesystem implementation code.
+ The [FATFS: Generic FAT File System Module](http://elm-chan.org/fsw/ff/00index_e.html)
+ (ChanFS) has been integrated within mbed-os.
+- The Block API Device Driver. The SDCard driver is an example of a persistent storage driver.
+ It's maintained as a separate component from the mbed OS repository (in this repository).
+- The SPI module provides the mbed OS generic SPI API. This functionality is maintained in
+ mbed OS.
+
+
+# SDCard POSIX File API Example App for Reading/Writing Data
+
+Refer to [SD driver Example](https://github.com/ARMmbed/mbed-os-example-sd-driver)
+
+
+### <a name="testing-with-an-sdcard-on-target-xyx"></a> Testing with an SDCard on Target XYZ
+
+The standard way to test is with the mbed CI Test Shield plugged into the
+target board. This pin mapping for this configuration is parameterised in
+the `mbed_lib.json` file.
+
+The following is an example of the `mbed_lib.json` file available in the repository:
+
+ {
+ "config": {
+ "UART_RX": "D0",
+ "UART_TX": "D1",
+ "DIO_0": "D0",
+ "DIO_1": "D1",
+ "DIO_2": "D2",
+ "DIO_3": "D3",
+ "DIO_4": "D4",
+ "DIO_5": "D5",
+ "DIO_6": "D6",
+ "DIO_7": "D7",
+ "DIO_8": "D8",
+ "DIO_9": "D9",
+ "SPI_CS": "D10",
+ "SPI_MOSI": "D11",
+ "SPI_MISO": "D12",
+ "SPI_CLK": "D13",
+ "I2C_SDA": "D14",
+ "I2C_SCL": "D15",
+ "I2C_TEMP_ADDR":"0x90",
+ "I2C_EEPROM_ADDR":"0xA0",
+ "AIN_0": "A0",
+ "AIN_1": "A1",
+ "AIN_2": "A2",
+ "AIN_3": "A3",
+ "AIN_4": "A4",
+ "AIN_5": "A5",
+ "AOUT" : "A5",
+ "PWM_0": "D3",
+ "PWM_1": "D5",
+ "PWM_2": "D6",
+ "PWM_3": "D9",
+ "DEBUG_MSG": 0,
+ "DEVICE_SPI": 1,
+ "FSFAT_SDCARD_INSTALLED": 1
+ },
+ "target_overrides": {
+ "DISCO_F051R8": {
+ "SPI_MOSI": "SPI_MOSI",
+ "SPI_MISO": "SPI_MISO",
+ "SPI_CLK": "SPI_SCK",
+ "SPI_CS": "SPI_CS"
+ },
+ "K20D50M": {
+ "SPI_MOSI": "PTD2",
+ "SPI_MISO": "PTD3",
+ "SPI_CLK": "PTD1",
+ "SPI_CS": "PTC2"
+ },
+ "KL22F": {
+ "SPI_MOSI": "PTD6",
+ "SPI_MISO": "PTD7",
+ "SPI_CLK": "PTD5",
+ "SPI_CS": "PTD4"
+ },
+ "KL25Z": {
+ "SPI_MOSI": "PTD2",
+ "SPI_MISO": "PTD3",
+ "SPI_CLK": "PTD1",
+ "SPI_CS": "PTD0"
+ },
+ "KL43Z": {
+ "SPI_MOSI": "PTD6",
+ "SPI_MISO": "PTD7",
+ "SPI_CLK": "PTD5",
+ "SPI_CS": "PTD4"
+ },
+ "KL46Z": {
+ "SPI_MOSI": "PTD6",
+ "SPI_MISO": "PTD7",
+ "SPI_CLK": "PTD5",
+ "SPI_CS": "PTD4"
+ },
+ "K64F": {
+ "SPI_MOSI": "PTE3",
+ "SPI_MISO": "PTE1",
+ "SPI_CLK": "PTE2",
+ "SPI_CS": "PTE4"
+ },
+ "K66F": {
+ "SPI_MOSI": "PTE3",
+ "SPI_MISO": "PTE1",
+ "SPI_CLK": "PTE2",
+ "SPI_CS": "PTE4"
+ },
+ "LPC11U37H_401": {
+ "SPI_MOSI": "SDMOSI",
+ "SPI_MISO": "SDMISO",
+ "SPI_CLK": "SDSCLK",
+ "SPI_CS": "SDSSEL"
+ },
+ "LPC2368": {
+ "SPI_MOSI": "p11",
+ "SPI_MISO": "p12",
+ "SPI_CLK": "p13",
+ "SPI_CS": "p14"
+ },
+ "NUCLEO_L031K6": {
+ "SPI_MOSI": "SPI_MOSI",
+ "SPI_MISO": "SPI_MISO",
+ "SPI_CLK": "SPI_SCK",
+ "SPI_CS": "SPI_CS"
+ },
+ "nRF51822": {
+ "SPI_MOSI": "p12",
+ "SPI_MISO": "p13",
+ "SPI_CLK": "p15",
+ "SPI_CS": "p14"
+ },
+ "RZ_A1H": {
+ "SPI_MOSI": "P8_5",
+ "SPI_MISO": "P8_6",
+ "SPI_CLK": "P8_3",
+ "SPI_CS": "P8_4"
+ }
+ }
+ }
+
+Note the following things about the `mbed_lib.json` file:
+
+- The `mbed_lib.json` file is used to define target specific symbols for the SPI pins connecting the SDCard slot to the target MCU:
+ - "SPI\_CS". This is the Chip Select line.
+ - "SPI\_MOSI". This is the Master Out Slave In data line.
+ - "SPI\_MISO". This is the Master In Slave Out data line.
+ - "SPI\_CLK". This is the serial Clock line.
+- The default configuration defined in the "config" section is for the standard Arduino header pin mappings for the SPI bus.
+ The "config" section defines a dictionary mapping functional names to target board Arduino header pins:
+ - "SPI\_CS": "D10". This causes the MBED\_CONF\_APP\_SPI\_CS symbol to be defined in mbed\_config.h as D10, which is used in the filesystem test implementation.
+ D10 is defined in the target specific PinNames.h file.
+ - "SPI\_MOSI": "D11". This causes the MBED\_CONF\_APP\_SPI\_MOSI symbol to be defined in mbed\_config.h.
+ - "SPI\_MISO": "D12". This causes the MBED\_CONF\_APP\_SPI\_MISO symbol to be defined in mbed\_config.h.
+ - "SPI\_CLK": "D13". This causes the MBED\_CONF\_APP\_SPI\_CLK symbol to be defined in mbed\_config.h.
+- The `"target_overrides"` section is used to override the "SPI\_xxx" symbols for specific target boards, which may have an SDCard slot, for example.
+ This is the case for the K64F, where the "SPI\_xxx" are mapped to the pin names for the on-board SDCard.
+
+ ```
+ "K64F": {
+ "SPI_MOSI": "PTE3",
+ "SPI_MISO": "PTE1",
+ "SPI_CLK": "PTE2",
+ "SPI_CS": "PTE4"
+ }
+ ```
+- Thus, in the absence of any target specific definitions in the `"target_overrides"` section, all boards will default to
+ using the Arduino header configuration. For those platforms with a `"target_overrides"` section then this configuration
+ will be used in preference.
+- Hence in the case that you want to test a platform with an SDCard inserted into a
+ fitted CI test shield (rather than the on-board SDCard slot)
+ and there is a `"target_overrides"` section present in the `mbed_lib.json` file, you must then delete the `"target_overrides"`
+ section before building. This will result in the default configuration being used (suitable for the CI
+ Test Shield).
+- Note when inserting the v1.0.0 CI Test Shield into the Arduino header of the target platform, the shield pins D0 and
+ D1 should be bent to be parallel to the shield PCB so they are not inserted into the Arduino header. This is because
+ some boards use the same UART on DAPLINK and D0/D1, which means the serial debug channel breaks and hence the mbed greentea
+ test suite will not work correctly. This is mainly on older ST boards and should not be a problem on
+ `K64F`, `NUCLEO_F429ZI` and `UBLOX_EVK_ODIN_W2`. Note also that the v2.0.0 CI Test Shield doesn't suffer from this
+ problem and the pins don't need to be bent.
+- When inserting the SDCard into the card slot on the CI test shield, make sure the card is fully inserted.
+ On insertion, there should be a small clicking sound when the card registers, and the back edge of the card
+ should protrude no more than ~1mm over the edge of the CI test shield PCB. If the SDCard fails to register,
+ try gently pushing the metal flexible strip in the shape of a spade at the top edge of the SDCard metal slot
+ casing with a pair of tweezers, bending it a little to lower it into the slot casing. This helps with the
+ insertion mechanism.
+
+### Wiring instructions for target NUCLEO_F429ZI with CI Test Shield
+
+
+**Figure 3. The figure shows how to connect the NUCLEO_F429ZI platform with the CI shield.**
+
+The above figure shows how to connect the NUCLEO_F429ZI with the v1.0.0 CI test shield. Note:
+
+- To get the SD Card to work with this platform the CI test shield cannot be connected directly to this board, instead follow the instructions above.
+- Any SD-card adapter will work as long as you connect all the relevant pins (MOSI, MISO, SCLK, CS, 3.3V and GND) as illustrated in figure 3.
+- The SDCard is fully inserted into the slot and overhangs the PCB by ~1mm.
+
+# SDBlockDevice Example Application
+
+The following sample code illustrates how to use the sd-driver Block Device API:
+
+``` cpp
+#include "mbed.h"
+#include "SDBlockDevice.h"
+
+// Instantiate the SDBlockDevice by specifying the SPI pins connected to the SDCard
+// socket. The PINS are:
+// MOSI (Master Out Slave In)
+// MISO (Master In Slave Out)
+// SCLK (Serial Clock)
+// CS (Chip Select)
+SDBlockDevice sd(MBED_CONF_SD_SPI_MOSI, MBED_CONF_SD_SPI_MISO, MBED_CONF_SD_SPI_CLK, MBED_CONF_SD_SPI_CS);
+uint8_t block[512] = "Hello World!\n";
+
+int main()
+{
+ // call the SDBlockDevice instance initialisation method.
+ if ( 0 != sd.init()) {
+ printf("Init failed \n");
+ return -1;
+ }
+ printf("sd size: %llu\n", sd.size());
+ printf("sd read size: %llu\n", sd.get_read_size());
+ printf("sd program size: %llu\n", sd.get_program_size());
+ printf("sd erase size: %llu\n", sd.get_erase_size());
+
+ // set the frequency
+ if ( 0 != sd.frequency(5000000)) {
+ printf("Error setting frequency \n");
+ }
+
+ if ( 0 != sd.erase(0, sd.get_erase_size())) {
+ printf("Error Erasing block \n");
+ }
+
+ // Write some the data block to the device
+ if ( 0 == sd.program(block, 0, 512)) {
+ // read the data block from the device
+ if ( 0 == sd.read(block, 0, 512)) {
+ // print the contents of the block
+ printf("%s", block);
+ }
+ }
+
+ // call the SDBlockDevice instance de-initialisation method.
+ sd.deinit();
+}
+```
+
+# SDCard POSIX File API mbed Greentea Test Cases
+
+This section describes how to build and run the POSIX file API test cases.
+The following steps are covered:
+
+- [Create the FAT/SDCard Application Project](#create-fat-sdcard-application-project).
+ This section describes how to git clone the mbed OS and sd-driver repositories containing the
+ code and test cases of interest.
+- [Build the mbed OS Test Cases](#build-the-mbedos-test-cases). This section
+ describes how to build the mbed OS test cases.
+- [Insert a microSD Card Into the K64F for Greentea Testing](#greentea-insert-sdcard-into-k64f).This section
+ describes how to format (if required) a microSD card prior to running the tests.
+- [Run the POSIX File Test Case](#run-the-posix-file-test-cases).This section
+ describes how to run the POSIX file test cases.
+
+
+### <a name="create-fat-sdcard-application-project"></a> Create the FAT/SDCard Application Project
+
+This section describes how to create an application project combining the mbed-os and
+sd-driver repositories into a single project.
+In summary the following steps will be covered in this section:
+
+- A top level application project directory is created. The directory name is ex_app1.
+- In the ex_app1 directory, the mbed-os repository is cloned.
+- In the ex_app1 directory at the same level as the mbed-os directory, the sd-driver repository is cloned.
+- The `mbed_lib.json` file is copied from the `sd-driver/config/mbed_lib.json` to the ex_app1 directory.
+
+First create the top level application directory ex_app1 and move into it:
+
+ shell:/d/demo_area$ mkdir ex_app1
+ shell:/d/demo_area$ pushd ex_app1
+
+Next, get a clone of public mbed OS repository in the following way:
+
+ shell:/d/demo_area/ex_app1$ git clone git@github.com:/armmbed/mbed-os
+ <trace removed>
+ shell:/d/demo_area/ex_app1$
+
+Next, get a clone of the sd-driver repository:
+
+ shell:/d/demo_area/ex_app1$ git clone git@github.com:/armmbed/sd-driver
+ <trace removed>
+ shell:/d/demo_area/ex_app1$
+
+Note: The `mbed_lib.json` file specifies the SPI bus pin configuration for different targets,
+and is discussed in the [Testing with an SDCard on Target XYZ](#testing-with-an-sdcard-on-target-xyx) section.
+
+### <a name="build-the-mbedos-test-cases"></a> Build the mbed OS Test Cases
+
+Build the test cases for the K64F target using the following command:
+
+ shell:/d/demo_area/ex_app1$ mbed -v test --compile -t GCC_ARM -m K64F
+ <trace removed>
+ shell:/d/demo_area/ex_app1$
+
+The build trace is quite extensive but on a successful build you should see the following output at the end of the log:
+
+ Build successes:
+ * K64F::GCC_ARM::MBED-BUILD
+ * K64F::GCC_ARM::MBED-OS-FEATURES-FEATURE_LWIP-TESTS-MBEDMICRO-NET-CONNECTIVITY
+ <trace removed>
+ * K64F::GCC_ARM::MBED-OS-FEATURES-TESTS-FILESYSTEM-FAT_FILE_SYSTEM
+ * K64F::GCC_ARM::MBED-OS-FEATURES-TESTS-FILESYSTEM-HEAP_BLOCK_DEVICE
+ * K64F::GCC_ARM::MBED-OS-FEATURES-TESTS-FILESYSTEM-UTIL_BLOCK_DEVICE
+ <trace removed>
+ * K64F::GCC_ARM::SD-DRIVER-TESTS-FILESYSTEM-BASIC
+ * K64F::GCC_ARM::SD-DRIVER-TESTS-FILESYSTEM-FOPEN
+ * K64F::GCC_ARM::SD-DRIVER-TESTS-BLOCK_DEVICE-BASIC
+
+ Build skips:
+ * K64F::GCC_ARM::MBED-OS-FEATURES-FEATURE_LWIP-TESTS-MBEDMICRO-NET-TCP_PACKET_PRESSURE
+ <trace removed>
+
+
+Notice the following tests in the sd-driver tree are listed above:
+
+- `K64F::GCC_ARM::SD-DRIVER-TESTS-FILESYSTEM-BASIC`
+- `K64F::GCC_ARM::SD-DRIVER-TESTS-FILESYSTEM-FOPEN`
+- `K64F::GCC_ARM::SD-DRIVER-TESTS-BLOCK_DEVICE-BASIC`
+
+The FAT32/SDCard test cases are at following locations in the source code tree:
+
+ /d/demo_area/ex_app1/sd-driver/TESTS/filesystem/basic/basic.cpp
+ /d/demo_area/ex_app1/sd-driver/TESTS/filesystem/fopen/fopen.cpp
+ /d/demo_area/ex_app1/sd-driver/TESTS/block_device/basic/basic.cpp
+
+#### <a name="settting-repos-to-compatible-versions"></a> Setting mbed-os/sd-driver Repositories To Compatible Versions
+
+The sd-driver master HEAD and the mbed-os master HEAD should be compatible
+with one another and therefore no specific tagged versions need to be checked out.
+However, in the case that you experience problems building, checkout out the compatible
+tagged version of each repository, as shown below:
+
+ shell:/d/demo_area/ex_app1$ pushd mbed-os
+ shell:/d/demo_area/ex_app1$ git checkout tags/mbed-os-5.4.0
+ shell:/d/demo_area/ex_app1$ popd
+ shell:/d/demo_area/ex_app1$ pushd sd-driver
+ shell:/d/demo_area/ex_app1$ git checkout tags/sd-driver-0.0.2-mbed-os-5.4.0
+ shell:/d/demo_area/ex_app1$ popd
+
+In the above:
+
+- `mbed-os-5.4.0` should be replaced with the latest mbed-os release tag.
+- For an mbed-os release tag `mbed-os-x.y.z`, use the equivalent sd-driver tag `sd-driver-a.b.c-mbed-os-x.y.z`
+ where `a.b.c` is the latest version code for the `mbed-os-x.y.z` tag.
+
+### <a name="greentea-insert-sdcard-into-k64f"></a> Insert SDCard into K64F for Greentea Testing
+
+See the previous section for [Insert SDCard into K64F](#insert-sdcard-into-k64f) for details.
+
+
+### <a name="run-the-posix-file-test-cases"></a> Run the POSIX File Test Case
+
+To setup for running the test cases, connect the K64F development board to your
+PC using a suitable USB cable.
+
+All tests can be run using the following command:
+
+ shell:/d/demo_area/ex_app1$ mbedgt -VS
+ <trace removed>
+
+However, it's possible to run a particular test case using the following form of the mbedgt command:
+
+ shell:/d/demo_area/ex_app1$ mbedgt -VS --test-by-names=<test-name>
+
+The names of the tests can be listed using:
+
+ shell:/d/demo_area/ex_app1$ mbedgt -VS --list
+
+For example, to run the basic test use:
+
+ shell:/d/demo_area/ex_app1$ mbedgt -VS --test-by-names=sd-driver-tests-filesystem-basic
+
+To run the fopen test use:
+
+ shell:/d/demo_area/ex_app1$ mbedgt -VS --test-by-names=sd-driver-tests-filesystem-fopen
+
+On a successful run, results similar to the following will be shown:
+
+ mbedgt: test suite report:
+ +--------------+---------------+-------------------------------------------+--------+--------------------+-------------+
+ | target | platform_name | test suite | result | elapsed_time (sec) | copy_method |
+ +--------------+---------------+-------------------------------------------+--------+--------------------+-------------+
+ | K64F-GCC_ARM | K64F | sd-driver-features-tests-filesystem-fopen | OK | 151.46 | shell |
+ +--------------+---------------+-------------------------------------------+--------+--------------------+-------------+
+ mbedgt: test suite results: 1 OK
+ mbedgt: test case report:
+ +--------------+---------------+------------------------------------+----------------------------------------------------------------------------------------+--------+--------+--------+--------------------+
+ | target | platform_name | test suite | test case | passed | failed | result | elapsed_time (sec) |
+ +--------------+---------------+------------------------------------+----------------------------------------------------------------------------------------+--------+--------+--------+--------------------+
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_01: fopen()/fwrite()/fclose() directories/file in multi-dir filepath. | 1 | 0 | OK | 7.57 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_02: fopen(r) pre-existing file try to write it. | 1 | 0 | OK | 0.2 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_03: fopen(w+) pre-existing file try to write it. | 1 | 0 | OK | 0.41 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_04: fopen() with a filename exceeding the maximum length. | 1 | 0 | OK | 0.11 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_06: fopen() with bad filenames (minimal). | 1 | 0 | OK | 0.1 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_07: fopen()/errno handling. | 1 | 0 | OK | 0.07 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_08: ferror()/clearerr()/errno handling. | 1 | 0 | OK | 0.1 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_09: ftell() handling. | 1 | 0 | OK | 0.17 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_10: remove() test. | 1 | 0 | OK | 1.28 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_11: rename(). | 1 | 0 | OK | 2.3 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_12: opendir(), readdir(), closedir() test. | 1 | 0 | OK | 3.57 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_13: mkdir() test. | 1 | 0 | OK | 1.21 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_14: stat() test. | 1 | 0 | OK | 1.47 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_15: format() test. | 1 | 0 | OK | 26.12 |
+ | K64F-GCC_ARM | K64F | sd-driver-tests-filesystem-fopen | FSFAT_FOPEN_TEST_16: write/check n x 25kB data files. | 1 | 0 | OK | 87.11 |
+ +--------------+---------------+------------------------------------+----------------------------------------------------------------------------------------+--------+--------+--------+--------------------+
+ mbedgt: test case results: 15 OK
+ mbedgt: completed in 152.35 sec
+
+
+# <a name="summary-posix-api-documentation"></a> Summary of POSIX File API Documentation
+
+### POSIX File API
+
+mbed OS supports a subset of the POSIX File API, as outlined below:
+
+- [clearerr()](https://linux.die.net/man/3/clearerr).
+ - STATUS: Basic testing implemented. Working.
+- [fclose()](https://linux.die.net/man/3/fclose).
+ - STATUS: Basic testing implemented. Working.
+- [ferror()](https://linux.die.net/man/3/clearerr).
+ - STATUS: Basic testing implemented.
+ - STATUS: GCC_ARM: Working.
+ - STATUS: ARMCC: ARMCC has problem with ferror(filep) where filep is NULL. Appears to work for non-NULL pointer.
+- [fgetc()](https://linux.die.net/man/3/fgets).
+ - STATUS: Basic testing implemented. Working.
+- [fgets()](https://linux.die.net/man/3/fgets).
+ - STATUS: Basic testing implemented. Working.
+- [fputc()](https://linux.die.net/man/3/fputs).
+ - STATUS: Unknown.
+- [fputs()](https://linux.die.net/man/3/fputs).
+ - STATUS: Basic testing implemented. Working.
+- [fprintf()](https://linux.die.net/man/3/fprintf).
+ - STATUS: Basic testing implemented. Working.
+- [fopen()](https://linux.die.net/man/3/fopen).
+ - STATUS: Basic testing implemented. Working.
+- [freopen()](https://linux.die.net/man/3/fopen).
+ - STATUS: This is not tested.
+- [fread()](https://linux.die.net/man/3/fread).
+ - STATUS: Basic testing implemented. Working.
+ - STATUS: n x 25kB stress test working.
+- [ftell()](https://linux.die.net/man/3/ftell).
+ - STATUS: Basic testing implemented. Working.
+- [fwrite()](https://linux.die.net/man/3/fwrite).
+ - STATUS: Basic testing implemented. Working.
+ - STATUS: n x 25kB stress test working.
+- [fseek()](https://linux.die.net/man/3/fseek)
+ - STATUS: Basic testing implemented. Working.
+- [getc()](https://linux.die.net/man/3/fgets).
+ - STATUS: Basic testing implemented. Working.
+- [gets()](https://linux.die.net/man/3/fgets).
+ - STATUS: Unknown.
+- [putc()](https://linux.die.net/man/3/fputs).
+ - STATUS: Unknown.
+- [puts()](https://linux.die.net/man/3/fputs).
+ - STATUS: Unknown.
+- [remove()](https://linux.die.net/man/3/remove)
+ - STATUS: Basic testing implemented. Working.
+- [rewind()](https://linux.die.net/man/3/rewind).
+ - STATUS: Basic testing implemented. Working.
+- [stat()](https://linux.die.net/man/2/stat)
+ - STATUS: Implemented. Working.
+ - STATUS: Not supported by ARMCC/IAR libc.
+- [tmpfile()](https://linux.die.net/man/3/tmpfile).
+ - STATUS: Not implemented.
+- [tmpnam()](https://linux.die.net/man/3/tmpnam).
+ - STATUS: Not implemented.
+
+Supported directory related operations are as follows:
+
+- [closedir()](https://linux.die.net/man/3/closedir).
+ - STATUS: Implemented. Working.
+- [mkdir()](https://linux.die.net/man/3/mkdir).
+ - STATUS: Basic testing implemented. Working.
+- [opendir()](https://linux.die.net/man/3/opendir).
+ - STATUS: Implemented. Working.
+- [readdir()](https://linux.die.net/man/3/readdir).
+ - STATUS: Implemented. Working.
+- [remove()](https://linux.die.net/man/3/remove).
+ - STATUS: Basic testing implemented. Working.
+- [rename()](https://linux.die.net/man/3/rename).
+ - STATUS: Implemented. Not tested.
+- [rewinddir()](https://linux.die.net/man/3/rewinddir).
+ - STATUS: Implemented. Found not to work. Test case not present in repo.
+- [seekdir()](https://linux.die.net/man/3/seekdir).
+ - STATUS: Implemented. Found not to work. Test case not present in repo.
+- [telldir()](https://linux.die.net/man/3/telldir).
+ - STATUS: Implemented. Found not to work. Test case not present in repo.
+
+### errno
+
+Basic errno reporting is supported, tested and known to be working.
+
+
+# Related Projects Resources
+
+The following are related mbed storage projects and useful resources:
+
+- The [mbed-os](https://github.com/ARMmbed/mbed-os) main repository.
+- The [mbed-os-example-fat-filesystem](https://github.com/ARMmbed/mbed-os-example-fat-filesystem) repository.
+ This is an example project for the mbed OS FAT filesystem.
+- The [spiflash-driver](https://github.com/armmbed/spiflash-driver) repository.
+- The [i2ceeprom-driver](https://github.com/ARMmbed/i2ceeprom-driver.git) repository.
+- The [ci-test-shield](https://github.com/ARMmbed/ci-test-shield) repository. This is the project describing
+ the mbed-os Continuous Integration test shield, together with standard tests.
+- The [mbed-HDK](https://github.com/ARMmbed/mbed-HDK) repository containing Hardware Development Kit resources
+ including the schematics for the CI test shield.
+- [POSIX File Interface ISO/IEC 9899:TC2 Documentation](http://www.eng.utah.edu/~cs5785/slides-f10/n1124.pdf).
+- [FATFS: Generic FAT File System Module used in mbed OS](http://elm-chan.org/fsw/ff/00index_e.html)
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SDBlockDevice.cpp Thu Apr 12 01:36:31 2018 +0000
@@ -0,0 +1,1014 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2006-2012 ARM Limited
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/* Introduction
+ * ------------
+ * SD and MMC cards support a number of interfaces, but common to them all
+ * is one based on SPI. Since we already have the mbed SPI Interface, it will
+ * be used for SD cards.
+ *
+ * The main reference I'm using is Chapter 7, "SPI Mode" of:
+ * http://www.sdcard.org/developers/tech/sdcard/pls/Simplified_Physical_Layer_Spec.pdf
+ *
+ * SPI Startup
+ * -----------
+ * The SD card powers up in SD mode. The start-up procedure is complicated
+ * by the requirement to support older SDCards in a backwards compatible
+ * way with the new higher capacity variants SDHC and SDHC.
+ *
+ * The following figures from the specification with associated text describe
+ * the SPI mode initialisation process:
+ * - Figure 7-1: SD Memory Card State Diagram (SPI mode)
+ * - Figure 7-2: SPI Mode Initialization Flow
+ *
+ * Firstly, a low initial clock should be selected (in the range of 100-
+ * 400kHZ). After initialisation has been completed, the switch to a
+ * higher clock speed can be made (e.g. 1MHz). Newer cards will support
+ * higher speeds than the default _transfer_sck defined here.
+ *
+ * Next, note the following from the SDCard specification (note to
+ * Figure 7-1):
+ *
+ * In any of the cases CMD1 is not recommended because it may be difficult for the host
+ * to distinguish between MultiMediaCard and SD Memory Card
+ *
+ * Hence CMD1 is not used for the initialisation sequence.
+ *
+ * The SPI interface mode is selected by asserting CS low and sending the
+ * reset command (CMD0). The card will respond with a (R1) response.
+ * In practice many cards initially respond with 0xff or invalid data
+ * which is ignored. Data is read until a valid response is received
+ * or the number of re-reads has exceeded a maximim count. If a valid
+ * response is not received then the CMD0 can be retried. This
+ * has been found to successfully initialise cards where the SPI master
+ * (on MCU) has been reset but the SDCard has not, so the first
+ * CMD0 may be lost.
+ *
+ * CMD8 is optionally sent to determine the voltage range supported, and
+ * indirectly determine whether it is a version 1.x SD/non-SD card or
+ * version 2.x. I'll just ignore this for now.
+ *
+ * ACMD41 is repeatedly issued to initialise the card, until "in idle"
+ * (bit 0) of the R1 response goes to '0', indicating it is initialised.
+ *
+ * You should also indicate whether the host supports High Capicity cards,
+ * and check whether the card is high capacity - i'll also ignore this
+ *
+ * SPI Protocol
+ * ------------
+ * The SD SPI protocol is based on transactions made up of 8-bit words, with
+ * the host starting every bus transaction by asserting the CS signal low. The
+ * card always responds to commands, data blocks and errors.
+ *
+ * The protocol supports a CRC, but by default it is off (except for the
+ * first reset CMD0, where the CRC can just be pre-calculated, and CMD8)
+ * I'll leave the CRC off I think!
+ *
+ * Standard capacity cards have variable data block sizes, whereas High
+ * Capacity cards fix the size of data block to 512 bytes. I'll therefore
+ * just always use the Standard Capacity cards with a block size of 512 bytes.
+ * This is set with CMD16.
+ *
+ * You can read and write single blocks (CMD17, CMD25) or multiple blocks
+ * (CMD18, CMD25). For simplicity, I'll just use single block accesses. When
+ * the card gets a read command, it responds with a response token, and then
+ * a data token or an error.
+ *
+ * SPI Command Format
+ * ------------------
+ * Commands are 6-bytes long, containing the command, 32-bit argument, and CRC.
+ *
+ * +---------------+------------+------------+-----------+----------+--------------+
+ * | 01 | cmd[5:0] | arg[31:24] | arg[23:16] | arg[15:8] | arg[7:0] | crc[6:0] | 1 |
+ * +---------------+------------+------------+-----------+----------+--------------+
+ *
+ * As I'm not using CRC, I can fix that byte to what is needed for CMD0 (0x95)
+ *
+ * All Application Specific commands shall be preceded with APP_CMD (CMD55).
+ *
+ * SPI Response Format
+ * -------------------
+ * The main response format (R1) is a status byte (normally zero). Key flags:
+ * idle - 1 if the card is in an idle state/initialising
+ * cmd - 1 if an illegal command code was detected
+ *
+ * +-------------------------------------------------+
+ * R1 | 0 | arg | addr | seq | crc | cmd | erase | idle |
+ * +-------------------------------------------------+
+ *
+ * R1b is the same, except it is followed by a busy signal (zeros) until
+ * the first non-zero byte when it is ready again.
+ *
+ * Data Response Token
+ * -------------------
+ * Every data block written to the card is acknowledged by a byte
+ * response token
+ *
+ * +----------------------+
+ * | xxx | 0 | status | 1 |
+ * +----------------------+
+ * 010 - OK!
+ * 101 - CRC Error
+ * 110 - Write Error
+ *
+ * Single Block Read and Write
+ * ---------------------------
+ *
+ * Block transfers have a byte header, followed by the data, followed
+ * by a 16-bit CRC. In our case, the data will always be 512 bytes.
+ *
+ * +------+---------+---------+- - - -+---------+-----------+----------+
+ * | 0xFE | data[0] | data[1] | | data[n] | crc[15:8] | crc[7:0] |
+ * +------+---------+---------+- - - -+---------+-----------+----------+
+ */
+
+/* If the target has no SPI support then SDCard is not supported */
+#ifdef DEVICE_SPI
+
+#include "SDBlockDevice.h"
+#include "mbed_debug.h"
+#include <errno.h>
+
+/* Required version: 5.6.1 and above */
+#ifdef MBED_MAJOR_VERSION
+#if (MBED_VERSION < MBED_ENCODE_VERSION(5,6,1))
+#error "Incompatible mbed-os version detected! Required 5.5.4 and above"
+#endif
+#else
+#warning "mbed-os version 5.6.1 or above required"
+#endif
+
+#define SD_COMMAND_TIMEOUT 5000 /*!< Timeout in ms for response */
+#define SD_CMD0_GO_IDLE_STATE_RETRIES 5 /*!< Number of retries for sending CMDO */
+#define SD_DBG 0 /*!< 1 - Enable debugging */
+#define SD_CMD_TRACE 0 /*!< 1 - Enable SD command tracing */
+
+#define SD_BLOCK_DEVICE_ERROR_WOULD_BLOCK -5001 /*!< operation would block */
+#define SD_BLOCK_DEVICE_ERROR_UNSUPPORTED -5002 /*!< unsupported operation */
+#define SD_BLOCK_DEVICE_ERROR_PARAMETER -5003 /*!< invalid parameter */
+#define SD_BLOCK_DEVICE_ERROR_NO_INIT -5004 /*!< uninitialized */
+#define SD_BLOCK_DEVICE_ERROR_NO_DEVICE -5005 /*!< device is missing or not connected */
+#define SD_BLOCK_DEVICE_ERROR_WRITE_PROTECTED -5006 /*!< write protected */
+#define SD_BLOCK_DEVICE_ERROR_UNUSABLE -5007 /*!< unusable card */
+#define SD_BLOCK_DEVICE_ERROR_NO_RESPONSE -5008 /*!< No response from device */
+#define SD_BLOCK_DEVICE_ERROR_CRC -5009 /*!< CRC error */
+#define SD_BLOCK_DEVICE_ERROR_ERASE -5010 /*!< Erase error: reset/sequence */
+#define SD_BLOCK_DEVICE_ERROR_WRITE -5011 /*!< SPI Write error: !SPI_DATA_ACCEPTED */
+
+#define BLOCK_SIZE_HC 512 /*!< Block size supported for SD card is 512 bytes */
+#define WRITE_BL_PARTIAL 0 /*!< Partial block write - Not supported */
+#define CRC_SUPPORT 0 /*!< CRC - Not supported */
+#define SPI_CMD(x) (0x40 | (x & 0x3f))
+
+/* R1 Response Format */
+#define R1_NO_RESPONSE (0xFF)
+#define R1_RESPONSE_RECV (0x80)
+#define R1_IDLE_STATE (1 << 0)
+#define R1_ERASE_RESET (1 << 1)
+#define R1_ILLEGAL_COMMAND (1 << 2)
+#define R1_COM_CRC_ERROR (1 << 3)
+#define R1_ERASE_SEQUENCE_ERROR (1 << 4)
+#define R1_ADDRESS_ERROR (1 << 5)
+#define R1_PARAMETER_ERROR (1 << 6)
+
+// Types
+#define SDCARD_NONE 0 /**< No card is present */
+#define SDCARD_V1 1 /**< v1.x Standard Capacity */
+#define SDCARD_V2 2 /**< v2.x Standard capacity SD card */
+#define SDCARD_V2HC 3 /**< v2.x High capacity SD card */
+#define CARD_UNKNOWN 4 /**< Unknown or unsupported card */
+
+/* SIZE in Bytes */
+#define PACKET_SIZE 6 /*!< SD Packet size CMD+ARG+CRC */
+#define R1_RESPONSE_SIZE 1 /*!< Size of R1 response */
+#define R2_RESPONSE_SIZE 2 /*!< Size of R2 response */
+#define R3_R7_RESPONSE_SIZE 5 /*!< Size of R3/R7 response */
+
+/* R1b Response */
+#define DEVICE_BUSY (0x00)
+
+/* R2 Response Format */
+#define R2_CARD_LOCKED (1 << 0)
+#define R2_CMD_FAILED (1 << 1)
+#define R2_ERROR (1 << 2)
+#define R2_CC_ERROR (1 << 3)
+#define R2_CC_FAILED (1 << 4)
+#define R2_WP_VIOLATION (1 << 5)
+#define R2_ERASE_PARAM (1 << 6)
+#define R2_OUT_OF_RANGE (1 << 7)
+
+/* R3 Response : OCR Register */
+#define OCR_HCS_CCS (0x1 << 30)
+#define OCR_LOW_VOLTAGE (0x01 << 24)
+#define OCR_3_3V (0x1 << 20)
+
+/* R7 response pattern for CMD8 */
+#define CMD8_PATTERN (0xAA)
+
+/* CRC Enable */
+#define CRC_ENABLE (0) /*!< CRC 1 - Enable 0 - Disable */
+
+/* Control Tokens */
+#define SPI_DATA_RESPONSE_MASK (0x1F)
+#define SPI_DATA_ACCEPTED (0x05)
+#define SPI_DATA_CRC_ERROR (0x0B)
+#define SPI_DATA_WRITE_ERROR (0x0D)
+#define SPI_START_BLOCK (0xFE) /*!< For Single Block Read/Write and Multiple Block Read */
+#define SPI_START_BLK_MUL_WRITE (0xFC) /*!< Start Multi-block write */
+#define SPI_STOP_TRAN (0xFD) /*!< Stop Multi-block write */
+
+#define SPI_DATA_READ_ERROR_MASK (0xF) /*!< Data Error Token: 4 LSB bits */
+#define SPI_READ_ERROR (0x1 << 0) /*!< Error */
+#define SPI_READ_ERROR_CC (0x1 << 1) /*!< CC Error*/
+#define SPI_READ_ERROR_ECC_C (0x1 << 2) /*!< Card ECC failed */
+#define SPI_READ_ERROR_OFR (0x1 << 3) /*!< Out of Range */
+
+SDBlockDevice::SDBlockDevice(PinName mosi, PinName miso, PinName sclk, PinName cs, uint64_t hz)
+ : _spi(mosi, miso, sclk), _cs(cs), _is_initialized(0)
+{
+ _cs = 1;
+ _card_type = SDCARD_NONE;
+
+ // Set default to 100kHz for initialisation and 1MHz for data transfer
+ _init_sck = 100000;
+ _transfer_sck = hz;
+
+ // Only HC block size is supported.
+ _block_size = BLOCK_SIZE_HC;
+}
+
+SDBlockDevice::~SDBlockDevice()
+{
+ if (_is_initialized) {
+ deinit();
+ }
+}
+
+int SDBlockDevice::_initialise_card()
+{
+ // Detail debugging is for commands
+ _dbg = SD_DBG ? SD_CMD_TRACE : 0;
+ int32_t status = BD_ERROR_OK;
+ uint32_t response, arg;
+
+ // Initialize the SPI interface: Card by default is in SD mode
+ _spi_init();
+
+ // The card is transitioned from SDCard mode to SPI mode by sending the CMD0 + CS Asserted("0")
+ if (_go_idle_state() != R1_IDLE_STATE) {
+ debug_if(SD_DBG, "No disk, or could not put SD card in to SPI idle state\n");
+ return SD_BLOCK_DEVICE_ERROR_NO_DEVICE;
+ }
+
+ // Send CMD8, if the card rejects the command then it's probably using the
+ // legacy protocol, or is a MMC, or just flat-out broken
+ status = _cmd8();
+ if (BD_ERROR_OK != status && SD_BLOCK_DEVICE_ERROR_UNSUPPORTED != status) {
+ return status;
+ }
+
+ // Read OCR - CMD58 Response contains OCR register
+ if (BD_ERROR_OK != (status = _cmd(CMD58_READ_OCR, 0x0, 0x0, &response))) {
+ return status;
+ }
+
+ // Check if card supports voltage range: 3.3V
+ if (!(response & OCR_3_3V)) {
+ _card_type = CARD_UNKNOWN;
+ status = SD_BLOCK_DEVICE_ERROR_UNUSABLE;
+ return status;
+ }
+
+ // HCS is set 1 for HC/XC capacity cards for ACMD41, if supported
+ arg = 0x0;
+ if (SDCARD_V2 == _card_type) {
+ arg |= OCR_HCS_CCS;
+ }
+
+ /* Idle state bit in the R1 response of ACMD41 is used by the card to inform the host
+ * if initialization of ACMD41 is completed. "1" indicates that the card is still initializing.
+ * "0" indicates completion of initialization. The host repeatedly issues ACMD41 until
+ * this bit is set to "0".
+ */
+ _spi_timer.start();
+ do {
+ status = _cmd(ACMD41_SD_SEND_OP_COND, arg, 1, &response);
+ } while ((response & R1_IDLE_STATE) && (_spi_timer.read_ms() < SD_COMMAND_TIMEOUT));
+ _spi_timer.stop();
+
+ // Initialization complete: ACMD41 successful
+ if ((BD_ERROR_OK != status) || (0x00 != response)) {
+ _card_type = CARD_UNKNOWN;
+ debug_if(SD_DBG, "Timeout waiting for card\n");
+ return status;
+ }
+
+ if (SDCARD_V2 == _card_type) {
+ // Get the card capacity CCS: CMD58
+ if (BD_ERROR_OK == (status = _cmd(CMD58_READ_OCR, 0x0, 0x0, &response))) {
+ // High Capacity card
+ if (response & OCR_HCS_CCS) {
+ _card_type = SDCARD_V2HC;
+ debug_if(SD_DBG, "Card Initialized: High Capacity Card \n");
+ } else {
+ debug_if(SD_DBG, "Card Initialized: Standard Capacity Card: Version 2.x \n");
+ }
+ }
+ } else {
+ _card_type = SDCARD_V1;
+ debug_if(SD_DBG, "Card Initialized: Version 1.x Card\n");
+ }
+
+ // Disable CRC
+ status = _cmd(CMD59_CRC_ON_OFF, 0);
+
+ return status;
+}
+
+
+int SDBlockDevice::init()
+{
+ _lock.lock();
+ int err = _initialise_card();
+ _is_initialized = (err == BD_ERROR_OK);
+ if (!_is_initialized) {
+ debug_if(SD_DBG, "Fail to initialize card\n");
+ _lock.unlock();
+ return err;
+ }
+ debug_if(SD_DBG, "init card = %d\n", _is_initialized);
+ _sectors = _sd_sectors();
+ // CMD9 failed
+ if (0 == _sectors) {
+ _lock.unlock();
+ return BD_ERROR_DEVICE_ERROR;
+ }
+
+ // Set block length to 512 (CMD16)
+ if (_cmd(CMD16_SET_BLOCKLEN, _block_size) != 0) {
+ debug_if(SD_DBG, "Set %d-byte block timed out\n", _block_size);
+ _lock.unlock();
+ return BD_ERROR_DEVICE_ERROR;
+ }
+
+ // Set SCK for data transfer
+ err = _freq();
+ if (err) {
+ _lock.unlock();
+ return err;
+ }
+ _lock.unlock();
+ return BD_ERROR_OK;
+}
+
+int SDBlockDevice::deinit()
+{
+ _lock.lock();
+ _is_initialized = false;
+ _lock.unlock();
+ return 0;
+}
+
+
+int SDBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size)
+{
+ if (!is_valid_program(addr, size)) {
+ return SD_BLOCK_DEVICE_ERROR_PARAMETER;
+ }
+
+ _lock.lock();
+ if (!_is_initialized) {
+ _lock.unlock();
+ return SD_BLOCK_DEVICE_ERROR_NO_INIT;
+ }
+
+ const uint8_t *buffer = static_cast<const uint8_t*>(b);
+ int status = BD_ERROR_OK;
+ uint8_t response;
+
+ // Get block count
+ bd_addr_t blockCnt = size / _block_size;
+
+ // SDSC Card (CCS=0) uses byte unit address
+ // SDHC and SDXC Cards (CCS=1) use block unit address (512 Bytes unit)
+ if(SDCARD_V2HC == _card_type) {
+ addr = addr / _block_size;
+ }
+
+ // Send command to perform write operation
+ if (blockCnt == 1) {
+ // Single block write command
+ if (BD_ERROR_OK != (status = _cmd(CMD24_WRITE_BLOCK, addr))) {
+ _lock.unlock();
+ return status;
+ }
+
+ // Write data
+ response = _write(buffer, SPI_START_BLOCK, _block_size);
+
+ // Only CRC and general write error are communicated via response token
+ if ((response == SPI_DATA_CRC_ERROR) || (response == SPI_DATA_WRITE_ERROR)) {
+ debug_if(SD_DBG, "Single Block Write failed: 0x%x \n", response);
+ status = SD_BLOCK_DEVICE_ERROR_WRITE;
+ }
+ } else {
+ // Pre-erase setting prior to multiple block write operation
+ _cmd(ACMD23_SET_WR_BLK_ERASE_COUNT, blockCnt, 1);
+
+ // Multiple block write command
+ if (BD_ERROR_OK != (status = _cmd(CMD25_WRITE_MULTIPLE_BLOCK, addr))) {
+ _lock.unlock();
+ return status;
+ }
+
+ // Write the data: one block at a time
+ do {
+ response = _write(buffer, SPI_START_BLK_MUL_WRITE, _block_size);
+ if (response != SPI_DATA_ACCEPTED) {
+ debug_if(SD_DBG, "Multiple Block Write failed: 0x%x \n", response);
+ break;
+ }
+ buffer += _block_size;
+ }while (--blockCnt); // Receive all blocks of data
+
+ /* In a Multiple Block write operation, the stop transmission will be done by
+ * sending 'Stop Tran' token instead of 'Start Block' token at the beginning
+ * of the next block
+ */
+ _spi.write(SPI_STOP_TRAN);
+ }
+
+ _deselect();
+ _lock.unlock();
+ return status;
+}
+
+int SDBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
+{
+ if (!is_valid_read(addr, size)) {
+ return SD_BLOCK_DEVICE_ERROR_PARAMETER;
+ }
+
+ _lock.lock();
+ if (!_is_initialized) {
+ _lock.unlock();
+ return SD_BLOCK_DEVICE_ERROR_PARAMETER;
+ }
+
+ uint8_t *buffer = static_cast<uint8_t *>(b);
+ int status = BD_ERROR_OK;
+ bd_addr_t blockCnt = size / _block_size;
+
+ // SDSC Card (CCS=0) uses byte unit address
+ // SDHC and SDXC Cards (CCS=1) use block unit address (512 Bytes unit)
+ if (SDCARD_V2HC == _card_type) {
+ addr = addr / _block_size;
+ }
+
+ // Write command ro receive data
+ if (blockCnt > 1) {
+ status = _cmd(CMD18_READ_MULTIPLE_BLOCK, addr);
+ } else {
+ status = _cmd(CMD17_READ_SINGLE_BLOCK, addr);
+ }
+ if (BD_ERROR_OK != status) {
+ _lock.unlock();
+ return status;
+ }
+
+ // receive the data : one block at a time
+ while (blockCnt) {
+ if (0 != _read(buffer, _block_size)) {
+ status = SD_BLOCK_DEVICE_ERROR_NO_RESPONSE;
+ break;
+ }
+ buffer += _block_size;
+ --blockCnt;
+ }
+ _deselect();
+
+ // Send CMD12(0x00000000) to stop the transmission for multi-block transfer
+ if (size > _block_size) {
+ status = _cmd(CMD12_STOP_TRANSMISSION, 0x0);
+ }
+ _lock.unlock();
+ return status;
+}
+
+bool SDBlockDevice::_is_valid_trim(bd_addr_t addr, bd_size_t size)
+{
+ return (
+ addr % _erase_size == 0 &&
+ size % _erase_size == 0 &&
+ addr + size <= this->size());
+}
+
+int SDBlockDevice::trim(bd_addr_t addr, bd_size_t size)
+{
+ if (!_is_valid_trim(addr, size)) {
+ return SD_BLOCK_DEVICE_ERROR_PARAMETER;
+ }
+
+ _lock.lock();
+ if (!_is_initialized) {
+ _lock.unlock();
+ return SD_BLOCK_DEVICE_ERROR_NO_INIT;
+ }
+ int status = BD_ERROR_OK;
+
+ size -= _block_size;
+ // SDSC Card (CCS=0) uses byte unit address
+ // SDHC and SDXC Cards (CCS=1) use block unit address (512 Bytes unit)
+ if (SDCARD_V2HC == _card_type) {
+ size = size / _block_size;
+ addr = addr / _block_size;
+ }
+
+ // Start lba sent in start command
+ if (BD_ERROR_OK != (status = _cmd(CMD32_ERASE_WR_BLK_START_ADDR, addr))) {
+ _lock.unlock();
+ return status;
+ }
+
+ // End lba = addr+size sent in end addr command
+ if (BD_ERROR_OK != (status = _cmd(CMD33_ERASE_WR_BLK_END_ADDR, addr+size))) {
+ _lock.unlock();
+ return status;
+ }
+ status = _cmd(CMD38_ERASE, 0x0);
+ _lock.unlock();
+ return status;
+}
+
+bd_size_t SDBlockDevice::get_read_size() const
+{
+ return _block_size;
+}
+
+bd_size_t SDBlockDevice::get_program_size() const
+{
+ return _block_size;
+}
+
+bd_size_t SDBlockDevice::size() const
+{
+ bd_size_t sectors = 0;
+ _lock.lock();
+ if (_is_initialized) {
+ sectors = _sectors;
+ }
+ _lock.unlock();
+ return _block_size*sectors;
+}
+
+void SDBlockDevice::debug(bool dbg)
+{
+ _dbg = dbg;
+}
+
+int SDBlockDevice::frequency(uint64_t freq)
+{
+ _lock.lock();
+ _transfer_sck = freq;
+ int err = _freq();
+ _lock.unlock();
+ return err;
+}
+
+// PRIVATE FUNCTIONS
+int SDBlockDevice::_freq(void)
+{
+ // Max frequency supported is 25MHZ
+ if (_transfer_sck <= 25000000) {
+ _spi.frequency(_transfer_sck);
+ return 0;
+ } else { // TODO: Switch function to be implemented for higher frequency
+ _transfer_sck = 25000000;
+ _spi.frequency(_transfer_sck);
+ return -EINVAL;
+ }
+}
+
+uint8_t SDBlockDevice::_cmd_spi(SDBlockDevice::cmdSupported cmd, uint32_t arg) {
+ uint8_t response;
+ char cmdPacket[PACKET_SIZE];
+
+ // Prepare the command packet
+ cmdPacket[0] = SPI_CMD(cmd);
+ cmdPacket[1] = (arg >> 24);
+ cmdPacket[2] = (arg >> 16);
+ cmdPacket[3] = (arg >> 8);
+ cmdPacket[4] = (arg >> 0);
+ // CMD0 is executed in SD mode, hence should have correct CRC
+ // CMD8 CRC verification is always enabled
+ switch(cmd) {
+ case CMD0_GO_IDLE_STATE:
+ cmdPacket[5] = 0x95;
+ break;
+ case CMD8_SEND_IF_COND:
+ cmdPacket[5] = 0x87;
+ break;
+ default:
+ cmdPacket[5] = 0xFF; // Make sure bit 0-End bit is high
+ break;
+ }
+
+ // send a command
+ for (int i = 0; i < PACKET_SIZE; i++) {
+ _spi.write(cmdPacket[i]);
+ }
+
+ // The received byte immediataly following CMD12 is a stuff byte,
+ // it should be discarded before receive the response of the CMD12.
+ if (CMD12_STOP_TRANSMISSION == cmd) {
+ _spi.write(SPI_FILL_CHAR);
+ }
+
+ // Loop for response: Response is sent back within command response time (NCR), 0 to 8 bytes for SDC
+ for (int i = 0; i < 0x10; i++) {
+ response = _spi.write(SPI_FILL_CHAR);
+ // Got the response
+ if (!(response & R1_RESPONSE_RECV)) {
+ break;
+ }
+ }
+ return response;
+}
+
+int SDBlockDevice::_cmd(SDBlockDevice::cmdSupported cmd, uint32_t arg, bool isAcmd, uint32_t *resp) {
+ int32_t status = BD_ERROR_OK;
+ uint32_t response;
+
+ // Select card and wait for card to be ready before sending next command
+ // Note: next command will fail if card is not ready
+ _select();
+
+ // No need to wait for card to be ready when sending the stop command
+ if (CMD12_STOP_TRANSMISSION != cmd) {
+ if (false == _wait_ready(SD_COMMAND_TIMEOUT)) {
+ debug_if(SD_DBG, "Card not ready yet \n");
+ }
+ }
+
+ // Re-try command
+ for(int i = 0; i < 3; i++) {
+ // Send CMD55 for APP command first
+ if (isAcmd) {
+ response = _cmd_spi(CMD55_APP_CMD, 0x0);
+ // Wait for card to be ready after CMD55
+ if (false == _wait_ready(SD_COMMAND_TIMEOUT)) {
+ debug_if(SD_DBG, "Card not ready yet \n");
+ }
+ }
+
+ // Send command over SPI interface
+ response = _cmd_spi(cmd, arg);
+ if (R1_NO_RESPONSE == response) {
+ debug_if(SD_DBG, "No response CMD:%d \n", cmd);
+ continue;
+ }
+ break;
+ }
+
+ // Pass the response to the command call if required
+ if (NULL != resp) {
+ *resp = response;
+ }
+
+ // Process the response R1 : Exit on CRC/Illegal command error/No response
+ if (R1_NO_RESPONSE == response) {
+ _deselect();
+ debug_if(SD_DBG, "No response CMD:%d response: 0x%x\n",cmd, response);
+ return SD_BLOCK_DEVICE_ERROR_NO_DEVICE; // No device
+ }
+ if (response & R1_COM_CRC_ERROR) {
+ _deselect();
+ debug_if(SD_DBG, "CRC error CMD:%d response 0x%x \n",cmd, response);
+ return SD_BLOCK_DEVICE_ERROR_CRC; // CRC error
+ }
+ if (response & R1_ILLEGAL_COMMAND) {
+ _deselect();
+ debug_if(SD_DBG, "Illegal command CMD:%d response 0x%x\n",cmd, response);
+ if (CMD8_SEND_IF_COND == cmd) { // Illegal command is for Ver1 or not SD Card
+ _card_type = CARD_UNKNOWN;
+ }
+ return SD_BLOCK_DEVICE_ERROR_UNSUPPORTED; // Command not supported
+ }
+
+ debug_if(_dbg, "CMD:%d \t arg:0x%x \t Response:0x%x \n", cmd, arg, response);
+ // Set status for other errors
+ if ((response & R1_ERASE_RESET) || (response & R1_ERASE_SEQUENCE_ERROR)) {
+ status = SD_BLOCK_DEVICE_ERROR_ERASE; // Erase error
+ }else if ((response & R1_ADDRESS_ERROR) || (response & R1_PARAMETER_ERROR)) {
+ // Misaligned address / invalid address block length
+ status = SD_BLOCK_DEVICE_ERROR_PARAMETER;
+ }
+
+ // Get rest of the response part for other commands
+ switch(cmd) {
+ case CMD8_SEND_IF_COND: // Response R7
+ debug_if(_dbg, "V2-Version Card\n");
+ _card_type = SDCARD_V2;
+ // Note: No break here, need to read rest of the response
+ case CMD58_READ_OCR: // Response R3
+ response = (_spi.write(SPI_FILL_CHAR) << 24);
+ response |= (_spi.write(SPI_FILL_CHAR) << 16);
+ response |= (_spi.write(SPI_FILL_CHAR) << 8);
+ response |= _spi.write(SPI_FILL_CHAR);
+ debug_if(_dbg, "R3/R7: 0x%x \n", response);
+ break;
+
+ case CMD12_STOP_TRANSMISSION: // Response R1b
+ case CMD38_ERASE:
+ _wait_ready(SD_COMMAND_TIMEOUT);
+ break;
+
+ case ACMD13_SD_STATUS: // Response R2
+ response = _spi.write(SPI_FILL_CHAR);
+ debug_if(_dbg, "R2: 0x%x \n", response);
+ break;
+
+ default: // Response R1
+ break;
+ }
+
+ // Pass the updated response to the command
+ if (NULL != resp) {
+ *resp = response;
+ }
+
+ // Do not deselect card if read is in progress.
+ if (((CMD9_SEND_CSD == cmd) || (ACMD22_SEND_NUM_WR_BLOCKS == cmd) ||
+ (CMD24_WRITE_BLOCK == cmd) || (CMD25_WRITE_MULTIPLE_BLOCK == cmd) ||
+ (CMD17_READ_SINGLE_BLOCK == cmd) || (CMD18_READ_MULTIPLE_BLOCK == cmd))
+ && (BD_ERROR_OK == status)) {
+ return BD_ERROR_OK;
+ }
+ // Deselect card
+ _deselect();
+ return status;
+}
+
+int SDBlockDevice::_cmd8() {
+ uint32_t arg = (CMD8_PATTERN << 0); // [7:0]check pattern
+ uint32_t response = 0;
+ int32_t status = BD_ERROR_OK;
+
+ arg |= (0x1 << 8); // 2.7-3.6V // [11:8]supply voltage(VHS)
+
+ status = _cmd(CMD8_SEND_IF_COND, arg, 0x0, &response);
+ // Verify voltage and pattern for V2 version of card
+ if ((BD_ERROR_OK == status) && (SDCARD_V2 == _card_type)) {
+ // If check pattern is not matched, CMD8 communication is not valid
+ if((response & 0xFFF) != arg)
+ {
+ debug_if(SD_DBG, "CMD8 Pattern mismatch 0x%x : 0x%x\n", arg, response);
+ _card_type = CARD_UNKNOWN;
+ status = SD_BLOCK_DEVICE_ERROR_UNUSABLE;
+ }
+ }
+ return status;
+}
+
+uint32_t SDBlockDevice::_go_idle_state() {
+ uint32_t response;
+
+ /* Reseting the MCU SPI master may not reset the on-board SDCard, in which
+ * case when MCU power-on occurs the SDCard will resume operations as
+ * though there was no reset. In this scenario the first CMD0 will
+ * not be interpreted as a command and get lost. For some cards retrying
+ * the command overcomes this situation. */
+ for (int i = 0; i < SD_CMD0_GO_IDLE_STATE_RETRIES; i++) {
+ _cmd(CMD0_GO_IDLE_STATE, 0x0, 0x0, &response);
+ if (R1_IDLE_STATE == response)
+ break;
+ wait_ms(1);
+ }
+ return response;
+}
+
+int SDBlockDevice::_read_bytes(uint8_t *buffer, uint32_t length) {
+ uint16_t crc;
+
+ // read until start byte (0xFE)
+ if (false == _wait_token(SPI_START_BLOCK)) {
+ debug_if(SD_DBG, "Read timeout\n");
+ _deselect();
+ return SD_BLOCK_DEVICE_ERROR_NO_RESPONSE;
+ }
+
+ // read data
+ for (uint32_t i = 0; i < length; i++) {
+ buffer[i] = _spi.write(SPI_FILL_CHAR);
+ }
+
+ // Read the CRC16 checksum for the data block
+ crc = (_spi.write(SPI_FILL_CHAR) << 8);
+ crc |= _spi.write(SPI_FILL_CHAR);
+
+ _deselect();
+ return 0;
+}
+
+int SDBlockDevice::_read(uint8_t *buffer, uint32_t length) {
+ uint16_t crc;
+
+ // read until start byte (0xFE)
+ if (false == _wait_token(SPI_START_BLOCK)) {
+ debug_if(SD_DBG, "Read timeout\n");
+ _deselect();
+ return SD_BLOCK_DEVICE_ERROR_NO_RESPONSE;
+ }
+
+ // read data
+ _spi.write(NULL, 0, (char*)buffer, length);
+
+ // Read the CRC16 checksum for the data block
+ crc = (_spi.write(SPI_FILL_CHAR) << 8);
+ crc |= _spi.write(SPI_FILL_CHAR);
+
+ return 0;
+}
+
+uint8_t SDBlockDevice::_write(const uint8_t *buffer, uint8_t token, uint32_t length) {
+ uint16_t crc = 0xFFFF;
+ uint8_t response = 0xFF;
+
+ // indicate start of block
+ _spi.write(token);
+
+ // write the data
+ _spi.write((char*)buffer, length, NULL, 0);
+
+ // write the checksum CRC16
+ _spi.write(crc >> 8);
+ _spi.write(crc);
+
+ // check the response token
+ response = _spi.write(SPI_FILL_CHAR);
+
+ // Wait for last block to be written
+ if (false == _wait_ready(SD_COMMAND_TIMEOUT)) {
+ debug_if(SD_DBG, "Card not ready yet \n");
+ }
+
+ return (response & SPI_DATA_RESPONSE_MASK);
+}
+
+static uint32_t ext_bits(unsigned char *data, int msb, int lsb) {
+ uint32_t bits = 0;
+ uint32_t size = 1 + msb - lsb;
+ for (uint32_t i = 0; i < size; i++) {
+ uint32_t position = lsb + i;
+ uint32_t byte = 15 - (position >> 3);
+ uint32_t bit = position & 0x7;
+ uint32_t value = (data[byte] >> bit) & 1;
+ bits |= value << i;
+ }
+ return bits;
+}
+
+uint32_t SDBlockDevice::_sd_sectors() {
+ uint32_t c_size, c_size_mult, read_bl_len;
+ uint32_t block_len, mult, blocknr;
+ uint32_t hc_c_size;
+ bd_size_t blocks = 0, capacity = 0;
+
+ // CMD9, Response R2 (R1 byte + 16-byte block read)
+ if (_cmd(CMD9_SEND_CSD, 0x0) != 0x0) {
+ debug_if(SD_DBG, "Didn't get a response from the disk\n");
+ return 0;
+ }
+ uint8_t csd[16];
+ if (_read_bytes(csd, 16) != 0) {
+ debug_if(SD_DBG, "Couldn't read csd response from disk\n");
+ return 0;
+ }
+
+ // csd_structure : csd[127:126]
+ int csd_structure = ext_bits(csd, 127, 126);
+ switch (csd_structure) {
+ case 0:
+ c_size = ext_bits(csd, 73, 62); // c_size : csd[73:62]
+ c_size_mult = ext_bits(csd, 49, 47); // c_size_mult : csd[49:47]
+ read_bl_len = ext_bits(csd, 83, 80); // read_bl_len : csd[83:80] - the *maximum* read block length
+ block_len = 1 << read_bl_len; // BLOCK_LEN = 2^READ_BL_LEN
+ mult = 1 << (c_size_mult + 2); // MULT = 2^C_SIZE_MULT+2 (C_SIZE_MULT < 8)
+ blocknr = (c_size + 1) * mult; // BLOCKNR = (C_SIZE+1) * MULT
+ capacity = blocknr * block_len; // memory capacity = BLOCKNR * BLOCK_LEN
+ blocks = capacity / _block_size;
+ debug_if(SD_DBG, "Standard Capacity: c_size: %d \n", c_size);
+ debug_if(SD_DBG, "Sectors: 0x%x : %llu\n", blocks, blocks);
+ debug_if(SD_DBG, "Capacity: 0x%x : %llu MB\n", capacity, (capacity/(1024U*1024U)));
+
+ // ERASE_BLK_EN = 1: Erase in multiple of 512 bytes supported
+ if (ext_bits(csd, 46, 46)) {
+ _erase_size = BLOCK_SIZE_HC;
+ } else {
+ // ERASE_BLK_EN = 1: Erase in multiple of SECTOR_SIZE supported
+ _erase_size = BLOCK_SIZE_HC * (ext_bits(csd, 45, 39) + 1);
+ }
+ break;
+
+ case 1:
+ hc_c_size = ext_bits(csd, 69, 48); // device size : C_SIZE : [69:48]
+ blocks = (hc_c_size+1) << 10; // block count = C_SIZE+1) * 1K byte (512B is block size)
+ debug_if(SD_DBG, "SDHC/SDXC Card: hc_c_size: %d \n", hc_c_size);
+ debug_if(SD_DBG, "Sectors: 0x%x : %llu\n", blocks, blocks);
+ debug_if(SD_DBG, "Capacity: %llu MB\n", (blocks/(2048U)));
+ // ERASE_BLK_EN is fixed to 1, which means host can erase one or multiple of 512 bytes.
+ _erase_size = BLOCK_SIZE_HC;
+ break;
+
+ default:
+ debug_if(SD_DBG, "CSD struct unsupported\r\n");
+ return 0;
+ };
+ return blocks;
+}
+
+// SPI function to wait till chip is ready and sends start token
+bool SDBlockDevice::_wait_token(uint8_t token) {
+ _spi_timer.reset();
+ _spi_timer.start();
+
+ do {
+ if (token == _spi.write(SPI_FILL_CHAR)) {
+ _spi_timer.stop();
+ return true;
+ }
+ } while (_spi_timer.read_ms() < 300); // Wait for 300 msec for start token
+ _spi_timer.stop();
+ debug_if(SD_DBG, "_wait_token: timeout\n");
+ return false;
+}
+
+// SPI function to wait till chip is ready
+// The host controller should wait for end of the process until DO goes high (a 0xFF is received).
+bool SDBlockDevice::_wait_ready(uint16_t ms) {
+ uint8_t response;
+ _spi_timer.reset();
+ _spi_timer.start();
+ do {
+ response = _spi.write(SPI_FILL_CHAR);
+ if (response == 0xFF) {
+ _spi_timer.stop();
+ return true;
+ }
+ } while (_spi_timer.read_ms() < ms);
+ _spi_timer.stop();
+ return false;
+}
+
+// SPI function to wait for count
+void SDBlockDevice::_spi_wait(uint8_t count)
+{
+ for (uint8_t i = 0; i < count; ++i) {
+ _spi.write(SPI_FILL_CHAR);
+ }
+}
+
+void SDBlockDevice::_spi_init() {
+ _spi.lock();
+ // Set to SCK for initialization, and clock card with cs = 1
+ _spi.frequency(_init_sck);
+ _spi.format(8, 0);
+ _spi.set_default_write_value(SPI_FILL_CHAR);
+ // Initial 74 cycles required for few cards, before selecting SPI mode
+ _cs = 1;
+ _spi_wait(10);
+ _spi.unlock();
+}
+
+void SDBlockDevice::_select() {
+ _spi.lock();
+ _spi.write(SPI_FILL_CHAR);
+ _cs = 0;
+}
+
+void SDBlockDevice::_deselect() {
+ _cs = 1;
+ _spi.write(SPI_FILL_CHAR);
+ _spi.unlock();
+}
+
+#endif /* DEVICE_SPI */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SDBlockDevice.h Thu Apr 12 01:36:31 2018 +0000
@@ -0,0 +1,230 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2006-2012 ARM Limited
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef MBED_SD_BLOCK_DEVICE_H
+#define MBED_SD_BLOCK_DEVICE_H
+
+/* If the target has no SPI support then SDCard is not supported */
+#ifdef DEVICE_SPI
+
+#include "BlockDevice.h"
+#include "mbed.h"
+
+
+/** Access an SD Card using SPI
+ *
+ * @code
+ * #include "mbed.h"
+ * #include "SDBlockDevice.h"
+ *
+ * SDBlockDevice sd(p5, p6, p7, p12); // mosi, miso, sclk, cs
+ * uint8_t block[512] = "Hello World!\n";
+ *
+ * int main() {
+ * sd.init();
+ * sd.write(block, 0, 512);
+ * sd.read(block, 0, 512);
+ * printf("%s", block);
+ * sd.deinit();
+ * }
+ */
+class SDBlockDevice : public BlockDevice {
+public:
+ /** Lifetime of an SD card
+ */
+ SDBlockDevice(PinName mosi, PinName miso, PinName sclk, PinName cs, uint64_t hz=1000000);
+ virtual ~SDBlockDevice();
+
+ /** Initialize a block device
+ *
+ * @return 0 on success or a negative error code on failure
+ */
+ virtual int init();
+
+ /** Deinitialize a block device
+ *
+ * @return 0 on success or a negative error code on failure
+ */
+ virtual int deinit();
+
+ /** Read blocks from a block device
+ *
+ * @param buffer Buffer to write blocks to
+ * @param addr Address of block to begin reading from
+ * @param size Size to read in bytes, must be a multiple of read block size
+ * @return 0 on success, negative error code on failure
+ */
+ virtual int read(void *buffer, bd_addr_t addr, bd_size_t size);
+
+ /** Program blocks to a block device
+ *
+ * The blocks must have been erased prior to being programmed
+ *
+ * @param buffer Buffer of data to write to blocks
+ * @param addr Address of block to begin writing to
+ * @param size Size to write in bytes, must be a multiple of program block size
+ * @return 0 on success, negative error code on failure
+ */
+ virtual int program(const void *buffer, bd_addr_t addr, bd_size_t size);
+
+ /** Mark blocks as no longer in use
+ *
+ * This function provides a hint to the underlying block device that a region of blocks
+ * is no longer in use and may be erased without side effects. Erase must still be called
+ * before programming, but trimming allows flash-translation-layers to schedule erases when
+ * the device is not busy.
+ *
+ * @param addr Address of block to mark as unused
+ * @param size Size to mark as unused in bytes, must be a multiple of erase block size
+ * @return 0 on success, negative error code on failure
+ */
+ virtual int trim(bd_addr_t addr, bd_size_t size);
+
+ /** Get the size of a readable block
+ *
+ * @return Size of a readable block in bytes
+ */
+ virtual bd_size_t get_read_size() const;
+
+ /** Get the size of a programable block
+ *
+ * @return Size of a programable block in bytes
+ * @note Must be a multiple of the read size
+ */
+ virtual bd_size_t get_program_size() const;
+
+ /** Get the total size of the underlying device
+ *
+ * @return Size of the underlying device in bytes
+ */
+ virtual bd_size_t size() const;
+
+ /** Enable or disable debugging
+ *
+ * @param State of debugging
+ */
+ virtual void debug(bool dbg);
+
+ /** Set the transfer frequency
+ *
+ * @param Transfer frequency
+ * @note Max frequency supported is 25MHZ
+ */
+ virtual int frequency(uint64_t freq);
+
+
+private:
+ /* Commands : Listed below are commands supported
+ * in SPI mode for SD card : Only Mandatory ones
+ */
+ enum cmdSupported {
+ CMD_NOT_SUPPORTED = -1, /**< Command not supported error */
+ CMD0_GO_IDLE_STATE = 0, /**< Resets the SD Memory Card */
+ CMD1_SEND_OP_COND = 1, /**< Sends host capacity support */
+ CMD6_SWITCH_FUNC = 6, /**< Check and Switches card function */
+ CMD8_SEND_IF_COND = 8, /**< Supply voltage info */
+ CMD9_SEND_CSD = 9, /**< Provides Card Specific data */
+ CMD10_SEND_CID = 10, /**< Provides Card Identification */
+ CMD12_STOP_TRANSMISSION = 12, /**< Forces the card to stop transmission */
+ CMD13_SEND_STATUS = 13, /**< Card responds with status */
+ CMD16_SET_BLOCKLEN = 16, /**< Length for SC card is set */
+ CMD17_READ_SINGLE_BLOCK = 17, /**< Read single block of data */
+ CMD18_READ_MULTIPLE_BLOCK = 18, /**< Card transfers data blocks to host until interrupted
+ by a STOP_TRANSMISSION command */
+ CMD24_WRITE_BLOCK = 24, /**< Write single block of data */
+ CMD25_WRITE_MULTIPLE_BLOCK = 25, /**< Continuously writes blocks of data until
+ 'Stop Tran' token is sent */
+ CMD27_PROGRAM_CSD = 27, /**< Programming bits of CSD */
+ CMD32_ERASE_WR_BLK_START_ADDR = 32, /**< Sets the address of the first write
+ block to be erased. */
+ CMD33_ERASE_WR_BLK_END_ADDR = 33, /**< Sets the address of the last write
+ block of the continuous range to be erased.*/
+ CMD38_ERASE = 38, /**< Erases all previously selected write blocks */
+ CMD55_APP_CMD = 55, /**< Extend to Applications specific commands */
+ CMD56_GEN_CMD = 56, /**< General Purpose Command */
+ CMD58_READ_OCR = 58, /**< Read OCR register of card */
+ CMD59_CRC_ON_OFF = 59, /**< Turns the CRC option on or off*/
+ // App Commands
+ ACMD6_SET_BUS_WIDTH = 6,
+ ACMD13_SD_STATUS = 13,
+ ACMD22_SEND_NUM_WR_BLOCKS = 22,
+ ACMD23_SET_WR_BLK_ERASE_COUNT = 23,
+ ACMD41_SD_SEND_OP_COND = 41,
+ ACMD42_SET_CLR_CARD_DETECT = 42,
+ ACMD51_SEND_SCR = 51,
+ };
+
+ uint8_t _card_type;
+ int _cmd(SDBlockDevice::cmdSupported cmd, uint32_t arg, bool isAcmd=0, uint32_t *resp=NULL);
+ int _cmd8();
+
+ /* Move the SDCard into the SPI Mode idle state
+ *
+ * The card is transitioned from SDCard mode to SPI mode by sending the
+ * CMD0 (GO_IDLE_STATE) command with CS asserted. See the notes in the
+ * "SPI Startup" section of the comments at the head of the
+ * implementation file for further details and specification references.
+ *
+ * @return Response form the card. R1_IDLE_STATE (0x1), the successful
+ * response from CMD0. R1_XXX_XXX for more response
+ */
+ uint32_t _go_idle_state();
+ int _initialise_card();
+
+ uint32_t _sectors;
+ uint32_t _sd_sectors();
+
+ bool _is_valid_trim(bd_addr_t addr, bd_size_t size);
+
+ /* SPI functions */
+ Timer _spi_timer; /**< Timer Class object used for busy wait */
+ uint32_t _init_sck; /**< Intial SPI frequency */
+ uint32_t _transfer_sck; /**< SPI frequency during data transfer/after initialization */
+ SPI _spi; /**< SPI Class object */
+
+ /* SPI initialization function */
+ void _spi_init();
+ uint8_t _cmd_spi(SDBlockDevice::cmdSupported cmd, uint32_t arg);
+ void _spi_wait(uint8_t count);
+
+ bool _wait_token(uint8_t token); /**< Wait for token */
+ bool _wait_ready(uint16_t ms=300); /**< 300ms default wait for card to be ready */
+ int _read(uint8_t * buffer, uint32_t length);
+ int _read_bytes(uint8_t * buffer, uint32_t length);
+ uint8_t _write(const uint8_t *buffer,uint8_t token, uint32_t length);
+ int _freq(void);
+
+ /* Chip Select and SPI mode select */
+ DigitalOut _cs;
+ void _select();
+ void _deselect();
+
+ mutable Mutex _lock;
+ uint32_t _block_size;
+ uint32_t _erase_size;
+ bool _is_initialized;
+ bool _dbg;
+};
+
+#endif /* DEVICE_SPI */
+
+#endif /* MBED_SD_BLOCK_DEVICE_H */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/config/mbed_lib.json Thu Apr 12 01:36:31 2018 +0000
@@ -0,0 +1,156 @@
+{
+ "name": "sd",
+ "config": {
+ "UART_RX": "D0",
+ "UART_TX": "D1",
+ "DIO_0": "D0",
+ "DIO_1": "D1",
+ "DIO_2": "D2",
+ "DIO_3": "D3",
+ "DIO_4": "D4",
+ "DIO_5": "D5",
+ "DIO_6": "D6",
+ "DIO_7": "D7",
+ "DIO_8": "D8",
+ "DIO_9": "D9",
+ "SPI_CS": "D10",
+ "SPI_MOSI": "D11",
+ "SPI_MISO": "D12",
+ "SPI_CLK": "D13",
+ "I2C_SDA": "D14",
+ "I2C_SCL": "D15",
+ "I2C_TEMP_ADDR":"0x90",
+ "I2C_EEPROM_ADDR":"0xA0",
+ "AIN_0": "A0",
+ "AIN_1": "A1",
+ "AIN_2": "A2",
+ "AIN_3": "A3",
+ "AIN_4": "A4",
+ "AIN_5": "A5",
+ "AOUT" : "A5",
+ "PWM_0": "D3",
+ "PWM_1": "D5",
+ "PWM_2": "D6",
+ "PWM_3": "D9",
+ "DEBUG_MSG": 0,
+ "DEVICE_SPI": 1,
+ "FSFAT_SDCARD_INSTALLED": 1
+ },
+ "target_overrides": {
+ "DISCO_F051R8": {
+ "SPI_MOSI": "SPI_MOSI",
+ "SPI_MISO": "SPI_MISO",
+ "SPI_CLK": "SPI_SCK",
+ "SPI_CS": "SPI_CS"
+ },
+ "DISCO_L476VG": {
+ "SPI_MOSI": "PE_15",
+ "SPI_MISO": "PE_14",
+ "SPI_CLK": "PE_13",
+ "SPI_CS": "PE_12"
+ },
+ "K20D50M": {
+ "SPI_MOSI": "PTD2",
+ "SPI_MISO": "PTD3",
+ "SPI_CLK": "PTD1",
+ "SPI_CS": "PTC2"
+ },
+ "KL22F": {
+ "SPI_MOSI": "PTD6",
+ "SPI_MISO": "PTD7",
+ "SPI_CLK": "PTD5",
+ "SPI_CS": "PTD4"
+ },
+ "KL25Z": {
+ "SPI_MOSI": "PTD2",
+ "SPI_MISO": "PTD3",
+ "SPI_CLK": "PTD1",
+ "SPI_CS": "PTD0"
+ },
+ "KL43Z": {
+ "SPI_MOSI": "PTD6",
+ "SPI_MISO": "PTD7",
+ "SPI_CLK": "PTD5",
+ "SPI_CS": "PTD4"
+ },
+ "KL46Z": {
+ "SPI_MOSI": "PTD6",
+ "SPI_MISO": "PTD7",
+ "SPI_CLK": "PTD5",
+ "SPI_CS": "PTD4"
+ },
+ "K64F": {
+ "SPI_MOSI": "PTE3",
+ "SPI_MISO": "PTE1",
+ "SPI_CLK": "PTE2",
+ "SPI_CS": "PTE4"
+ },
+ "K66F": {
+ "SPI_MOSI": "PTE3",
+ "SPI_MISO": "PTE1",
+ "SPI_CLK": "PTE2",
+ "SPI_CS": "PTE4"
+ },
+ "LPC11U37H_401": {
+ "SPI_MOSI": "SDMOSI",
+ "SPI_MISO": "SDMISO",
+ "SPI_CLK": "SDSCLK",
+ "SPI_CS": "SDSSEL"
+ },
+ "LPC2368": {
+ "SPI_MOSI": "p11",
+ "SPI_MISO": "p12",
+ "SPI_CLK": "p13",
+ "SPI_CS": "p14"
+ },
+ "NUCLEO_F429ZI": {
+ "SPI_MOSI": "PC_12",
+ "SPI_MISO": "PC_11",
+ "SPI_CLK": "PC_10",
+ "SPI_CS": "PA_15"
+ },
+ "NUCLEO_L031K6": {
+ "SPI_MOSI": "SPI_MOSI",
+ "SPI_MISO": "SPI_MISO",
+ "SPI_CLK": "SPI_SCK",
+ "SPI_CS": "SPI_CS"
+ },
+ "NUMAKER_PFM_M453": {
+ "SPI_MOSI": "PD_13",
+ "SPI_MISO": "PD_14",
+ "SPI_CLK": "PD_15",
+ "SPI_CS": "PD_12"
+ },
+ "NUMAKER_PFM_NUC472": {
+ "SPI_MOSI": "PF_0",
+ "SPI_MISO": "PD_15",
+ "SPI_CLK": "PD_14",
+ "SPI_CS": "PD_13"
+ },
+ "nRF51822": {
+ "SPI_MOSI": "p12",
+ "SPI_MISO": "p13",
+ "SPI_CLK": "p15",
+ "SPI_CS": "p14"
+ },
+ "UBLOX_EVK_ODIN_W2": {
+ "SPI_CS": "D9",
+ "SPI_MOSI": "D11",
+ "SPI_MISO": "D12",
+ "SPI_CLK": "D13"
+ },
+ "RZ_A1H": {
+ "SPI_MOSI": "P8_5",
+ "SPI_MISO": "P8_6",
+ "SPI_CLK": "P8_3",
+ "SPI_CS": "P8_4"
+ },
+ "HEXIWEAR": {
+ "SPI_MOSI": "PTE3",
+ "SPI_MISO": "PTE1",
+ "SPI_CLK": "PTE2",
+ "SPI_CS": "PTE4"
+ }
+ }
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/util/fsfat_debug.h Thu Apr 12 01:36:31 2018 +0000
@@ -0,0 +1,89 @@
+/** @file fsfat_debug.h
+ *
+ * component debug header file.
+ */
+
+
+#ifndef __FSFAT_DEBUG
+#define __FSFAT_DEBUG
+
+#include <stdint.h>
+#include <assert.h>
+#include <stdio.h>
+
+
+/* Debug Support */
+
+#define FSFAT_LOG_NONE 0
+#define FSFAT_LOG_ERR 1
+#define FSFAT_LOG_WARN 2
+#define FSFAT_LOG_NOTICE 3
+#define FSFAT_LOG_INFO 4
+#define FSFAT_LOG_DEBUG 5
+#define FSFAT_LOG_FENTRY 6
+
+#define FSFAT_LOG(_fmt, ...) \
+ do \
+ { \
+ printf(_fmt, __VA_ARGS__); \
+ }while(0);
+
+#define noFSFAT_DEBUG
+#ifdef FSFAT_DEBUG
+
+extern uint32_t fsfat_optDebug_g;
+extern uint32_t fsfat_optLogLevel_g;
+
+
+/* uncomment for asserts to work */
+/* #undef NDEBUG */
+// todo: port to mbedOSV3++ #include <core-util/assert.h>
+
+#define FSFAT_INLINE
+// todo: port to mbedOSV3++ #define FSFAT_ASSERT CORE_UTIL_ASSERT
+#define FSFAT_ASSERT(...)
+
+#define FSFAT_DBGLOG(_fmt, ...) \
+ do \
+ { \
+ if(fsfat_optDebug_g && (fsfat_optLogLevel_g >= FSFAT_LOG_DEBUG)) \
+ { \
+ printf(_fmt, __VA_ARGS__); \
+ } \
+ }while(0);
+
+
+#define FSFAT_ERRLOG(_fmt, ...) \
+ do \
+ { \
+ if(fsfat_optDebug_g && (fsfat_optLogLevel_g >= FSFAT_LOG_ERR)) \
+ { \
+ printf(_fmt, __VA_ARGS__); \
+ } \
+ }while(0);
+
+
+#define FSFAT_FENTRYLOG(_fmt, ...) \
+ do \
+ { \
+ if(fsfat_optDebug_g && (fsfat_optLogLevel_g >= FSFAT_LOG_FENTRY)) \
+ { \
+ printf(_fmt, __VA_ARGS__); \
+ } \
+ }while(0);
+
+
+
+
+
+#else
+#define FSFAT_ASSERT(_x) do { } while(0)
+#define FSFAT_INLINE inline
+#define FSFAT_DBGLOG(_fmt, ...) do { } while(0)
+#define FSFAT_ERRLOG(_fmt, ...) do { } while(0)
+#define FSFAT_FENTRYLOG(_fmt, ...) do { } while(0)
+#endif /* FSFAT_DEBUG */
+
+
+#endif /*__FSFAT_DEBUG*/
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/util/fsfat_test.c Thu Apr 12 01:36:31 2018 +0000
@@ -0,0 +1,118 @@
+/* @file fsfat_test.c
+ *
+ * mbed Microcontroller Library
+ * Copyright (c) 2006-2016 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * test support code implementation file.
+ */
+
+#include "fsfat_debug.h"
+#include "fsfat_test.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <inttypes.h>
+#include <ctype.h>
+
+
+#ifdef FSFAT_DEBUG
+uint32_t fsfat_optDebug_g = 1;
+uint32_t fsfat_optLogLevel_g = FSFAT_LOG_NONE; /*FSFAT_LOG_NONE|FSFAT_LOG_ERR|FSFAT_LOG_DEBUG|FSFAT_LOG_FENTRY; */
+#endif
+
+/* ruler for measuring text strings */
+/* 1 1 1 1 1 1 1 1 1 1 2 2 2 */
+/* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 */
+/* 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 */
+
+const uint8_t fsfat_test_byte_data_table[FSFAT_TEST_BYTE_DATA_TABLE_SIZE] = {
+ 0x2d, 0xf3, 0x31, 0x4c, 0x11, 0x4f, 0xde, 0x0d, 0xbd, 0xbc, 0xa6, 0x78, 0x36, 0x5c, 0x1d, 0x28,
+ 0x5f, 0xa9, 0x10, 0x65, 0x54, 0x45, 0x21, 0x1a, 0x88, 0xfe, 0x76, 0x45, 0xb9, 0xac, 0x65, 0x9a,
+ 0x34, 0x9d, 0x73, 0x10, 0xb4, 0xa9, 0x2e, 0x90, 0x95, 0x68, 0xac, 0xfe, 0xc5, 0x2d, 0x15, 0x03,
+ 0x34, 0x70, 0xf1, 0x1d, 0x48, 0xa1, 0xa0, 0xed, 0x5c, 0x2f, 0xf5, 0x2b, 0xb9, 0x84, 0xbb, 0x45,
+ 0x32, 0xdd, 0xb1, 0x33, 0x95, 0x2a, 0xbc, 0x26, 0xf0, 0x89, 0xba, 0xf4, 0xbd, 0xf9, 0x5d, 0x2e,
+ 0x6e, 0x11, 0xc6, 0xa7, 0x78, 0xfc, 0xc9, 0x0e, 0x6b, 0x38, 0xba, 0x14, 0x1b, 0xab, 0x4c, 0x20,
+ 0x91, 0xe4, 0xb0, 0xf1, 0x2b, 0x14, 0x07, 0x6b, 0xb5, 0xcd, 0xe3, 0x49, 0x75, 0xac, 0xe8, 0x98,
+ 0xf1, 0x58, 0x8f, 0xd9, 0xc4, 0x8f, 0x00, 0x17, 0xb5, 0x06, 0x6a, 0x33, 0xbd, 0xa7, 0x40, 0x5a,
+ 0xbf, 0x49, 0xf7, 0x27, 0x1b, 0x4c, 0x3e, 0x6f, 0xe3, 0x08, 0x1f, 0xfd, 0xa6, 0xd4, 0xc7, 0x5f,
+ 0xa4, 0xa6, 0x82, 0xad, 0x19, 0xd5, 0x5c, 0xd8, 0x3a, 0x49, 0x85, 0xc9, 0x21, 0x83, 0xf6, 0xc6,
+ 0x84, 0xf9, 0x76, 0x89, 0xf3, 0x2d, 0x17, 0x50, 0x97, 0x38, 0x48, 0x9a, 0xe1, 0x82, 0xcd, 0xac,
+ 0xa8, 0x1d, 0xd7, 0x96, 0x5e, 0xb3, 0x08, 0xa8, 0x3a, 0xc7, 0x2b, 0x05, 0xaf, 0xdc, 0x16, 0xdf,
+ 0x48, 0x0f, 0x2a, 0x7e, 0x3a, 0x82, 0xd7, 0x80, 0xd6, 0x49, 0x27, 0x5d, 0xe3, 0x07, 0x62, 0xb3,
+ 0xc3, 0x6c, 0xba, 0xb2, 0xaa, 0x9f, 0xd9, 0x03, 0x0d, 0x27, 0xa8, 0xe0, 0xd6, 0xee, 0x79, 0x4b,
+ 0xd6, 0x97, 0x99, 0xb7, 0x11, 0xd6, 0x0d, 0x34, 0xae, 0x99, 0x4a, 0x93, 0x95, 0xd0, 0x5a, 0x34,
+ 0x19, 0xa2, 0x69, 0x57, 0xcf, 0x7c, 0x3d, 0x98, 0x88, 0x5d, 0x04, 0xf2, 0xd7, 0xac, 0xa5, 0x63
+};
+
+
+/* @brief test utility function to delete the file identified by filename
+ */
+int32_t fsfat_test_delete(const char* filename)
+{
+ FSFAT_FENTRYLOG("%s:entered.\r\n", __func__);
+ return remove(filename);
+}
+
+
+/* @brief test utility function to create a file
+ *
+ * @param filename name of the file including path
+ * @param data data to store in file
+ * @param len number of bytes of data present in the data buffer.
+ */
+int32_t fsfat_test_create(const char* filename, const char* data, size_t len)
+{
+ int32_t ret = -1;
+ FILE *fp = NULL;
+
+ FSFAT_FENTRYLOG("%s:entered (filename=%s, len=%d).\n", __func__, filename, (int) len);
+ fp = fopen(filename, "w+");
+ if(fp == NULL){
+ return ret;
+ }
+ ret = fwrite((const void*) data, len, 1, fp);
+ if(ret < 0){
+ fclose(fp);
+ return ret;
+ }
+ fclose(fp);
+ return ret;
+}
+
+
+/* @brief support function for generating a kv_name
+ * @param name buffer to hold kv name
+ * @param len length of kv name to generate
+ *
+ */
+int32_t fsfat_test_filename_gen(char* name, const size_t len)
+{
+ size_t i;
+ uint32_t pos = 0;
+
+ const char* buf = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!$-_@";
+ const int buf_len = strlen(buf);
+ FSFAT_FENTRYLOG("%s:entered\n", __func__);
+ for(i = 0; i < len; i++)
+ {
+ pos = rand() % (buf_len);
+ name[i] = buf[pos];
+ }
+ return 0;
+}
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/util/fsfat_test.h Thu Apr 12 01:36:31 2018 +0000
@@ -0,0 +1,75 @@
+/** @file fsfat_test.h
+ *
+ * mbed Microcontroller Library
+ * Copyright (c) 2006-2016 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Header file for test support data structures and function API.
+ */
+#ifndef __FSFAT_TEST_H
+#define __FSFAT_TEST_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Defines */
+//#define FSFAT_INIT_1_TABLE_HEAD { "a", ""}
+#define FSFAT_INIT_1_TABLE_MID_NODE { "/sd/01234567.txt", "abcdefghijklmnopqrstuvwxyz"}
+//#define FSFAT_INIT_1_TABLE_TAIL { "/sd/fopentst/hello/world/animal/wobbly/dog/foot/backrght.txt", "present"}
+#define FSFAT_TEST_RW_TABLE_SENTINEL 0xffffffff
+#define FSFAT_TEST_BYTE_DATA_TABLE_SIZE 256
+#define FSFAT_UTEST_MSG_BUF_SIZE 256
+#define FSFAT_UTEST_DEFAULT_TIMEOUT_MS 10000
+#define FSFAT_MBED_HOSTTEST_TIMEOUT 60
+#define FSFAT_MAX_FILE_BASENAME 8
+#define FSFAT_MAX_FILE_EXTNAME 3
+#define FSFAT_BUF_MAX_LENGTH 64
+#define FSFAT_FILENAME_MAX_LENGTH 255
+
+
+/* support macro for make string for utest _MESSAGE macros, which dont support formatted output */
+#define FSFAT_TEST_UTEST_MESSAGE(_buf, _max_len, _fmt, ...) \
+ do \
+ { \
+ snprintf((_buf), (_max_len), (_fmt), __VA_ARGS__); \
+ }while(0);
+
+
+/*
+ * Structures
+ */
+
+/* kv data for test */
+typedef struct fsfat_kv_data_t {
+ const char* filename;
+ const char* value;
+} fsfat_kv_data_t;
+
+
+extern const uint8_t fsfat_test_byte_data_table[FSFAT_TEST_BYTE_DATA_TABLE_SIZE];
+
+int32_t fsfat_test_create(const char* filename, const char* data, size_t len);
+int32_t fsfat_test_delete(const char* key_name);
+int32_t fsfat_test_filename_gen(char* name, const size_t len);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __FSFAT_TEST_H */
+