Sync with HEAD.
[dragonfly.git] / sys / dev / drm / sis_ds.c
blob623fa0e2c9795cfd525ec26e3dce8980f2ed6de3
1 /* sis_ds.c -- Private header for Direct Rendering Manager -*- linux-c -*-
2 * Created: Mon Jan 4 10:05:05 1999 by sclin@sis.com.tw
4 * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
5 * All rights reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
16 * Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
22 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24 * DEALINGS IN THE SOFTWARE.
26 * Authors:
27 * Sung-Ching Lin <sclin@sis.com.tw>
29 * $DragonFly: src/sys/dev/drm/sis_ds.c,v 1.1 2008/04/05 18:12:29 hasso Exp $
32 #include "drmP.h"
33 #include "drm.h"
34 #include "sis_ds.h"
36 /* Set Data Structure, not check repeated value
37 * temporarily used
40 set_t *setInit(void)
42 int i;
43 set_t *set;
45 set = (set_t *) drm_alloc(sizeof(set_t), DRM_MEM_DRIVER);
46 if (set != NULL) {
47 for (i = 0; i < SET_SIZE; i++) {
48 set->list[i].free_next = i + 1;
49 set->list[i].alloc_next = -1;
51 set->list[SET_SIZE - 1].free_next = -1;
52 set->free = 0;
53 set->alloc = -1;
54 set->trace = -1;
56 return set;
59 int setAdd(set_t * set, ITEM_TYPE item)
61 int free = set->free;
63 if (free != -1) {
64 set->list[free].val = item;
65 set->free = set->list[free].free_next;
66 } else {
67 return 0;
70 set->list[free].alloc_next = set->alloc;
71 set->alloc = free;
72 set->list[free].free_next = -1;
74 return 1;
77 int setDel(set_t * set, ITEM_TYPE item)
79 int alloc = set->alloc;
80 int prev = -1;
82 while (alloc != -1) {
83 if (set->list[alloc].val == item) {
84 if (prev != -1)
85 set->list[prev].alloc_next =
86 set->list[alloc].alloc_next;
87 else
88 set->alloc = set->list[alloc].alloc_next;
89 break;
91 prev = alloc;
92 alloc = set->list[alloc].alloc_next;
95 if (alloc == -1)
96 return 0;
98 set->list[alloc].free_next = set->free;
99 set->free = alloc;
100 set->list[alloc].alloc_next = -1;
102 return 1;
105 /* setFirst -> setAdd -> setNext is wrong */
107 int setFirst(set_t * set, ITEM_TYPE * item)
109 if (set->alloc == -1)
110 return 0;
112 *item = set->list[set->alloc].val;
113 set->trace = set->list[set->alloc].alloc_next;
115 return 1;
118 int setNext(set_t * set, ITEM_TYPE * item)
120 if (set->trace == -1)
121 return 0;
123 *item = set->list[set->trace].val;
124 set->trace = set->list[set->trace].alloc_next;
126 return 1;
129 int setDestroy(set_t * set)
131 drm_free(set, sizeof(set_t), DRM_MEM_DRIVER);
133 return 1;
137 * GLX Hardware Device Driver common code
138 * Copyright (C) 1999 Wittawat Yamwong
140 * Permission is hereby granted, free of charge, to any person obtaining a
141 * copy of this software and associated documentation files (the "Software"),
142 * to deal in the Software without restriction, including without limitation
143 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
144 * and/or sell copies of the Software, and to permit persons to whom the
145 * Software is furnished to do so, subject to the following conditions:
147 * The above copyright notice and this permission notice shall be included
148 * in all copies or substantial portions of the Software.
150 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
151 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
152 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
153 * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
154 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
155 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
156 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
160 #define ISFREE(bptr) ((bptr)->free)
162 memHeap_t *mmInit(int ofs, int size)
164 PMemBlock blocks;
166 if (size <= 0)
167 return NULL;
169 blocks = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock), DRM_MEM_DRIVER);
170 if (blocks != NULL) {
171 blocks->ofs = ofs;
172 blocks->size = size;
173 blocks->free = 1;
174 return (memHeap_t *) blocks;
175 } else
176 return NULL;
179 /* Checks if a pointer 'b' is part of the heap 'heap' */
180 int mmBlockInHeap(memHeap_t * heap, PMemBlock b)
182 TMemBlock *p;
184 if (heap == NULL || b == NULL)
185 return 0;
187 p = heap;
188 while (p != NULL && p != b) {
189 p = p->next;
191 if (p == b)
192 return 1;
193 else
194 return 0;
197 static TMemBlock *SliceBlock(TMemBlock * p,
198 int startofs, int size,
199 int reserved, int alignment)
201 TMemBlock *newblock;
203 /* break left */
204 if (startofs > p->ofs) {
205 newblock = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
206 DRM_MEM_DRIVER);
207 newblock->ofs = startofs;
208 newblock->size = p->size - (startofs - p->ofs);
209 newblock->free = 1;
210 newblock->next = p->next;
211 p->size -= newblock->size;
212 p->next = newblock;
213 p = newblock;
216 /* break right */
217 if (size < p->size) {
218 newblock = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
219 DRM_MEM_DRIVER);
220 newblock->ofs = startofs + size;
221 newblock->size = p->size - size;
222 newblock->free = 1;
223 newblock->next = p->next;
224 p->size = size;
225 p->next = newblock;
228 /* p = middle block */
229 p->align = alignment;
230 p->free = 0;
231 p->reserved = reserved;
232 return p;
235 PMemBlock mmAllocMem(memHeap_t * heap, int size, int align2, int startSearch)
237 int mask, startofs, endofs;
238 TMemBlock *p;
240 if (heap == NULL || align2 < 0 || size <= 0)
241 return NULL;
243 mask = (1 << align2) - 1;
244 startofs = 0;
245 p = (TMemBlock *) heap;
246 while (p != NULL) {
247 if (ISFREE(p)) {
248 startofs = (p->ofs + mask) & ~mask;
249 if (startofs < startSearch) {
250 startofs = startSearch;
252 endofs = startofs + size;
253 if (endofs <= (p->ofs + p->size))
254 break;
256 p = p->next;
258 if (p == NULL)
259 return NULL;
260 p = SliceBlock(p, startofs, size, 0, mask + 1);
261 p->heap = heap;
262 return p;
265 static __inline__ int Join2Blocks(TMemBlock * p)
267 if (p->free && p->next && p->next->free) {
268 TMemBlock *q = p->next;
269 p->size += q->size;
270 p->next = q->next;
271 drm_free(q, sizeof(TMemBlock), DRM_MEM_DRIVER);
272 return 1;
274 return 0;
277 int mmFreeMem(PMemBlock b)
279 TMemBlock *p, *prev;
281 if (b == NULL)
282 return 0;
283 if (b->heap == NULL)
284 return -1;
286 p = b->heap;
287 prev = NULL;
288 while (p != NULL && p != b) {
289 prev = p;
290 p = p->next;
292 if (p == NULL || p->free || p->reserved)
293 return -1;
295 p->free = 1;
296 Join2Blocks(p);
297 if (prev)
298 Join2Blocks(prev);
299 return 0;