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