1 /* 2 * Copyright 2012-15 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * Authors: AMD 23 * 24 */ 25 26 #include "dm_services.h" 27 #include "include/vector.h" 28 29 bool dal_vector_construct( 30 struct vector *vector, 31 struct dc_context *ctx, 32 uint32_t capacity, 33 uint32_t struct_size) 34 { 35 vector->container = NULL; 36 37 if (!struct_size || !capacity) { 38 /* Container must be non-zero size*/ 39 BREAK_TO_DEBUGGER(); 40 return false; 41 } 42 43 vector->container = kcalloc(capacity, struct_size, GFP_KERNEL); 44 if (vector->container == NULL) 45 return false; 46 vector->capacity = capacity; 47 vector->struct_size = struct_size; 48 vector->count = 0; 49 vector->ctx = ctx; 50 return true; 51 } 52 53 bool dal_vector_presized_costruct( 54 struct vector *vector, 55 struct dc_context *ctx, 56 uint32_t count, 57 void *initial_value, 58 uint32_t struct_size) 59 { 60 uint32_t i; 61 62 vector->container = NULL; 63 64 if (!struct_size || !count) { 65 /* Container must be non-zero size*/ 66 BREAK_TO_DEBUGGER(); 67 return false; 68 } 69 70 vector->container = kcalloc(count, struct_size, GFP_KERNEL); 71 72 if (vector->container == NULL) 73 return false; 74 75 /* If caller didn't supply initial value then the default 76 * of all zeros is expected, which is exactly what dal_alloc() 77 * initialises the memory to. */ 78 if (NULL != initial_value) { 79 for (i = 0; i < count; ++i) 80 memmove( 81 vector->container + i * struct_size, 82 initial_value, 83 struct_size); 84 } 85 86 vector->capacity = count; 87 vector->struct_size = struct_size; 88 vector->count = count; 89 return true; 90 } 91 92 struct vector *dal_vector_presized_create( 93 struct dc_context *ctx, 94 uint32_t size, 95 void *initial_value, 96 uint32_t struct_size) 97 { 98 struct vector *vector = kzalloc(sizeof(struct vector), GFP_KERNEL); 99 100 if (vector == NULL) 101 return NULL; 102 103 if (dal_vector_presized_costruct( 104 vector, ctx, size, initial_value, struct_size)) 105 return vector; 106 107 BREAK_TO_DEBUGGER(); 108 kfree(vector); 109 return NULL; 110 } 111 112 struct vector *dal_vector_create( 113 struct dc_context *ctx, 114 uint32_t capacity, 115 uint32_t struct_size) 116 { 117 struct vector *vector = kzalloc(sizeof(struct vector), GFP_KERNEL); 118 119 if (vector == NULL) 120 return NULL; 121 122 if (dal_vector_construct(vector, ctx, capacity, struct_size)) 123 return vector; 124 125 BREAK_TO_DEBUGGER(); 126 kfree(vector); 127 return NULL; 128 } 129 130 void dal_vector_destruct( 131 struct vector *vector) 132 { 133 kfree(vector->container); 134 vector->count = 0; 135 vector->capacity = 0; 136 } 137 138 void dal_vector_destroy( 139 struct vector **vector) 140 { 141 if (vector == NULL || *vector == NULL) 142 return; 143 dal_vector_destruct(*vector); 144 kfree(*vector); 145 *vector = NULL; 146 } 147 148 uint32_t dal_vector_get_count( 149 const struct vector *vector) 150 { 151 return vector->count; 152 } 153 154 void *dal_vector_at_index( 155 const struct vector *vector, 156 uint32_t index) 157 { 158 if (vector->container == NULL || index >= vector->count) 159 return NULL; 160 return vector->container + (index * vector->struct_size); 161 } 162 163 bool dal_vector_remove_at_index( 164 struct vector *vector, 165 uint32_t index) 166 { 167 if (index >= vector->count) 168 return false; 169 170 if (index != vector->count - 1) 171 memmove( 172 vector->container + (index * vector->struct_size), 173 vector->container + ((index + 1) * vector->struct_size), 174 (vector->count - index - 1) * vector->struct_size); 175 vector->count -= 1; 176 177 return true; 178 } 179 180 void dal_vector_set_at_index( 181 const struct vector *vector, 182 const void *what, 183 uint32_t index) 184 { 185 void *where = dal_vector_at_index(vector, index); 186 187 if (!where) { 188 BREAK_TO_DEBUGGER(); 189 return; 190 } 191 memmove( 192 where, 193 what, 194 vector->struct_size); 195 } 196 197 static inline uint32_t calc_increased_capacity( 198 uint32_t old_capacity) 199 { 200 return old_capacity * 2; 201 } 202 203 bool dal_vector_insert_at( 204 struct vector *vector, 205 const void *what, 206 uint32_t position) 207 { 208 uint8_t *insert_address; 209 210 if (vector->count == vector->capacity) { 211 if (!dal_vector_reserve( 212 vector, 213 calc_increased_capacity(vector->capacity))) 214 return false; 215 } 216 217 insert_address = vector->container + (vector->struct_size * position); 218 219 if (vector->count && position < vector->count) 220 memmove( 221 insert_address + vector->struct_size, 222 insert_address, 223 vector->struct_size * (vector->count - position)); 224 225 memmove( 226 insert_address, 227 what, 228 vector->struct_size); 229 230 vector->count++; 231 232 return true; 233 } 234 235 bool dal_vector_append( 236 struct vector *vector, 237 const void *item) 238 { 239 return dal_vector_insert_at(vector, item, vector->count); 240 } 241 242 struct vector *dal_vector_clone( 243 const struct vector *vector) 244 { 245 struct vector *vec_cloned; 246 uint32_t count; 247 248 /* create new vector */ 249 count = dal_vector_get_count(vector); 250 251 if (count == 0) 252 /* when count is 0 we still want to create clone of the vector 253 */ 254 vec_cloned = dal_vector_create( 255 vector->ctx, 256 vector->capacity, 257 vector->struct_size); 258 else 259 /* Call "presized create" version, independently of how the 260 * original vector was created. 261 * The owner of original vector must know how to treat the new 262 * vector - as "presized" or as "regular". 263 * But from vector point of view it doesn't matter. */ 264 vec_cloned = dal_vector_presized_create(vector->ctx, count, 265 NULL,/* no initial value */ 266 vector->struct_size); 267 268 if (NULL == vec_cloned) { 269 BREAK_TO_DEBUGGER(); 270 return NULL; 271 } 272 273 /* copy vector's data */ 274 memmove(vec_cloned->container, vector->container, 275 vec_cloned->struct_size * vec_cloned->capacity); 276 277 return vec_cloned; 278 } 279 280 uint32_t dal_vector_capacity(const struct vector *vector) 281 { 282 return vector->capacity; 283 } 284 285 bool dal_vector_reserve(struct vector *vector, uint32_t capacity) 286 { 287 void *new_container; 288 289 if (capacity <= vector->capacity) 290 return true; 291 292 new_container = krealloc(vector->container, 293 capacity * vector->struct_size, GFP_KERNEL); 294 295 if (new_container) { 296 vector->container = new_container; 297 vector->capacity = capacity; 298 return true; 299 } 300 301 return false; 302 } 303 304 void dal_vector_clear(struct vector *vector) 305 { 306 vector->count = 0; 307 } 308