1 /* i915_mem.c -- Simple agp/fb memory manager for i915 -*- linux-c -*-
3 /**************************************************************************
5 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the
10 * "Software"), to deal in the Software without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sub license, and/or sell copies of the Software, and to
13 * permit persons to whom the Software is furnished to do so, subject to
14 * the following conditions:
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial portions
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
23 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
24 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 **************************************************************************/
35 /* This memory manager is integrated into the global/local lru
36 * mechanisms used by the clients. Specifically, it operates by
37 * setting the 'in_use' fields of the global LRU to indicate whether
38 * this region is privately allocated to a client.
40 * This does require the client to actually respect that field.
42 * Currently no effort is made to allocate 'private' memory in any
43 * clever way - the LRU information isn't used to determine which
44 * block to allocate, and the ring is drained prior to allocations --
45 * in other words allocation is expensive.
47 static void mark_block(drm_device_t
* dev
, struct mem_block
*p
, int in_use
)
49 drm_i915_private_t
*dev_priv
= dev
->dev_private
;
50 drm_i915_sarea_t
*sarea_priv
= dev_priv
->sarea_priv
;
51 drm_tex_region_t
*list
;
58 shift
= dev_priv
->tex_lru_log_granularity
;
59 nr
= I915_NR_TEX_REGIONS
;
61 start
= p
->start
>> shift
;
62 end
= (p
->start
+ p
->size
- 1) >> shift
;
64 age
= ++sarea_priv
->texAge
;
65 list
= sarea_priv
->texList
;
67 /* Mark the regions with the new flag and update their age. Move
68 * them to head of list to preserve LRU semantics.
70 for (i
= start
; i
<= end
; i
++) {
71 list
[i
].in_use
= in_use
;
74 /* remove_from_list(i)
76 list
[(unsigned)list
[i
].next
].prev
= list
[i
].prev
;
77 list
[(unsigned)list
[i
].prev
].next
= list
[i
].next
;
79 /* insert_at_head(list, i)
82 list
[i
].next
= list
[nr
].next
;
83 list
[(unsigned)list
[nr
].next
].prev
= i
;
88 /* Very simple allocator for agp memory, working on a static range
89 * already mapped into each client's address space.
92 static struct mem_block
*split_block(struct mem_block
*p
, int start
, int size
,
95 /* Maybe cut off the start of an existing block */
96 if (start
> p
->start
) {
97 struct mem_block
*newblock
=
98 drm_alloc(sizeof(*newblock
), DRM_MEM_BUFLISTS
);
101 newblock
->start
= start
;
102 newblock
->size
= p
->size
- (start
- p
->start
);
103 newblock
->filp
= NULL
;
104 newblock
->next
= p
->next
;
106 p
->next
->prev
= newblock
;
108 p
->size
-= newblock
->size
;
112 /* Maybe cut off the end of an existing block */
113 if (size
< p
->size
) {
114 struct mem_block
*newblock
=
115 drm_alloc(sizeof(*newblock
), DRM_MEM_BUFLISTS
);
118 newblock
->start
= start
+ size
;
119 newblock
->size
= p
->size
- size
;
120 newblock
->filp
= NULL
;
121 newblock
->next
= p
->next
;
123 p
->next
->prev
= newblock
;
129 /* Our block is in the middle */
134 static struct mem_block
*alloc_block(struct mem_block
*heap
, int size
,
135 int align2
, DRMFILE filp
)
138 int mask
= (1 << align2
) - 1;
140 for (p
= heap
->next
; p
!= heap
; p
= p
->next
) {
141 int start
= (p
->start
+ mask
) & ~mask
;
142 if (p
->filp
== NULL
&& start
+ size
<= p
->start
+ p
->size
)
143 return split_block(p
, start
, size
, filp
);
149 static struct mem_block
*find_block(struct mem_block
*heap
, int start
)
153 for (p
= heap
->next
; p
!= heap
; p
= p
->next
)
154 if (p
->start
== start
)
160 static void free_block(struct mem_block
*p
)
164 /* Assumes a single contiguous range. Needs a special filp in
165 * 'heap' to stop it being subsumed.
167 if (p
->next
->filp
== NULL
) {
168 struct mem_block
*q
= p
->next
;
172 drm_free(q
, sizeof(*q
), DRM_MEM_BUFLISTS
);
175 if (p
->prev
->filp
== NULL
) {
176 struct mem_block
*q
= p
->prev
;
180 drm_free(p
, sizeof(*q
), DRM_MEM_BUFLISTS
);
184 /* Initialize. How to check for an uninitialized heap?
186 static int init_heap(struct mem_block
**heap
, int start
, int size
)
188 struct mem_block
*blocks
= drm_alloc(sizeof(*blocks
), DRM_MEM_BUFLISTS
);
193 *heap
= drm_alloc(sizeof(**heap
), DRM_MEM_BUFLISTS
);
195 drm_free(blocks
, sizeof(*blocks
), DRM_MEM_BUFLISTS
);
199 blocks
->start
= start
;
202 blocks
->next
= blocks
->prev
= *heap
;
204 memset(*heap
, 0, sizeof(**heap
));
205 (*heap
)->filp
= (DRMFILE
) - 1;
206 (*heap
)->next
= (*heap
)->prev
= blocks
;
210 /* Free all blocks associated with the releasing file.
212 void i915_mem_release(drm_device_t
* dev
, DRMFILE filp
, struct mem_block
*heap
)
216 if (!heap
|| !heap
->next
)
219 for (p
= heap
->next
; p
!= heap
; p
= p
->next
) {
220 if (p
->filp
== filp
) {
222 mark_block(dev
, p
, 0);
226 /* Assumes a single contiguous range. Needs a special filp in
227 * 'heap' to stop it being subsumed.
229 for (p
= heap
->next
; p
!= heap
; p
= p
->next
) {
230 while (p
->filp
== NULL
&& p
->next
->filp
== NULL
) {
231 struct mem_block
*q
= p
->next
;
235 drm_free(q
, sizeof(*q
), DRM_MEM_BUFLISTS
);
242 void i915_mem_takedown(struct mem_block
**heap
)
249 for (p
= (*heap
)->next
; p
!= *heap
;) {
250 struct mem_block
*q
= p
;
252 drm_free(q
, sizeof(*q
), DRM_MEM_BUFLISTS
);
255 drm_free(*heap
, sizeof(**heap
), DRM_MEM_BUFLISTS
);
259 static struct mem_block
**get_heap(drm_i915_private_t
* dev_priv
, int region
)
262 case I915_MEM_REGION_AGP
:
263 return &dev_priv
->agp_heap
;
271 int i915_mem_alloc(DRM_IOCTL_ARGS
)
274 drm_i915_private_t
*dev_priv
= dev
->dev_private
;
275 drm_i915_mem_alloc_t alloc
;
276 struct mem_block
*block
, **heap
;
279 DRM_ERROR("%s called with no initialization\n", __FUNCTION__
);
280 return DRM_ERR(EINVAL
);
283 DRM_COPY_FROM_USER_IOCTL(alloc
, (drm_i915_mem_alloc_t __user
*) data
,
286 heap
= get_heap(dev_priv
, alloc
.region
);
288 return DRM_ERR(EFAULT
);
290 /* Make things easier on ourselves: all allocations at least
293 if (alloc
.alignment
< 12)
294 alloc
.alignment
= 12;
296 block
= alloc_block(*heap
, alloc
.size
, alloc
.alignment
, filp
);
299 return DRM_ERR(ENOMEM
);
301 mark_block(dev
, block
, 1);
303 if (DRM_COPY_TO_USER(alloc
.region_offset
, &block
->start
, sizeof(int))) {
304 DRM_ERROR("copy_to_user\n");
305 return DRM_ERR(EFAULT
);
311 int i915_mem_free(DRM_IOCTL_ARGS
)
314 drm_i915_private_t
*dev_priv
= dev
->dev_private
;
315 drm_i915_mem_free_t memfree
;
316 struct mem_block
*block
, **heap
;
319 DRM_ERROR("%s called with no initialization\n", __FUNCTION__
);
320 return DRM_ERR(EINVAL
);
323 DRM_COPY_FROM_USER_IOCTL(memfree
, (drm_i915_mem_free_t __user
*) data
,
326 heap
= get_heap(dev_priv
, memfree
.region
);
328 return DRM_ERR(EFAULT
);
330 block
= find_block(*heap
, memfree
.region_offset
);
332 return DRM_ERR(EFAULT
);
334 if (block
->filp
!= filp
)
335 return DRM_ERR(EPERM
);
337 mark_block(dev
, block
, 0);
342 int i915_mem_init_heap(DRM_IOCTL_ARGS
)
345 drm_i915_private_t
*dev_priv
= dev
->dev_private
;
346 drm_i915_mem_init_heap_t initheap
;
347 struct mem_block
**heap
;
350 DRM_ERROR("%s called with no initialization\n", __FUNCTION__
);
351 return DRM_ERR(EINVAL
);
354 DRM_COPY_FROM_USER_IOCTL(initheap
,
355 (drm_i915_mem_init_heap_t __user
*) data
,
358 heap
= get_heap(dev_priv
, initheap
.region
);
360 return DRM_ERR(EFAULT
);
363 DRM_ERROR("heap already initialized?");
364 return DRM_ERR(EFAULT
);
367 return init_heap(heap
, initheap
.start
, initheap
.size
);