Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
| 3 | * |
| 4 | * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan. |
| 5 | * All rights reserved. |
| 6 | * |
| 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: |
| 13 | * |
| 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. |
| 17 | * |
| 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. |
| 25 | * |
| 26 | * Authors: |
| 27 | * Sung-Ching Lin <sclin@sis.com.tw> |
| 28 | * |
| 29 | */ |
| 30 | |
| 31 | #include "drmP.h" |
| 32 | #include "drm.h" |
| 33 | #include "sis_ds.h" |
| 34 | |
| 35 | /* Set Data Structure, not check repeated value |
| 36 | * temporarily used |
| 37 | */ |
| 38 | |
| 39 | set_t *setInit(void) |
| 40 | { |
| 41 | int i; |
| 42 | set_t *set; |
| 43 | |
| 44 | set = (set_t *)drm_alloc(sizeof(set_t), DRM_MEM_DRIVER); |
| 45 | if (set != NULL) { |
| 46 | for (i = 0; i < SET_SIZE; i++) { |
| 47 | set->list[i].free_next = i + 1; |
| 48 | set->list[i].alloc_next = -1; |
| 49 | } |
| 50 | set->list[SET_SIZE-1].free_next = -1; |
| 51 | set->free = 0; |
| 52 | set->alloc = -1; |
| 53 | set->trace = -1; |
| 54 | } |
| 55 | return set; |
| 56 | } |
| 57 | |
| 58 | int setAdd(set_t *set, ITEM_TYPE item) |
| 59 | { |
| 60 | int free = set->free; |
| 61 | |
| 62 | if (free != -1) { |
| 63 | set->list[free].val = item; |
| 64 | set->free = set->list[free].free_next; |
| 65 | } else { |
| 66 | return 0; |
| 67 | } |
| 68 | |
| 69 | set->list[free].alloc_next = set->alloc; |
| 70 | set->alloc = free; |
| 71 | set->list[free].free_next = -1; |
| 72 | |
| 73 | return 1; |
| 74 | } |
| 75 | |
| 76 | int setDel(set_t *set, ITEM_TYPE item) |
| 77 | { |
| 78 | int alloc = set->alloc; |
| 79 | int prev = -1; |
| 80 | |
| 81 | while (alloc != -1) { |
| 82 | if (set->list[alloc].val == item) { |
| 83 | if (prev != -1) |
| 84 | set->list[prev].alloc_next = |
| 85 | set->list[alloc].alloc_next; |
| 86 | else |
| 87 | set->alloc = set->list[alloc].alloc_next; |
| 88 | break; |
| 89 | } |
| 90 | prev = alloc; |
| 91 | alloc = set->list[alloc].alloc_next; |
| 92 | } |
| 93 | |
| 94 | if (alloc == -1) |
| 95 | return 0; |
| 96 | |
| 97 | set->list[alloc].free_next = set->free; |
| 98 | set->free = alloc; |
| 99 | set->list[alloc].alloc_next = -1; |
| 100 | |
| 101 | return 1; |
| 102 | } |
| 103 | |
| 104 | /* setFirst -> setAdd -> setNext is wrong */ |
| 105 | |
| 106 | int setFirst(set_t *set, ITEM_TYPE *item) |
| 107 | { |
| 108 | if (set->alloc == -1) |
| 109 | return 0; |
| 110 | |
| 111 | *item = set->list[set->alloc].val; |
| 112 | set->trace = set->list[set->alloc].alloc_next; |
| 113 | |
| 114 | return 1; |
| 115 | } |
| 116 | |
| 117 | int setNext(set_t *set, ITEM_TYPE *item) |
| 118 | { |
| 119 | if (set->trace == -1) |
| 120 | return 0; |
| 121 | |
| 122 | *item = set->list[set->trace].val; |
| 123 | set->trace = set->list[set->trace].alloc_next; |
| 124 | |
| 125 | return 1; |
| 126 | } |
| 127 | |
| 128 | int setDestroy(set_t *set) |
| 129 | { |
| 130 | drm_free(set, sizeof(set_t), DRM_MEM_DRIVER); |
| 131 | |
| 132 | return 1; |
| 133 | } |
| 134 | |
| 135 | /* |
| 136 | * GLX Hardware Device Driver common code |
| 137 | * Copyright (C) 1999 Wittawat Yamwong |
| 138 | * |
| 139 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 140 | * copy of this software and associated documentation files (the "Software"), |
| 141 | * to deal in the Software without restriction, including without limitation |
| 142 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 143 | * and/or sell copies of the Software, and to permit persons to whom the |
| 144 | * Software is furnished to do so, subject to the following conditions: |
| 145 | * |
| 146 | * The above copyright notice and this permission notice shall be included |
| 147 | * in all copies or substantial portions of the Software. |
| 148 | * |
| 149 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| 150 | * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 151 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 152 | * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, |
| 153 | * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| 154 | * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE |
| 155 | * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 156 | * |
| 157 | */ |
| 158 | |
| 159 | #define ISFREE(bptr) ((bptr)->free) |
| 160 | |
| 161 | memHeap_t *mmInit(int ofs, |
| 162 | int size) |
| 163 | { |
| 164 | PMemBlock blocks; |
| 165 | |
| 166 | if (size <= 0) |
| 167 | return NULL; |
| 168 | |
| 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; |
| 177 | } |
| 178 | |
| 179 | /* Checks if a pointer 'b' is part of the heap 'heap' */ |
| 180 | int mmBlockInHeap(memHeap_t *heap, PMemBlock b) |
| 181 | { |
| 182 | TMemBlock *p; |
| 183 | |
| 184 | if (heap == NULL || b == NULL) |
| 185 | return 0; |
| 186 | |
| 187 | p = heap; |
| 188 | while (p != NULL && p != b) { |
| 189 | p = p->next; |
| 190 | } |
| 191 | if (p == b) |
| 192 | return 1; |
| 193 | else |
| 194 | return 0; |
| 195 | } |
| 196 | |
| 197 | static TMemBlock* SliceBlock(TMemBlock *p, |
| 198 | int startofs, int size, |
| 199 | int reserved, int alignment) |
| 200 | { |
| 201 | TMemBlock *newblock; |
| 202 | |
| 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; |
| 214 | } |
| 215 | |
| 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; |
| 226 | } |
| 227 | |
| 228 | /* p = middle block */ |
| 229 | p->align = alignment; |
| 230 | p->free = 0; |
| 231 | p->reserved = reserved; |
| 232 | return p; |
| 233 | } |
| 234 | |
| 235 | PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch) |
| 236 | { |
| 237 | int mask,startofs, endofs; |
| 238 | TMemBlock *p; |
| 239 | |
| 240 | if (heap == NULL || align2 < 0 || size <= 0) |
| 241 | return NULL; |
| 242 | |
| 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; |
| 251 | } |
| 252 | endofs = startofs+size; |
| 253 | if (endofs <= (p->ofs+p->size)) |
| 254 | break; |
| 255 | } |
| 256 | p = p->next; |
| 257 | } |
| 258 | if (p == NULL) |
| 259 | return NULL; |
| 260 | p = SliceBlock(p,startofs,size,0,mask+1); |
| 261 | p->heap = heap; |
| 262 | return p; |
| 263 | } |
| 264 | |
| 265 | static __inline__ int Join2Blocks(TMemBlock *p) |
| 266 | { |
| 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; |
| 273 | } |
| 274 | return 0; |
| 275 | } |
| 276 | |
| 277 | int mmFreeMem(PMemBlock b) |
| 278 | { |
| 279 | TMemBlock *p, *prev; |
| 280 | |
| 281 | if (b == NULL) |
| 282 | return 0; |
| 283 | if (b->heap == NULL) |
| 284 | return -1; |
| 285 | |
| 286 | p = b->heap; |
| 287 | prev = NULL; |
| 288 | while (p != NULL && p != b) { |
| 289 | prev = p; |
| 290 | p = p->next; |
| 291 | } |
| 292 | if (p == NULL || p->free || p->reserved) |
| 293 | return -1; |
| 294 | |
| 295 | p->free = 1; |
| 296 | Join2Blocks(p); |
| 297 | if (prev) |
| 298 | Join2Blocks(prev); |
| 299 | return 0; |
| 300 | } |
| 301 | |