Commit | Line | Data |
---|---|---|
4562236b HW |
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 | ||
6396bb22 | 43 | vector->container = kcalloc(capacity, struct_size, GFP_KERNEL); |
4562236b HW |
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 | ||
6396bb22 | 70 | vector->container = kcalloc(count, struct_size, GFP_KERNEL); |
4562236b HW |
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 | { | |
2004f45e | 98 | struct vector *vector = kzalloc(sizeof(struct vector), GFP_KERNEL); |
4562236b HW |
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(); | |
2004f45e | 108 | kfree(vector); |
4562236b HW |
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 | { | |
2004f45e | 117 | struct vector *vector = kzalloc(sizeof(struct vector), GFP_KERNEL); |
4562236b HW |
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(); | |
2004f45e | 126 | kfree(vector); |
4562236b HW |
127 | return NULL; |
128 | } | |
129 | ||
130 | void dal_vector_destruct( | |
131 | struct vector *vector) | |
132 | { | |
d029810c | 133 | kfree(vector->container); |
4562236b HW |
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); | |
2004f45e | 144 | kfree(*vector); |
4562236b HW |
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 | ||
2004f45e HW |
292 | new_container = krealloc(vector->container, |
293 | capacity * vector->struct_size, GFP_KERNEL); | |
4562236b HW |
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 | } |