1 /* 2 * Copyright (c) 2014, ARM Limited and Contributors. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * 7 * Redistributions of source code must retain the above copyright notice, this 8 * list of conditions and the following disclaimer. 9 * 10 * Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 14 * Neither the name of ARM nor the names of its contributors may be used 15 * to endorse or promote products derived from this software without specific 16 * prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include <assert.h> 32 #include <debug.h> 33 #include <io_driver.h> 34 #include <io_storage.h> 35 #include <string.h> 36 37 /* As we need to be able to keep state for seek, only one file can be open 38 * at a time. Make this a structure and point to the entity->info. When we 39 * can malloc memory we can change this to support more open files. 40 */ 41 typedef struct { 42 /* Use the 'in_use' flag as any value for base and file_pos could be 43 * valid. 44 */ 45 int in_use; 46 uintptr_t base; 47 size_t file_pos; 48 size_t size; 49 } file_state_t; 50 51 static file_state_t current_file = {0}; 52 53 /* Identify the device type as memmap */ 54 io_type_t device_type_memmap(void) 55 { 56 return IO_TYPE_MEMMAP; 57 } 58 59 /* Memmap device functions */ 60 static int memmap_dev_open(const uintptr_t dev_spec, io_dev_info_t **dev_info); 61 static int memmap_block_open(io_dev_info_t *dev_info, const uintptr_t spec, 62 io_entity_t *entity); 63 static int memmap_block_seek(io_entity_t *entity, int mode, 64 ssize_t offset); 65 static int memmap_block_len(io_entity_t *entity, size_t *length); 66 static int memmap_block_read(io_entity_t *entity, uintptr_t buffer, 67 size_t length, size_t *length_read); 68 static int memmap_block_write(io_entity_t *entity, const uintptr_t buffer, 69 size_t length, size_t *length_written); 70 static int memmap_block_close(io_entity_t *entity); 71 static int memmap_dev_close(io_dev_info_t *dev_info); 72 73 74 static const io_dev_connector_t memmap_dev_connector = { 75 .dev_open = memmap_dev_open 76 }; 77 78 79 static const io_dev_funcs_t memmap_dev_funcs = { 80 .type = device_type_memmap, 81 .open = memmap_block_open, 82 .seek = memmap_block_seek, 83 .size = memmap_block_len, 84 .read = memmap_block_read, 85 .write = memmap_block_write, 86 .close = memmap_block_close, 87 .dev_init = NULL, 88 .dev_close = memmap_dev_close, 89 }; 90 91 92 /* No state associated with this device so structure can be const */ 93 static const io_dev_info_t memmap_dev_info = { 94 .funcs = &memmap_dev_funcs, 95 .info = (uintptr_t)NULL 96 }; 97 98 99 /* Open a connection to the memmap device */ 100 static int memmap_dev_open(const uintptr_t dev_spec __unused, 101 io_dev_info_t **dev_info) 102 { 103 assert(dev_info != NULL); 104 *dev_info = (io_dev_info_t *)&memmap_dev_info; /* cast away const */ 105 106 return 0; 107 } 108 109 110 111 /* Close a connection to the memmap device */ 112 static int memmap_dev_close(io_dev_info_t *dev_info) 113 { 114 /* NOP */ 115 /* TODO: Consider tracking open files and cleaning them up here */ 116 return 0; 117 } 118 119 120 /* Open a file on the memmap device */ 121 /* TODO: Can we do any sensible limit checks on requested memory */ 122 static int memmap_block_open(io_dev_info_t *dev_info, const uintptr_t spec, 123 io_entity_t *entity) 124 { 125 int result = -ENOMEM; 126 const io_block_spec_t *block_spec = (io_block_spec_t *)spec; 127 128 /* Since we need to track open state for seek() we only allow one open 129 * spec at a time. When we have dynamic memory we can malloc and set 130 * entity->info. 131 */ 132 if (current_file.in_use == 0) { 133 assert(block_spec != NULL); 134 assert(entity != NULL); 135 136 current_file.in_use = 1; 137 current_file.base = block_spec->offset; 138 /* File cursor offset for seek and incremental reads etc. */ 139 current_file.file_pos = 0; 140 current_file.size = block_spec->length; 141 entity->info = (uintptr_t)¤t_file; 142 result = 0; 143 } else { 144 WARN("A Memmap device is already active. Close first.\n"); 145 } 146 147 return result; 148 } 149 150 151 /* Seek to a particular file offset on the memmap device */ 152 static int memmap_block_seek(io_entity_t *entity, int mode, ssize_t offset) 153 { 154 int result = -ENOENT; 155 156 /* We only support IO_SEEK_SET for the moment. */ 157 if (mode == IO_SEEK_SET) { 158 assert(entity != NULL); 159 160 /* TODO: can we do some basic limit checks on seek? */ 161 ((file_state_t *)entity->info)->file_pos = offset; 162 result = 0; 163 } 164 165 return result; 166 } 167 168 169 /* Return the size of a file on the memmap device */ 170 static int memmap_block_len(io_entity_t *entity, size_t *length) 171 { 172 assert(entity != NULL); 173 assert(length != NULL); 174 175 *length = ((file_state_t *)entity->info)->size; 176 177 return 0; 178 } 179 180 181 /* Read data from a file on the memmap device */ 182 static int memmap_block_read(io_entity_t *entity, uintptr_t buffer, 183 size_t length, size_t *length_read) 184 { 185 file_state_t *fp; 186 187 assert(entity != NULL); 188 assert(buffer != (uintptr_t)NULL); 189 assert(length_read != NULL); 190 191 fp = (file_state_t *)entity->info; 192 193 memcpy((void *)buffer, (void *)(fp->base + fp->file_pos), length); 194 195 *length_read = length; 196 /* advance the file 'cursor' for incremental reads */ 197 fp->file_pos += length; 198 199 return 0; 200 } 201 202 203 /* Write data to a file on the memmap device */ 204 static int memmap_block_write(io_entity_t *entity, const uintptr_t buffer, 205 size_t length, size_t *length_written) 206 { 207 file_state_t *fp; 208 209 assert(entity != NULL); 210 assert(buffer != (uintptr_t)NULL); 211 assert(length_written != NULL); 212 213 fp = (file_state_t *)entity->info; 214 215 memcpy((void *)(fp->base + fp->file_pos), (void *)buffer, length); 216 217 *length_written = length; 218 219 /* advance the file 'cursor' for incremental writes */ 220 fp->file_pos += length; 221 222 return 0; 223 } 224 225 226 /* Close a file on the memmap device */ 227 static int memmap_block_close(io_entity_t *entity) 228 { 229 assert(entity != NULL); 230 231 entity->info = 0; 232 233 /* This would be a mem free() if we had malloc.*/ 234 memset((void *)¤t_file, 0, sizeof(current_file)); 235 236 return 0; 237 } 238 239 240 /* Exported functions */ 241 242 /* Register the memmap driver with the IO abstraction */ 243 int register_io_dev_memmap(const io_dev_connector_t **dev_con) 244 { 245 int result; 246 assert(dev_con != NULL); 247 248 result = io_register_device(&memmap_dev_info); 249 if (result == 0) 250 *dev_con = &memmap_dev_connector; 251 252 return result; 253 } 254