diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/examples/ant/ant_fs/client/mem.c')
| -rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/examples/ant/ant_fs/client/mem.c | 221 |
1 files changed, 221 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/examples/ant/ant_fs/client/mem.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/examples/ant/ant_fs/client/mem.c new file mode 100644 index 0000000..8d88292 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/examples/ant/ant_fs/client/mem.c @@ -0,0 +1,221 @@ +/** + * This software is subject to the ANT+ Shared Source License + * www.thisisant.com/swlicenses + * Copyright (c) Dynastream Innovations, Inc. 2012 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that the following + * conditions are met: + * 1) Redistributions of source code must retain the above + * copyright notice, this list of conditions and the following + * disclaimer. + * + * 2) Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * 3) Neither the name of Dynastream nor the names of its + * contributors may be used to endorse or promote products + * derived from this software without specific prior + * written permission. + * + * The following actions are prohibited: + * 1) Redistribution of source code containing the ANT+ Network + * Key. The ANT+ Network Key is available to ANT+ Adopters. + * Please refer to http://thisisant.com to become an ANT+ + * Adopter and access the key. + * + * 2) Reverse engineering, decompilation, and/or disassembly of + * software provided in binary form under this license. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE HEREBY + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; DAMAGE TO ANY DEVICE, LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. SOME STATES DO NOT ALLOW + * THE EXCLUSION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THE + * ABOVE LIMITATIONS MAY NOT APPLY TO YOU. + * + */ +#include "mem.h" +#include <string.h> + +#define NRF_LOG_MODULE_NAME MEM + +#if MEM_WRITE_LOG_ENABLED +#define NRF_LOG_LEVEL MEM_WRITE_LOG_LEVEL +#define NRF_LOG_INFO_COLOR MEM_WRITE_INFO_COLOR +#define NRF_LOG_DEBUG_COLOR MEM_WRITE_DEBUG_COLOR +#else //MEM_WRITE_LOG_ENABLED +#define NRF_LOG_LEVEL 0 +#endif //MEM_WRITE_LOG_ENABLED +#include "nrf_log.h" +NRF_LOG_MODULE_REGISTER(); + +#define MEM_DIR_SIZE 9u /**< Example directory size. */ +#define MEM_DIR_INVALID_INDEX 0xFFFFu /**< Defined invalid index value. */ + +// Sample constant directory structure. +typedef struct +{ + antfs_dir_header_t header; /**< Directory header. */ + antfs_dir_struct_t directory_file[MEM_DIR_SIZE]; /**< Array of directory entry structures. */ +} directory_file_t; + +// Sample constant directory. +static const directory_file_t m_directory = +{ + { + ANTFS_DIR_STRUCT_VERSION, // Version 1, length of each subsequent entry = 16 bytes, system time not used. + sizeof(antfs_dir_struct_t), + 0, 0, 0, 0, 0, 0, 0, 0 + }, + { + {9, 0, 4, 0, 0, 0xA0, 0x00000000, 0x000296BC}, // Index 9, data type 0, identifier 4, read and erase, 0 bytes in length. + {7, 1, 0, 0, 0, 0x60, 0x00000000, 0x00007E71}, // Index 7, data type 1, identifier 0, write and erase, 0 bytes in length. + {8, 1, 1, 0, 0, 0x60, 0x00000000, 0x00007E73}, // Index 8, data type 1, identifier 1, write and erase, 0 bytes in length. + {1, 0x80, 1, 0, 0, 0x80, 0x000000DA, 0x00007E63}, // Index 1, data type 128, identifier 1, read and write, 218 bytes in length. + {2, 0x80, 2, 0, 0, 0xC0, 0x0000014E, 0x00007E65}, // Index 2, data type 128, identifier 2, read and write, 334 bytes in length. + {3, 0x80, 3, 0, 0, 0xC0, 0x0000037B, 0x00007E67}, // Index 3, data type 128, identifier 3, read and write, 891 bytes in length. + {4, 0x80, 3, 0, 0, 0xC0, 0x0000037B, 0x00007E6A}, // Index 4, data type 128, identifier 3, read and write, 891 bytes in length. + {5, 0x80, 3, 0, 0, 0xF0, 0x0001D4C0, 0x00007E6C}, // Index 5, data type 128, identifier 3, read, write, erase, archive, 120000 bytes in length. + {6, 0x80, 0x0A, 0, 0, 0x80, 0x00000000, 0x00007E6F} // Index 6, data type 128, identifier 10, read-only, 0 bytes in length. + } +}; + + +/**@brief Function for getting an array index of a particular directory structure matching the + * requested file index. + * + * @param[in] index The file index identifier used for lookup. + * + * @return Upon success the array index, otherwise MEM_DIR_INVALID_INDEX. + */ +static uint32_t index_lookup(uint32_t index) +{ + if (index) + { + uint32_t idx; + for (idx = 0; idx < MEM_DIR_SIZE; idx++) + { + if (m_directory.directory_file[idx].data_file_index == index) + { + return idx; + } + } + + } + + return MEM_DIR_INVALID_INDEX; +} + + +bool mem_file_write(uint16_t index, uint32_t offset, const void * p_data, uint32_t size) +{ + if ((index < MEM_DIR_SIZE + 1u) && (index > 0)) + { + const uint32_t array_index = index_lookup(index); + if (array_index != MEM_DIR_INVALID_INDEX) + { + NRF_LOG_HEXDUMP_INFO(p_data, size); + return true; + } + else + { + return false; + } + + } + + return false; +} + + +void mem_file_read(uint16_t index, uint32_t offset, void * p_data, uint32_t size) +{ + if (index == 0) + { + // Directory. + + uint8_t * p_directory = (uint8_t*) &m_directory; + memcpy((uint8_t*)p_data, p_directory + offset, size); + } + else + { + // Fake data (no actual files stored in memory for this reference design). + + uint32_t idx; + uint8_t* p_data_access = (uint8_t*)p_data; + for (idx = 0; idx < size; idx++) + { + p_data_access[idx] = ((uint8_t)(offset + idx)); + } + } +} + + +bool mem_file_erase(uint16_t index) +{ + if ((index < MEM_DIR_SIZE + 1u) && (index > 0)) + { + const uint32_t array_index = index_lookup(index); + if (array_index != MEM_DIR_INVALID_INDEX) + { + // Erase file. This function is implementation specific. There are no actual files in + // memory for this reference design, so there is nothing to erase. + return true; + } + else + { + return false; + } + } + + return false; +} + + +bool mem_file_info_get(uint16_t index, antfs_dir_struct_t * p_file_info) +{ + if (index < (MEM_DIR_SIZE + 1u)) + { + if (index == 0) + { + // Requested directory. + + // Set can download flag. + p_file_info->general_flags = 0x80u; + + p_file_info->file_size_in_bytes = + // Header + directory structures. + (uint32_t)(MEM_DIR_SIZE + 1u) * sizeof(antfs_dir_struct_t); + + // Directory is index 0 + p_file_info->data_file_index = 0; + } + else + { + // Requested a file. + + const uint32_t array_index = index_lookup(index); + memcpy(p_file_info, + &m_directory.directory_file[array_index], + sizeof(antfs_dir_struct_t)); + } + + return true; + } + + return false; +} |