Commit | Line | Data |
---|---|---|
71e8831f | 1 | /* |
71e8831f AG |
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 | ||
238083ad AG |
60 | unsigned int y_offset; /* offset to use for y coordinates */ |
61 | ||
0d6fa53f AG |
62 | spinlock_t lock; |
63 | unsigned long *bitmap; | |
64 | size_t map_size; | |
71e8831f AG |
65 | |
66 | /* function table */ | |
0d6fa53f | 67 | s32 (*reserve_2d)(struct tcm *tcm, u16 height, u16 width, u16 align, |
dfe9cfcc | 68 | s16 offset, u16 slot_bytes, |
71e8831f AG |
69 | struct tcm_area *area); |
70 | s32 (*reserve_1d)(struct tcm *tcm, u32 slots, struct tcm_area *area); | |
0d6fa53f AG |
71 | s32 (*free)(struct tcm *tcm, struct tcm_area *area); |
72 | void (*deinit)(struct tcm *tcm); | |
71e8831f AG |
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 | ||
0d6fa53f | 91 | struct tcm *sita_init(u16 width, u16 height); |
71e8831f AG |
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. | |
0d6fa53f AG |
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 | |
71e8831f AG |
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, | |
dfe9cfcc | 132 | u16 align, s16 offset, u16 slot_bytes, |
0d6fa53f | 133 | struct tcm_area *area) |
71e8831f AG |
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; | |
0d6fa53f AG |
144 | res = tcm->reserve_2d(tcm, height, width, align, offset, |
145 | slot_bytes, area); | |
71e8831f AG |
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(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 |