1 /* 2 * Copyright (c) 2014-2017, 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 #include <utils.h> 37 38 /* As we need to be able to keep state for seek, only one file can be open 39 * at a time. Make this a structure and point to the entity->info. When we 40 * can malloc memory we can change this to support more open files. 41 */ 42 typedef struct { 43 /* Use the 'in_use' flag as any value for base and file_pos could be 44 * valid. 45 */ 46 int in_use; 47 uintptr_t base; 48 size_t file_pos; 49 size_t size; 50 } file_state_t; 51 52 static file_state_t current_file = {0}; 53 54 /* Identify the device type as memmap */ 55 io_type_t device_type_memmap(void) 56 { 57 return IO_TYPE_MEMMAP; 58 } 59 60 /* Memmap device functions */ 61 static int memmap_dev_open(const uintptr_t dev_spec, io_dev_info_t **dev_info); 62 static int memmap_block_open(io_dev_info_t *dev_info, const uintptr_t spec, 63 io_entity_t *entity); 64 static int memmap_block_seek(io_entity_t *entity, int mode, 65 ssize_t offset); 66 static int memmap_block_len(io_entity_t *entity, size_t *length); 67 static int memmap_block_read(io_entity_t *entity, uintptr_t buffer, 68 size_t length, size_t *length_read); 69 static int memmap_block_write(io_entity_t *entity, const uintptr_t buffer, 70 size_t length, size_t *length_written); 71 static int memmap_block_close(io_entity_t *entity); 72 static int memmap_dev_close(io_dev_info_t *dev_info); 73 74 75 static const io_dev_connector_t memmap_dev_connector = { 76 .dev_open = memmap_dev_open 77 }; 78 79 80 static const io_dev_funcs_t memmap_dev_funcs = { 81 .type = device_type_memmap, 82 .open = memmap_block_open, 83 .seek = memmap_block_seek, 84 .size = memmap_block_len, 85 .read = memmap_block_read, 86 .write = memmap_block_write, 87 .close = memmap_block_close, 88 .dev_init = NULL, 89 .dev_close = memmap_dev_close, 90 }; 91 92 93 /* No state associated with this device so structure can be const */ 94 static const io_dev_info_t memmap_dev_info = { 95 .funcs = &memmap_dev_funcs, 96 .info = (uintptr_t)NULL 97 }; 98 99 100 /* Open a connection to the memmap device */ 101 static int memmap_dev_open(const uintptr_t dev_spec __unused, 102 io_dev_info_t **dev_info) 103 { 104 assert(dev_info != NULL); 105 *dev_info = (io_dev_info_t *)&memmap_dev_info; /* cast away const */ 106 107 return 0; 108 } 109 110 111 112 /* Close a connection to the memmap device */ 113 static int memmap_dev_close(io_dev_info_t *dev_info) 114 { 115 /* NOP */ 116 /* TODO: Consider tracking open files and cleaning them up here */ 117 return 0; 118 } 119 120 121 /* Open a file on the memmap device */ 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 assert(block_spec->length >= 0); 129 130 /* Since we need to track open state for seek() we only allow one open 131 * spec at a time. When we have dynamic memory we can malloc and set 132 * entity->info. 133 */ 134 if (current_file.in_use == 0) { 135 assert(block_spec != NULL); 136 assert(entity != NULL); 137 138 current_file.in_use = 1; 139 current_file.base = block_spec->offset; 140 /* File cursor offset for seek and incremental reads etc. */ 141 current_file.file_pos = 0; 142 current_file.size = block_spec->length; 143 entity->info = (uintptr_t)¤t_file; 144 result = 0; 145 } else { 146 WARN("A Memmap device is already active. Close first.\n"); 147 } 148 149 return result; 150 } 151 152 153 /* Seek to a particular file offset on the memmap device */ 154 static int memmap_block_seek(io_entity_t *entity, int mode, ssize_t offset) 155 { 156 int result = -ENOENT; 157 file_state_t *fp; 158 159 /* We only support IO_SEEK_SET for the moment. */ 160 if (mode == IO_SEEK_SET) { 161 assert(entity != NULL); 162 163 fp = (file_state_t *) entity->info; 164 165 /* Assert that new file position is valid */ 166 assert((offset >= 0) && (offset < fp->size)); 167 168 /* Reset file position */ 169 fp->file_pos = offset; 170 result = 0; 171 } 172 173 return result; 174 } 175 176 177 /* Return the size of a file on the memmap device */ 178 static int memmap_block_len(io_entity_t *entity, size_t *length) 179 { 180 assert(entity != NULL); 181 assert(length != NULL); 182 183 *length = ((file_state_t *)entity->info)->size; 184 185 return 0; 186 } 187 188 189 /* Read data from a file on the memmap device */ 190 static int memmap_block_read(io_entity_t *entity, uintptr_t buffer, 191 size_t length, size_t *length_read) 192 { 193 file_state_t *fp; 194 size_t pos_after; 195 196 assert(entity != NULL); 197 assert(buffer != (uintptr_t)NULL); 198 assert(length_read != NULL); 199 200 fp = (file_state_t *) entity->info; 201 202 /* Assert that file position is valid for this read operation */ 203 pos_after = fp->file_pos + length; 204 assert((pos_after >= fp->file_pos) && (pos_after <= fp->size)); 205 206 memcpy((void *)buffer, (void *)(fp->base + fp->file_pos), length); 207 208 *length_read = length; 209 210 /* Set file position after read */ 211 fp->file_pos = pos_after; 212 213 return 0; 214 } 215 216 217 /* Write data to a file on the memmap device */ 218 static int memmap_block_write(io_entity_t *entity, const uintptr_t buffer, 219 size_t length, size_t *length_written) 220 { 221 file_state_t *fp; 222 size_t pos_after; 223 224 assert(entity != NULL); 225 assert(buffer != (uintptr_t)NULL); 226 assert(length_written != NULL); 227 228 fp = (file_state_t *) entity->info; 229 230 /* Assert that file position is valid for this write operation */ 231 pos_after = fp->file_pos + length; 232 assert((pos_after >= fp->file_pos) && (pos_after <= fp->size)); 233 234 memcpy((void *)(fp->base + fp->file_pos), (void *)buffer, length); 235 236 *length_written = length; 237 238 /* Set file position after write */ 239 fp->file_pos = pos_after; 240 241 return 0; 242 } 243 244 245 /* Close a file on the memmap device */ 246 static int memmap_block_close(io_entity_t *entity) 247 { 248 assert(entity != NULL); 249 250 entity->info = 0; 251 252 /* This would be a mem free() if we had malloc.*/ 253 zeromem((void *)¤t_file, sizeof(current_file)); 254 255 return 0; 256 } 257 258 259 /* Exported functions */ 260 261 /* Register the memmap driver with the IO abstraction */ 262 int register_io_dev_memmap(const io_dev_connector_t **dev_con) 263 { 264 int result; 265 assert(dev_con != NULL); 266 267 result = io_register_device(&memmap_dev_info); 268 if (result == 0) 269 *dev_con = &memmap_dev_connector; 270 271 return result; 272 } 273