diff options
author | Vijayakumar Subbu <vsubbu@nvidia.com> | 2016-07-28 01:29:15 -0400 |
---|---|---|
committer | mobile promotions <svcmobile_promotions@nvidia.com> | 2016-09-29 16:17:46 -0400 |
commit | b17d9708c9e9930778de43de1edf1385acb13ebd (patch) | |
tree | fc485e96cc19575d463c61c8b80a09dd89745f3f /drivers/gpu/nvgpu/boardobj/boardobjgrpmask.c | |
parent | 27b47b1969d7d9cdd3de9fd6f0131ad357f4b0fa (diff) |
gpu: nvgpu: Add dGPU clocks support
JIRA DNVGPU-45
Change-Id: I237ce81e31b036c05c82d46eea8694ffe1c2e3df
Signed-off-by: Mahantesh Kumbar <mkumbar@nvidia.com>
Signed-off-by: Vijayakumar Subbu <vsubbu@nvidia.com>
Reviewed-on: http://git-master/r/1205849
(cherry picked from commit 9a4006f76b75a8ad525e7aa5ad1f609aaae49126)
Reviewed-on: http://git-master/r/1227256
Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>
Diffstat (limited to 'drivers/gpu/nvgpu/boardobj/boardobjgrpmask.c')
-rw-r--r-- | drivers/gpu/nvgpu/boardobj/boardobjgrpmask.c | 357 |
1 files changed, 357 insertions, 0 deletions
diff --git a/drivers/gpu/nvgpu/boardobj/boardobjgrpmask.c b/drivers/gpu/nvgpu/boardobj/boardobjgrpmask.c new file mode 100644 index 00000000..47914038 --- /dev/null +++ b/drivers/gpu/nvgpu/boardobj/boardobjgrpmask.c | |||
@@ -0,0 +1,357 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved. | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify it | ||
5 | * under the terms and conditions of the GNU General Public License, | ||
6 | * version 2, as published by the Free Software Foundation. | ||
7 | * | ||
8 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
9 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
10 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
11 | * more details. | ||
12 | */ | ||
13 | #include "gk20a/gk20a.h" | ||
14 | #include "boardobjgrp.h" | ||
15 | #include "ctrl/ctrlboardobj.h" | ||
16 | |||
17 | /* | ||
18 | * Assures that unused bits (size .. (maskDataCount * 32 - 1)) are always zero. | ||
19 | */ | ||
20 | #define BOARDOBJGRPMASK_NORMALIZE(_pmask) \ | ||
21 | ((_pmask)->data[(_pmask)->maskdatacount-1] &= (_pmask)->lastmaskfilter) | ||
22 | |||
23 | u32 boardobjgrpmask_init(struct boardobjgrpmask *mask, u8 bitsize, | ||
24 | struct ctrl_boardobjgrp_mask *extmask) | ||
25 | { | ||
26 | if (mask == NULL) | ||
27 | return -EINVAL; | ||
28 | if ((bitsize != CTRL_BOARDOBJGRP_E32_MAX_OBJECTS) && | ||
29 | (bitsize != CTRL_BOARDOBJGRP_E255_MAX_OBJECTS)) | ||
30 | return -EINVAL; | ||
31 | |||
32 | mask->bitcount = bitsize; | ||
33 | mask->maskdatacount = CTRL_BOARDOBJGRP_MASK_DATA_SIZE(bitsize); | ||
34 | mask->lastmaskfilter = bitsize % | ||
35 | CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_BIT_SIZE; | ||
36 | |||
37 | mask->lastmaskfilter = (mask->lastmaskfilter == 0) ? | ||
38 | 0xFFFFFFFF : (u32)(BIT(mask->lastmaskfilter) - 1); | ||
39 | |||
40 | return (extmask == NULL) ? | ||
41 | boardobjgrpmask_clr(mask) : | ||
42 | boardobjgrpmask_import(mask, bitsize, extmask); | ||
43 | } | ||
44 | |||
45 | u32 boardobjgrpmask_import(struct boardobjgrpmask *mask, u8 bitsize, | ||
46 | struct ctrl_boardobjgrp_mask *extmask) | ||
47 | { | ||
48 | u8 index; | ||
49 | |||
50 | if (mask == NULL) | ||
51 | return -EINVAL; | ||
52 | if (extmask == NULL) | ||
53 | return -EINVAL; | ||
54 | if (mask->bitcount != bitsize) | ||
55 | return -EINVAL; | ||
56 | |||
57 | for (index = 0; index < mask->maskdatacount; index++) | ||
58 | mask->data[index] = extmask->data[index]; | ||
59 | |||
60 | BOARDOBJGRPMASK_NORMALIZE(mask); | ||
61 | |||
62 | return 0; | ||
63 | } | ||
64 | |||
65 | u32 boardobjgrpmask_export(struct boardobjgrpmask *mask, u8 bitsize, | ||
66 | struct ctrl_boardobjgrp_mask *extmask) | ||
67 | { | ||
68 | u8 index; | ||
69 | |||
70 | if (mask == NULL) | ||
71 | return -EINVAL; | ||
72 | if (extmask == NULL) | ||
73 | return -EINVAL; | ||
74 | if (mask->bitcount != bitsize) | ||
75 | return -EINVAL; | ||
76 | |||
77 | for (index = 0; index < mask->maskdatacount; index++) | ||
78 | extmask->data[index] = mask->data[index]; | ||
79 | |||
80 | return 0; | ||
81 | } | ||
82 | |||
83 | u32 boardobjgrpmask_clr(struct boardobjgrpmask *mask) | ||
84 | { | ||
85 | u8 index; | ||
86 | |||
87 | if (mask == NULL) | ||
88 | return -EINVAL; | ||
89 | for (index = 0; index < mask->maskdatacount; index++) | ||
90 | mask->data[index] = 0; | ||
91 | |||
92 | return 0; | ||
93 | } | ||
94 | |||
95 | u32 boardobjgrpmask_set(struct boardobjgrpmask *mask) | ||
96 | { | ||
97 | u8 index; | ||
98 | |||
99 | if (mask == NULL) | ||
100 | return -EINVAL; | ||
101 | for (index = 0; index < mask->maskdatacount; index++) | ||
102 | mask->data[index] = 0xFFFFFFFF; | ||
103 | BOARDOBJGRPMASK_NORMALIZE(mask); | ||
104 | return 0; | ||
105 | } | ||
106 | |||
107 | u32 boardobjgrpmask_inv(struct boardobjgrpmask *mask) | ||
108 | { | ||
109 | u8 index; | ||
110 | |||
111 | if (mask == NULL) | ||
112 | return -EINVAL; | ||
113 | for (index = 0; index < mask->maskdatacount; index++) | ||
114 | mask->data[index] = ~mask->data[index]; | ||
115 | BOARDOBJGRPMASK_NORMALIZE(mask); | ||
116 | return 0; | ||
117 | } | ||
118 | |||
119 | bool boardobjgrpmask_iszero(struct boardobjgrpmask *mask) | ||
120 | { | ||
121 | u8 index; | ||
122 | |||
123 | if (mask == NULL) | ||
124 | return true; | ||
125 | for (index = 0; index < mask->maskdatacount; index++) { | ||
126 | if (mask->data[index] != 0) | ||
127 | return false; | ||
128 | } | ||
129 | return true; | ||
130 | } | ||
131 | |||
132 | u8 boardobjgrpmask_bitsetcount(struct boardobjgrpmask *mask) | ||
133 | { | ||
134 | u8 index; | ||
135 | u8 result = 0; | ||
136 | |||
137 | if (mask == NULL) | ||
138 | return result; | ||
139 | |||
140 | for (index = 0; index < mask->maskdatacount; index++) { | ||
141 | u32 m = mask->data[index]; | ||
142 | |||
143 | NUMSETBITS_32(m); | ||
144 | result += (u8)m; | ||
145 | } | ||
146 | |||
147 | return result; | ||
148 | } | ||
149 | |||
150 | u8 boardobjgrpmask_bitidxlowest(struct boardobjgrpmask *mask) | ||
151 | { | ||
152 | u8 index; | ||
153 | u8 result = CTRL_BOARDOBJ_IDX_INVALID; | ||
154 | |||
155 | if (mask == NULL) | ||
156 | return result; | ||
157 | |||
158 | for (index = 0; index < mask->maskdatacount; index++) { | ||
159 | u32 m = mask->data[index]; | ||
160 | |||
161 | if (m != 0) { | ||
162 | LOWESTBITIDX_32(m); | ||
163 | result = (u8)m + index * | ||
164 | CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_BIT_SIZE; | ||
165 | break; | ||
166 | } | ||
167 | } | ||
168 | |||
169 | return result; | ||
170 | } | ||
171 | |||
172 | u8 boardobjgrpmask_bitidxhighest(struct boardobjgrpmask *mask) | ||
173 | { | ||
174 | u8 index; | ||
175 | u8 result = CTRL_BOARDOBJ_IDX_INVALID; | ||
176 | |||
177 | if (mask == NULL) | ||
178 | return result; | ||
179 | |||
180 | for (index = 0; index < mask->maskdatacount; index++) { | ||
181 | u32 m = mask->data[index]; | ||
182 | |||
183 | if (m != 0) { | ||
184 | HIGHESTBITIDX_32(m); | ||
185 | result = (u8)m + index * | ||
186 | CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_BIT_SIZE; | ||
187 | break; | ||
188 | } | ||
189 | } | ||
190 | |||
191 | return result; | ||
192 | } | ||
193 | |||
194 | u32 boardobjgrpmask_bitclr(struct boardobjgrpmask *mask, u8 bitidx) | ||
195 | { | ||
196 | u8 index; | ||
197 | u8 offset; | ||
198 | |||
199 | if (mask == NULL) | ||
200 | return -EINVAL; | ||
201 | if (bitidx >= mask->bitcount) | ||
202 | return -EINVAL; | ||
203 | |||
204 | index = CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_INDEX(bitidx); | ||
205 | offset = CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_OFFSET(bitidx); | ||
206 | |||
207 | mask->data[index] &= ~BIT(offset); | ||
208 | |||
209 | return 0; | ||
210 | } | ||
211 | |||
212 | u32 boardobjgrpmask_bitset(struct boardobjgrpmask *mask, u8 bitidx) | ||
213 | { | ||
214 | u8 index; | ||
215 | u8 offset; | ||
216 | |||
217 | if (mask == NULL) | ||
218 | return -EINVAL; | ||
219 | if (bitidx >= mask->bitcount) | ||
220 | return -EINVAL; | ||
221 | |||
222 | index = CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_INDEX(bitidx); | ||
223 | offset = CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_OFFSET(bitidx); | ||
224 | |||
225 | mask->data[index] |= BIT(offset); | ||
226 | |||
227 | return 0; | ||
228 | } | ||
229 | |||
230 | u32 boardobjgrpmask_bitinv(struct boardobjgrpmask *mask, u8 bitidx) | ||
231 | { | ||
232 | u8 index; | ||
233 | u8 offset; | ||
234 | |||
235 | if (mask == NULL) | ||
236 | return -EINVAL; | ||
237 | if (bitidx >= mask->bitcount) | ||
238 | return -EINVAL; | ||
239 | |||
240 | index = CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_INDEX(bitidx); | ||
241 | offset = CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_OFFSET(bitidx); | ||
242 | |||
243 | mask->data[index] ^= ~BIT(offset); | ||
244 | |||
245 | return 0; | ||
246 | } | ||
247 | |||
248 | bool boardobjgrpmask_bitget(struct boardobjgrpmask *mask, u8 bitidx) | ||
249 | { | ||
250 | u8 index; | ||
251 | u8 offset; | ||
252 | |||
253 | if (mask == NULL) | ||
254 | return false; | ||
255 | if (bitidx >= mask->bitcount) | ||
256 | return false; | ||
257 | |||
258 | index = CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_INDEX(bitidx); | ||
259 | offset = CTRL_BOARDOBJGRP_MASK_MASK_ELEMENT_OFFSET(bitidx); | ||
260 | |||
261 | return (mask->data[index] & BIT(offset)) != 0; | ||
262 | } | ||
263 | |||
264 | u32 boardobjgrpmask_and(struct boardobjgrpmask *dst, | ||
265 | struct boardobjgrpmask *op1, | ||
266 | struct boardobjgrpmask *op2) | ||
267 | { | ||
268 | u8 index; | ||
269 | |||
270 | if (!boardobjgrpmask_sizeeq(dst, op1)) | ||
271 | return -EINVAL; | ||
272 | if (!boardobjgrpmask_sizeeq(dst, op2)) | ||
273 | return -EINVAL; | ||
274 | |||
275 | for (index = 0; index < dst->maskdatacount; index++) | ||
276 | dst->data[index] = op1->data[index] & op2->data[index]; | ||
277 | |||
278 | return 0; | ||
279 | } | ||
280 | |||
281 | u32 boardobjgrpmask_or(struct boardobjgrpmask *dst, | ||
282 | struct boardobjgrpmask *op1, | ||
283 | struct boardobjgrpmask *op2) | ||
284 | { | ||
285 | u8 index; | ||
286 | |||
287 | if (!boardobjgrpmask_sizeeq(dst, op1)) | ||
288 | return -EINVAL; | ||
289 | if (!boardobjgrpmask_sizeeq(dst, op2)) | ||
290 | return -EINVAL; | ||
291 | |||
292 | for (index = 0; index < dst->maskdatacount; index++) | ||
293 | dst->data[index] = op1->data[index] | op2->data[index]; | ||
294 | |||
295 | return 0; | ||
296 | } | ||
297 | |||
298 | u32 boardobjgrpmask_xor(struct boardobjgrpmask *dst, | ||
299 | struct boardobjgrpmask *op1, | ||
300 | struct boardobjgrpmask *op2) | ||
301 | { | ||
302 | u8 index; | ||
303 | |||
304 | if (!boardobjgrpmask_sizeeq(dst, op1)) | ||
305 | return -EINVAL; | ||
306 | if (!boardobjgrpmask_sizeeq(dst, op2)) | ||
307 | return -EINVAL; | ||
308 | |||
309 | for (index = 0; index < dst->maskdatacount; index++) | ||
310 | dst->data[index] = op1->data[index] ^ op2->data[index]; | ||
311 | |||
312 | return 0; | ||
313 | } | ||
314 | |||
315 | u32 boardobjgrpmask_copy(struct boardobjgrpmask *dst, | ||
316 | struct boardobjgrpmask *src) | ||
317 | { | ||
318 | u8 index; | ||
319 | |||
320 | if (!boardobjgrpmask_sizeeq(dst, src)) | ||
321 | return -EINVAL; | ||
322 | |||
323 | for (index = 0; index < dst->maskdatacount; index++) | ||
324 | dst->data[index] = src->data[index]; | ||
325 | |||
326 | return 0; | ||
327 | } | ||
328 | |||
329 | bool boardobjgrpmask_sizeeq(struct boardobjgrpmask *op1, | ||
330 | struct boardobjgrpmask *op2) | ||
331 | { | ||
332 | if (op1 == NULL) | ||
333 | return false; | ||
334 | if (op2 == NULL) | ||
335 | return false; | ||
336 | |||
337 | return op1->bitcount == op2->bitcount; | ||
338 | } | ||
339 | |||
340 | bool boardobjgrpmask_issubset(struct boardobjgrpmask *op1, | ||
341 | struct boardobjgrpmask *op2) | ||
342 | { | ||
343 | u8 index; | ||
344 | |||
345 | if (!boardobjgrpmask_sizeeq(op2, op1)) | ||
346 | return false; | ||
347 | |||
348 | for (index = 0; index < op1->maskdatacount; index++) { | ||
349 | u32 op_1 = op1->data[index]; | ||
350 | u32 op_2 = op2->data[index]; | ||
351 | |||
352 | if ((op_1 & op_2) != op_1) | ||
353 | return false; | ||
354 | } | ||
355 | |||
356 | return true; | ||
357 | } | ||