1/* radeon_mem.c -- Simple GART/fb memory manager for radeon -*- linux-c -*- */
2/*
3 * Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
4 *
5 * The Weather Channel (TM) funded Tungsten Graphics to develop the
6 * initial release of the Radeon 8500 driver under the XFree86 license.
7 * This notice must be preserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice (including the next
17 * paragraph) shall be included in all copies or substantial portions of the
18 * Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
23 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
24 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
25 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26 * DEALINGS IN THE SOFTWARE.
27 *
28 * Authors:
29 *    Keith Whitwell <keith@tungstengraphics.com>
30 */
31
32#include <sys/cdefs.h>
33__FBSDID("$FreeBSD$");
34
35#include <dev/drm2/drmP.h>
36#include <dev/drm2/radeon/radeon_drm.h>
37#include "radeon_drv.h"
38
39/* Very simple allocator for GART memory, working on a static range
40 * already mapped into each client's address space.
41 */
42
43static struct mem_block *split_block(struct mem_block *p, int start, int size,
44				     struct drm_file *file_priv)
45{
46	/* Maybe cut off the start of an existing block */
47	if (start > p->start) {
48		struct mem_block *newblock = malloc(sizeof(*newblock),
49						     DRM_MEM_DRIVER, M_WAITOK);
50		if (!newblock)
51			goto out;
52		newblock->start = start;
53		newblock->size = p->size - (start - p->start);
54		newblock->file_priv = NULL;
55		newblock->next = p->next;
56		newblock->prev = p;
57		p->next->prev = newblock;
58		p->next = newblock;
59		p->size -= newblock->size;
60		p = newblock;
61	}
62
63	/* Maybe cut off the end of an existing block */
64	if (size < p->size) {
65		struct mem_block *newblock = malloc(sizeof(*newblock),
66						     DRM_MEM_DRIVER, M_WAITOK);
67		if (!newblock)
68			goto out;
69		newblock->start = start + size;
70		newblock->size = p->size - size;
71		newblock->file_priv = NULL;
72		newblock->next = p->next;
73		newblock->prev = p;
74		p->next->prev = newblock;
75		p->next = newblock;
76		p->size = size;
77	}
78
79      out:
80	/* Our block is in the middle */
81	p->file_priv = file_priv;
82	return p;
83}
84
85static struct mem_block *alloc_block(struct mem_block *heap, int size,
86				     int align2, struct drm_file *file_priv)
87{
88	struct mem_block *p;
89	int mask = (1 << align2) - 1;
90
91	list_for_each(p, heap) {
92		int start = (p->start + mask) & ~mask;
93		if (p->file_priv == NULL && start + size <= p->start + p->size)
94			return split_block(p, start, size, file_priv);
95	}
96
97	return NULL;
98}
99
100static struct mem_block *find_block(struct mem_block *heap, int start)
101{
102	struct mem_block *p;
103
104	list_for_each(p, heap)
105	    if (p->start == start)
106		return p;
107
108	return NULL;
109}
110
111static void free_block(struct mem_block *p)
112{
113	p->file_priv = NULL;
114
115	/* Assumes a single contiguous range.  Needs a special file_priv in
116	 * 'heap' to stop it being subsumed.
117	 */
118	if (p->next->file_priv == NULL) {
119		struct mem_block *q = p->next;
120		p->size += q->size;
121		p->next = q->next;
122		p->next->prev = p;
123		free(q, DRM_MEM_DRIVER);
124	}
125
126	if (p->prev->file_priv == NULL) {
127		struct mem_block *q = p->prev;
128		q->size += p->size;
129		q->next = p->next;
130		q->next->prev = q;
131		free(p, DRM_MEM_DRIVER);
132	}
133}
134
135/* Initialize.  How to check for an uninitialized heap?
136 */
137static int init_heap(struct mem_block **heap, int start, int size)
138{
139	struct mem_block *blocks = malloc(sizeof(*blocks),
140	    DRM_MEM_DRIVER, M_WAITOK);
141
142	if (!blocks)
143		return -ENOMEM;
144
145	*heap = malloc(sizeof(**heap), DRM_MEM_DRIVER, M_ZERO | M_WAITOK);
146	if (!*heap) {
147		free(blocks, DRM_MEM_DRIVER);
148		return -ENOMEM;
149	}
150
151	blocks->start = start;
152	blocks->size = size;
153	blocks->file_priv = NULL;
154	blocks->next = blocks->prev = *heap;
155
156	(*heap)->file_priv = (struct drm_file *) - 1;
157	(*heap)->next = (*heap)->prev = blocks;
158	return 0;
159}
160
161/* Free all blocks associated with the releasing file.
162 */
163void radeon_mem_release(struct drm_file *file_priv, struct mem_block *heap)
164{
165	struct mem_block *p;
166
167	if (!heap || !heap->next)
168		return;
169
170	list_for_each(p, heap) {
171		if (p->file_priv == file_priv)
172			p->file_priv = NULL;
173	}
174
175	/* Assumes a single contiguous range.  Needs a special file_priv in
176	 * 'heap' to stop it being subsumed.
177	 */
178	list_for_each(p, heap) {
179		while (p->file_priv == NULL && p->next->file_priv == NULL) {
180			struct mem_block *q = p->next;
181			p->size += q->size;
182			p->next = q->next;
183			p->next->prev = p;
184			free(q, DRM_MEM_DRIVER);
185		}
186	}
187}
188
189/* Shutdown.
190 */
191void radeon_mem_takedown(struct mem_block **heap)
192{
193	struct mem_block *p;
194
195	if (!*heap)
196		return;
197
198	for (p = (*heap)->next; p != *heap;) {
199		struct mem_block *q = p;
200		p = p->next;
201		free(q, DRM_MEM_DRIVER);
202	}
203
204	free(*heap, DRM_MEM_DRIVER);
205	*heap = NULL;
206}
207
208/* IOCTL HANDLERS */
209
210static struct mem_block **get_heap(drm_radeon_private_t * dev_priv, int region)
211{
212	switch (region) {
213	case RADEON_MEM_REGION_GART:
214		return &dev_priv->gart_heap;
215	case RADEON_MEM_REGION_FB:
216		return &dev_priv->fb_heap;
217	default:
218		return NULL;
219	}
220}
221
222int radeon_mem_alloc(struct drm_device *dev, void *data, struct drm_file *file_priv)
223{
224	drm_radeon_private_t *dev_priv = dev->dev_private;
225	drm_radeon_mem_alloc_t *alloc = data;
226	struct mem_block *block, **heap;
227
228	if (!dev_priv) {
229		DRM_ERROR("called with no initialization\n");
230		return -EINVAL;
231	}
232
233	heap = get_heap(dev_priv, alloc->region);
234	if (!heap || !*heap)
235		return -EFAULT;
236
237	/* Make things easier on ourselves: all allocations at least
238	 * 4k aligned.
239	 */
240	if (alloc->alignment < 12)
241		alloc->alignment = 12;
242
243	block = alloc_block(*heap, alloc->size, alloc->alignment, file_priv);
244
245	if (!block)
246		return -ENOMEM;
247
248	if (DRM_COPY_TO_USER(alloc->region_offset, &block->start,
249			     sizeof(int))) {
250		DRM_ERROR("copy_to_user\n");
251		return -EFAULT;
252	}
253
254	return 0;
255}
256
257int radeon_mem_free(struct drm_device *dev, void *data, struct drm_file *file_priv)
258{
259	drm_radeon_private_t *dev_priv = dev->dev_private;
260	drm_radeon_mem_free_t *memfree = data;
261	struct mem_block *block, **heap;
262
263	if (!dev_priv) {
264		DRM_ERROR("called with no initialization\n");
265		return -EINVAL;
266	}
267
268	heap = get_heap(dev_priv, memfree->region);
269	if (!heap || !*heap)
270		return -EFAULT;
271
272	block = find_block(*heap, memfree->region_offset);
273	if (!block)
274		return -EFAULT;
275
276	if (block->file_priv != file_priv)
277		return -EPERM;
278
279	free_block(block);
280	return 0;
281}
282
283int radeon_mem_init_heap(struct drm_device *dev, void *data, struct drm_file *file_priv)
284{
285	drm_radeon_private_t *dev_priv = dev->dev_private;
286	drm_radeon_mem_init_heap_t *initheap = data;
287	struct mem_block **heap;
288
289	if (!dev_priv) {
290		DRM_ERROR("called with no initialization\n");
291		return -EINVAL;
292	}
293
294	heap = get_heap(dev_priv, initheap->region);
295	if (!heap)
296		return -EFAULT;
297
298	if (*heap) {
299		DRM_ERROR("heap already initialized?");
300		return -EFAULT;
301	}
302
303	return init_heap(heap, initheap->start, initheap->size);
304}
305