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