1 | /* |
2 | * TILER container manager specification and support functions for TI |
3 | * TILER driver. |
4 | * |
5 | * Author: Lajos Molnar <molnar@ti.com> |
6 | * |
7 | * All rights reserved. |
8 | * |
9 | * Redistribution and use in source and binary forms, with or without |
10 | * modification, are permitted provided that the following conditions |
11 | * are met: |
12 | * |
13 | * * Redistributions of source code must retain the above copyright |
14 | * notice, this list of conditions and the following disclaimer. |
15 | * |
16 | * * Redistributions in binary form must reproduce the above copyright |
17 | * notice, this list of conditions and the following disclaimer in the |
18 | * documentation and/or other materials provided with the distribution. |
19 | * |
20 | * * Neither the name of Texas Instruments Incorporated nor the names of |
21 | * its contributors may be used to endorse or promote products derived |
22 | * from this software without specific prior written permission. |
23 | * |
24 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
25 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
26 | * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
27 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
28 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
29 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
30 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
31 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
32 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
33 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
34 | * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
35 | */ |
36 | |
37 | #ifndef TCM_H |
38 | #define TCM_H |
39 | |
40 | struct tcm; |
41 | |
42 | /* point */ |
43 | struct tcm_pt { |
44 | u16 x; |
45 | u16 y; |
46 | }; |
47 | |
48 | /* 1d or 2d area */ |
49 | struct tcm_area { |
50 | bool is2d; /* whether area is 1d or 2d */ |
51 | struct tcm *tcm; /* parent */ |
52 | struct tcm_pt p0; |
53 | struct tcm_pt p1; |
54 | }; |
55 | |
56 | struct tcm { |
57 | u16 width, height; /* container dimensions */ |
58 | int lut_id; /* Lookup table identifier */ |
59 | |
60 | unsigned int y_offset; /* offset to use for y coordinates */ |
61 | |
62 | spinlock_t lock; |
63 | unsigned long *bitmap; |
64 | size_t map_size; |
65 | |
66 | /* function table */ |
67 | s32 (*reserve_2d)(struct tcm *tcm, u16 height, u16 width, u16 align, |
68 | s16 offset, u16 slot_bytes, |
69 | struct tcm_area *area); |
70 | s32 (*reserve_1d)(struct tcm *tcm, u32 slots, struct tcm_area *area); |
71 | s32 (*free)(struct tcm *tcm, struct tcm_area *area); |
72 | void (*deinit)(struct tcm *tcm); |
73 | }; |
74 | |
75 | /*============================================================================= |
76 | BASIC TILER CONTAINER MANAGER INTERFACE |
77 | =============================================================================*/ |
78 | |
79 | /* |
80 | * NOTE: |
81 | * |
82 | * Since some basic parameter checking is done outside the TCM algorithms, |
83 | * TCM implementation do NOT have to check the following: |
84 | * |
85 | * area pointer is NULL |
86 | * width and height fits within container |
87 | * number of pages is more than the size of the container |
88 | * |
89 | */ |
90 | |
91 | struct tcm *sita_init(u16 width, u16 height); |
92 | |
93 | |
94 | /** |
95 | * Deinitialize tiler container manager. |
96 | * |
97 | * @param tcm Pointer to container manager. |
98 | * |
99 | * @return 0 on success, non-0 error value on error. The call |
100 | * should free as much memory as possible and meaningful |
101 | * even on failure. Some error codes: -ENODEV: invalid |
102 | * manager. |
103 | */ |
104 | static inline void tcm_deinit(struct tcm *tcm) |
105 | { |
106 | if (tcm) |
107 | tcm->deinit(tcm); |
108 | } |
109 | |
110 | /** |
111 | * Reserves a 2D area in the container. |
112 | * |
113 | * @param tcm Pointer to container manager. |
114 | * @param height Height(in pages) of area to be reserved. |
115 | * @param width Width(in pages) of area to be reserved. |
116 | * @param align Alignment requirement for top-left corner of area. Not |
117 | * all values may be supported by the container manager, |
118 | * but it must support 0 (1), 32 and 64. |
119 | * 0 value is equivalent to 1. |
120 | * @param offset Offset requirement, in bytes. This is the offset |
121 | * from a 4KiB aligned virtual address. |
122 | * @param slot_bytes Width of slot in bytes |
123 | * @param area Pointer to where the reserved area should be stored. |
124 | * |
125 | * @return 0 on success. Non-0 error code on failure. Also, |
126 | * the tcm field of the area will be set to NULL on |
127 | * failure. Some error codes: -ENODEV: invalid manager, |
128 | * -EINVAL: invalid area, -ENOMEM: not enough space for |
129 | * allocation. |
130 | */ |
131 | static inline s32 tcm_reserve_2d(struct tcm *tcm, u16 width, u16 height, |
132 | u16 align, s16 offset, u16 slot_bytes, |
133 | struct tcm_area *area) |
134 | { |
135 | /* perform rudimentary error checking */ |
136 | s32 res = tcm == NULL ? -ENODEV : |
137 | (area == NULL || width == 0 || height == 0 || |
138 | /* align must be a 2 power */ |
139 | (align & (align - 1))) ? -EINVAL : |
140 | (height > tcm->height || width > tcm->width) ? -ENOMEM : 0; |
141 | |
142 | if (!res) { |
143 | area->is2d = true; |
144 | res = tcm->reserve_2d(tcm, height, width, align, offset, |
145 | slot_bytes, area); |
146 | area->tcm = res ? NULL : tcm; |
147 | } |
148 | |
149 | return res; |
150 | } |
151 | |
152 | /** |
153 | * Reserves a 1D area in the container. |
154 | * |
155 | * @param tcm Pointer to container manager. |
156 | * @param slots Number of (contiguous) slots to reserve. |
157 | * @param area Pointer to where the reserved area should be stored. |
158 | * |
159 | * @return 0 on success. Non-0 error code on failure. Also, |
160 | * the tcm field of the area will be set to NULL on |
161 | * failure. Some error codes: -ENODEV: invalid manager, |
162 | * -EINVAL: invalid area, -ENOMEM: not enough space for |
163 | * allocation. |
164 | */ |
165 | static inline s32 tcm_reserve_1d(struct tcm *tcm, u32 slots, |
166 | struct tcm_area *area) |
167 | { |
168 | /* perform rudimentary error checking */ |
169 | s32 res = tcm == NULL ? -ENODEV : |
170 | (area == NULL || slots == 0) ? -EINVAL : |
171 | slots > (tcm->width * (u32) tcm->height) ? -ENOMEM : 0; |
172 | |
173 | if (!res) { |
174 | area->is2d = false; |
175 | res = tcm->reserve_1d(tcm, slots, area); |
176 | area->tcm = res ? NULL : tcm; |
177 | } |
178 | |
179 | return res; |
180 | } |
181 | |
182 | /** |
183 | * Free a previously reserved area from the container. |
184 | * |
185 | * @param area Pointer to area reserved by a prior call to |
186 | * tcm_reserve_1d or tcm_reserve_2d call, whether |
187 | * it was successful or not. (Note: all fields of |
188 | * the structure must match.) |
189 | * |
190 | * @return 0 on success. Non-0 error code on failure. Also, the tcm |
191 | * field of the area is set to NULL on success to avoid subsequent |
192 | * freeing. This call will succeed even if supplying |
193 | * the area from a failed reserved call. |
194 | */ |
195 | static inline s32 tcm_free(struct tcm_area *area) |
196 | { |
197 | s32 res = 0; /* free succeeds by default */ |
198 | |
199 | if (area && area->tcm) { |
200 | res = area->tcm->free(area->tcm, area); |
201 | if (res == 0) |
202 | area->tcm = NULL; |
203 | } |
204 | |
205 | return res; |
206 | } |
207 | |
208 | /*============================================================================= |
209 | HELPER FUNCTION FOR ANY TILER CONTAINER MANAGER |
210 | =============================================================================*/ |
211 | |
212 | /** |
213 | * This method slices off the topmost 2D slice from the parent area, and stores |
214 | * it in the 'slice' parameter. The 'parent' parameter will get modified to |
215 | * contain the remaining portion of the area. If the whole parent area can |
216 | * fit in a 2D slice, its tcm pointer is set to NULL to mark that it is no |
217 | * longer a valid area. |
218 | * |
219 | * @param parent Pointer to a VALID parent area that will get modified |
220 | * @param slice Pointer to the slice area that will get modified |
221 | */ |
222 | static inline void tcm_slice(struct tcm_area *parent, struct tcm_area *slice) |
223 | { |
224 | *slice = *parent; |
225 | |
226 | /* check if we need to slice */ |
227 | if (slice->tcm && !slice->is2d && |
228 | slice->p0.y != slice->p1.y && |
229 | (slice->p0.x || (slice->p1.x != slice->tcm->width - 1))) { |
230 | /* set end point of slice (start always remains) */ |
231 | slice->p1.x = slice->tcm->width - 1; |
232 | slice->p1.y = (slice->p0.x) ? slice->p0.y : slice->p1.y - 1; |
233 | /* adjust remaining area */ |
234 | parent->p0.x = 0; |
235 | parent->p0.y = slice->p1.y + 1; |
236 | } else { |
237 | /* mark this as the last slice */ |
238 | parent->tcm = NULL; |
239 | } |
240 | } |
241 | |
242 | /* Verify if a tcm area is logically valid */ |
243 | static inline bool tcm_area_is_valid(struct tcm_area *area) |
244 | { |
245 | return area && area->tcm && |
246 | /* coordinate bounds */ |
247 | area->p1.x < area->tcm->width && |
248 | area->p1.y < area->tcm->height && |
249 | area->p0.y <= area->p1.y && |
250 | /* 1D coordinate relationship + p0.x check */ |
251 | ((!area->is2d && |
252 | area->p0.x < area->tcm->width && |
253 | area->p0.x + area->p0.y * area->tcm->width <= |
254 | area->p1.x + area->p1.y * area->tcm->width) || |
255 | /* 2D coordinate relationship */ |
256 | (area->is2d && |
257 | area->p0.x <= area->p1.x)); |
258 | } |
259 | |
260 | /* see if a coordinate is within an area */ |
261 | static inline bool __tcm_is_in(struct tcm_pt *p, struct tcm_area *a) |
262 | { |
263 | u16 i; |
264 | |
265 | if (a->is2d) { |
266 | return p->x >= a->p0.x && p->x <= a->p1.x && |
267 | p->y >= a->p0.y && p->y <= a->p1.y; |
268 | } else { |
269 | i = p->x + p->y * a->tcm->width; |
270 | return i >= a->p0.x + a->p0.y * a->tcm->width && |
271 | i <= a->p1.x + a->p1.y * a->tcm->width; |
272 | } |
273 | } |
274 | |
275 | /* calculate area width */ |
276 | static inline u16 __tcm_area_width(struct tcm_area *area) |
277 | { |
278 | return area->p1.x - area->p0.x + 1; |
279 | } |
280 | |
281 | /* calculate area height */ |
282 | static inline u16 __tcm_area_height(struct tcm_area *area) |
283 | { |
284 | return area->p1.y - area->p0.y + 1; |
285 | } |
286 | |
287 | /* calculate number of slots in an area */ |
288 | static inline u16 __tcm_sizeof(struct tcm_area *area) |
289 | { |
290 | return area->is2d ? |
291 | __tcm_area_width(area) * __tcm_area_height(area) : |
292 | (area->p1.x - area->p0.x + 1) + (area->p1.y - area->p0.y) * |
293 | area->tcm->width; |
294 | } |
295 | #define tcm_sizeof(area) __tcm_sizeof(&(area)) |
296 | #define tcm_awidth(area) __tcm_area_width(&(area)) |
297 | #define tcm_aheight(area) __tcm_area_height(&(area)) |
298 | #define tcm_is_in(pt, area) __tcm_is_in(&(pt), &(area)) |
299 | |
300 | /* limit a 1D area to the first N pages */ |
301 | static inline s32 tcm_1d_limit(struct tcm_area *a, u32 num_pg) |
302 | { |
303 | if (__tcm_sizeof(area: a) < num_pg) |
304 | return -ENOMEM; |
305 | if (!num_pg) |
306 | return -EINVAL; |
307 | |
308 | a->p1.x = (a->p0.x + num_pg - 1) % a->tcm->width; |
309 | a->p1.y = a->p0.y + ((a->p0.x + num_pg - 1) / a->tcm->width); |
310 | return 0; |
311 | } |
312 | |
313 | /** |
314 | * Iterate through 2D slices of a valid area. Behaves |
315 | * syntactically as a for(;;) statement. |
316 | * |
317 | * @param var Name of a local variable of type 'struct |
318 | * tcm_area *' that will get modified to |
319 | * contain each slice. |
320 | * @param area Pointer to the VALID parent area. This |
321 | * structure will not get modified |
322 | * throughout the loop. |
323 | * |
324 | */ |
325 | #define tcm_for_each_slice(var, area, safe) \ |
326 | for (safe = area, \ |
327 | tcm_slice(&safe, &var); \ |
328 | var.tcm; tcm_slice(&safe, &var)) |
329 | |
330 | #endif |
331 | |