drivers/gpu/drm/amd/display/dc/basics/vector.c

   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 static bool dal_vector_presized_costruct(struct vector *vector,
  54                                          struct dc_context *ctx,
  55                                          uint32_t count,
  56                                          void *initial_value,
  57                                          uint32_t struct_size)
  58 {
  59         uint32_t i;
  60
  61         vector->container = NULL;
  62
  63         if (!struct_size || !count) {
  64                 /* Container must be non-zero size*/
  65                 BREAK_TO_DEBUGGER();
  66                 return false;
  67         }
  68
  69         vector->container = kcalloc(count, struct_size, GFP_KERNEL);
  70
  71         if (vector->container == NULL)
  72                 return false;
  73
  74         /* If caller didn't supply initial value then the default
  75          * of all zeros is expected, which is exactly what dal_alloc()
  76          * initialises the memory to. */
  77         if (NULL != initial_value) {
  78                 for (i = 0; i < count; ++i)
  79                         memmove(
  80                                 vector->container + i * struct_size,
  81                                 initial_value,
  82                                 struct_size);
  83         }
  84
  85         vector->capacity = count;
  86         vector->struct_size = struct_size;
  87         vector->count = count;
  88         return true;
  89 }
  90
  91 struct vector *dal_vector_presized_create(
  92         struct dc_context *ctx,
  93         uint32_t size,
  94         void *initial_value,
  95         uint32_t struct_size)
  96 {
  97         struct vector *vector = kzalloc(sizeof(struct vector), GFP_KERNEL);
  98
  99         if (vector == NULL)
 100                 return NULL;
 101
 102         if (dal_vector_presized_costruct(
 103                 vector, ctx, size, initial_value, struct_size))
 104                 return vector;
 105
 106         BREAK_TO_DEBUGGER();
 107         kfree(vector);
 108         return NULL;
 109 }
 110
 111 struct vector *dal_vector_create(
 112         struct dc_context *ctx,
 113         uint32_t capacity,
 114         uint32_t struct_size)
 115 {
 116         struct vector *vector = kzalloc(sizeof(struct vector), GFP_KERNEL);
 117
 118         if (vector == NULL)
 119                 return NULL;
 120
 121         if (dal_vector_construct(vector, ctx, capacity, struct_size))
 122                 return vector;
 123
 124         BREAK_TO_DEBUGGER();
 125         kfree(vector);
 126         return NULL;
 127 }
 128
 129 void dal_vector_destruct(
 130         struct vector *vector)
 131 {
 132         kfree(vector->container);
 133         vector->count = 0;
 134         vector->capacity = 0;
 135 }
 136
 137 void dal_vector_destroy(
 138         struct vector **vector)
 139 {
 140         if (vector == NULL || *vector == NULL)
 141                 return;
 142         dal_vector_destruct(*vector);
 143         kfree(*vector);
 144         *vector = NULL;
 145 }
 146
 147 uint32_t dal_vector_get_count(
 148         const struct vector *vector)
 149 {
 150         return vector->count;
 151 }
 152
 153 void *dal_vector_at_index(
 154         const struct vector *vector,
 155         uint32_t index)
 156 {
 157         if (vector->container == NULL || index >= vector->count)
 158                 return NULL;
 159         return vector->container + (index * vector->struct_size);
 160 }
 161
 162 bool dal_vector_remove_at_index(
 163         struct vector *vector,
 164         uint32_t index)
 165 {
 166         if (index >= vector->count)
 167                 return false;
 168
 169         if (index != vector->count - 1)
 170                 memmove(
 171                         vector->container + (index * vector->struct_size),
 172                         vector->container + ((index + 1) * vector->struct_size),
 173                         (vector->count - index - 1) * vector->struct_size);
 174         vector->count -= 1;
 175
 176         return true;
 177 }
 178
 179 void dal_vector_set_at_index(
 180         const struct vector *vector,
 181         const void *what,
 182         uint32_t index)
 183 {
 184         void *where = dal_vector_at_index(vector, index);
 185
 186         if (!where) {
 187                 BREAK_TO_DEBUGGER();
 188                 return;
 189         }
 190         memmove(
 191                 where,
 192                 what,
 193                 vector->struct_size);
 194 }
 195
 196 static inline uint32_t calc_increased_capacity(
 197         uint32_t old_capacity)
 198 {
 199         return old_capacity * 2;
 200 }
 201
 202 bool dal_vector_insert_at(
 203         struct vector *vector,
 204         const void *what,
 205         uint32_t position)
 206 {
 207         uint8_t *insert_address;
 208
 209         if (vector->count == vector->capacity) {
 210                 if (!dal_vector_reserve(
 211                         vector,
 212                         calc_increased_capacity(vector->capacity)))
 213                         return false;
 214         }
 215
 216         insert_address = vector->container + (vector->struct_size * position);
 217
 218         if (vector->count && position < vector->count)
 219                 memmove(
 220                         insert_address + vector->struct_size,
 221                         insert_address,
 222                         vector->struct_size * (vector->count - position));
 223
 224         memmove(
 225                 insert_address,
 226                 what,
 227                 vector->struct_size);
 228
 229         vector->count++;
 230
 231         return true;
 232 }
 233
 234 bool dal_vector_append(
 235         struct vector *vector,
 236         const void *item)
 237 {
 238         return dal_vector_insert_at(vector, item, vector->count);
 239 }
 240
 241 struct vector *dal_vector_clone(
 242         const struct vector *vector)
 243 {
 244         struct vector *vec_cloned;
 245         uint32_t count;
 246
 247         /* create new vector */
 248         count = dal_vector_get_count(vector);
 249
 250         if (count == 0)
 251                 /* when count is 0 we still want to create clone of the vector
 252                  */
 253                 vec_cloned = dal_vector_create(
 254                         vector->ctx,
 255                         vector->capacity,
 256                         vector->struct_size);
 257         else
 258                 /* Call "presized create" version, independently of how the
 259                  * original vector was created.
 260                  * The owner of original vector must know how to treat the new
 261                  * vector - as "presized" or as "regular".
 262                  * But from vector point of view it doesn't matter. */
 263                 vec_cloned = dal_vector_presized_create(vector->ctx, count,
 264                         NULL,/* no initial value */
 265                         vector->struct_size);
 266
 267         if (NULL == vec_cloned) {
 268                 BREAK_TO_DEBUGGER();
 269                 return NULL;
 270         }
 271
 272         /* copy vector's data */
 273         memmove(vec_cloned->container, vector->container,
 274                         vec_cloned->struct_size * vec_cloned->capacity);
 275
 276         return vec_cloned;
 277 }
 278
 279 uint32_t dal_vector_capacity(const struct vector *vector)
 280 {
 281         return vector->capacity;
 282 }
 283
 284 bool dal_vector_reserve(struct vector *vector, uint32_t capacity)
 285 {
 286         void *new_container;
 287
 288         if (capacity <= vector->capacity)
 289                 return true;
 290
 291         new_container = krealloc(vector->container,
 292                                  capacity * vector->struct_size, GFP_KERNEL);
 293
 294         if (new_container) {
 295                 vector->container = new_container;
 296                 vector->capacity = capacity;
 297                 return true;
 298         }
 299
 300         return false;
 301 }
 302
 303 void dal_vector_clear(struct vector *vector)
 304 {
 305         vector->count = 0;
 306 }