sis_ds.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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  * $FreeBSD$
   30  */
   31 
   32 #include "dev/drm/sis.h"
   33 #include "dev/drm/drmP.h"
   34 #include "dev/drm/drm.h"
   35 #include "dev/drm/sis_ds.h"
   36 
   37 /* Set Data Structure, not check repeated value
   38  * temporarily used
   39  */
   40 
   41 set_t *setInit(void)
   42 {
   43         int i;
   44         set_t *set;
   45 
   46         set = (set_t *)DRM(alloc)(sizeof(set_t), DRM_MEM_DRIVER);
   47         if (set != NULL) {
   48                 for (i = 0; i < SET_SIZE; i++) {
   49                         set->list[i].free_next = i + 1;    
   50                         set->list[i].alloc_next = -1;
   51                 }
   52                 set->list[SET_SIZE-1].free_next = -1;
   53                 set->free = 0;
   54                 set->alloc = -1;
   55                 set->trace = -1;
   56         }
   57         return set;
   58 }
   59 
   60 int setAdd(set_t *set, ITEM_TYPE item)
   61 {
   62         int free = set->free;
   63   
   64         if (free != -1) {
   65                 set->list[free].val = item;
   66                 set->free = set->list[free].free_next;
   67         } else {
   68                 return 0;
   69         }
   70 
   71         set->list[free].alloc_next = set->alloc;
   72         set->alloc = free;  
   73         set->list[free].free_next = -1;    
   74 
   75         return 1;
   76 }
   77 
   78 int setDel(set_t *set, ITEM_TYPE item)
   79 {
   80         int alloc = set->alloc;
   81         int prev = -1;  
   82 
   83         while (alloc != -1) {
   84                 if (set->list[alloc].val == item) {
   85                         if (prev != -1)
   86                                 set->list[prev].alloc_next =
   87                                     set->list[alloc].alloc_next;
   88                         else
   89                                 set->alloc = set->list[alloc].alloc_next;
   90                         break;
   91                 }
   92                 prev = alloc;
   93                 alloc = set->list[alloc].alloc_next;
   94         }
   95 
   96         if (alloc == -1)
   97                 return 0;
   98 
   99         set->list[alloc].free_next = set->free;
  100         set->free = alloc;
  101         set->list[alloc].alloc_next = -1;
  102 
  103         return 1;
  104 }
  105 
  106 /* setFirst -> setAdd -> setNext is wrong */
  107 
  108 int setFirst(set_t *set, ITEM_TYPE *item)
  109 {
  110         if (set->alloc == -1)
  111                 return 0;
  112 
  113         *item = set->list[set->alloc].val;
  114         set->trace = set->list[set->alloc].alloc_next;
  115 
  116         return 1;
  117 }
  118 
  119 int setNext(set_t *set, ITEM_TYPE *item)
  120 {
  121         if (set->trace == -1)
  122                 return 0;
  123 
  124         *item = set->list[set->trace].val;
  125         set->trace = set->list[set->trace].alloc_next;
  126 
  127         return 1;
  128 }
  129 
  130 int setDestroy(set_t *set)
  131 {
  132         DRM(free)(set, sizeof(set_t), DRM_MEM_DRIVER);
  133 
  134         return 1;
  135 }
  136 
  137 /*
  138  * GLX Hardware Device Driver common code
  139  * Copyright (C) 1999 Keith Whitwell
  140  *
  141  * Permission is hereby granted, free of charge, to any person obtaining a
  142  * copy of this software and associated documentation files (the "Software"),
  143  * to deal in the Software without restriction, including without limitation
  144  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  145  * and/or sell copies of the Software, and to permit persons to whom the
  146  * Software is furnished to do so, subject to the following conditions:
  147  *
  148  * The above copyright notice and this permission notice shall be included
  149  * in all copies or substantial portions of the Software.
  150  *
  151  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  152  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  153  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  154  * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, 
  155  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
  156  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
  157  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  158  *
  159  */
  160 
  161 #define ISFREE(bptr) ((bptr)->free)
  162 
  163 memHeap_t *mmInit(int ofs,
  164                   int size)
  165 {
  166         PMemBlock blocks;
  167 
  168         if (size <= 0)
  169                 return 0;
  170 
  171         blocks = (TMemBlock *)DRM(calloc)(1, sizeof(TMemBlock), DRM_MEM_DRIVER);
  172         if (blocks != NULL) {
  173                 blocks->ofs = ofs;
  174                 blocks->size = size;
  175                 blocks->free = 1;
  176                 return (memHeap_t *)blocks;
  177         } else
  178                 return 0;
  179 }
  180 
  181 /* Checks if a pointer 'b' is part of the heap 'heap' */
  182 int mmBlockInHeap(memHeap_t *heap, PMemBlock b)
  183 {
  184         TMemBlock *p;
  185 
  186         if (heap == NULL || b == NULL)
  187                 return 0;
  188 
  189         p = heap;
  190         while (p != NULL && p != b) {
  191                 p = p->next;
  192         }
  193         if (p == b)
  194                 return 1;
  195         else
  196                 return 0;
  197 }
  198 
  199 /* Kludgey workaround for existing i810 server.  Remove soon.
  200  */
  201 memHeap_t *mmAddRange( memHeap_t *heap,
  202                        int ofs,
  203                        int size )
  204 {
  205         PMemBlock blocks;
  206         blocks = (TMemBlock *)DRM(calloc)(2, sizeof(TMemBlock), DRM_MEM_DRIVER);
  207         if (blocks != NULL) {
  208                 blocks[0].size = size;
  209                 blocks[0].free = 1;
  210                 blocks[0].ofs = ofs;
  211                 blocks[0].next = &blocks[1];
  212 
  213                 /* Discontinuity - stops JoinBlock from trying to join
  214                  * non-adjacent ranges.
  215                  */
  216                 blocks[1].size = 0;
  217                 blocks[1].free = 0;
  218                 blocks[1].ofs = ofs+size;
  219                 blocks[1].next = (PMemBlock)heap;
  220                 return (memHeap_t *)blocks;
  221         } else
  222                 return heap;
  223 }
  224 
  225 static TMemBlock* SliceBlock(TMemBlock *p, 
  226                              int startofs, int size, 
  227                              int reserved, int alignment)
  228 {
  229         TMemBlock *newblock;
  230 
  231         /* break left */
  232         if (startofs > p->ofs) {
  233                 newblock = (TMemBlock*) DRM(calloc)(1, sizeof(TMemBlock),
  234                     DRM_MEM_DRIVER);
  235                 newblock->ofs = startofs;
  236                 newblock->size = p->size - (startofs - p->ofs);
  237                 newblock->free = 1;
  238                 newblock->next = p->next;
  239                 p->size -= newblock->size;
  240                 p->next = newblock;
  241                 p = newblock;
  242         }
  243 
  244         /* break right */
  245         if (size < p->size) {
  246                 newblock = (TMemBlock*) DRM(calloc)(1, sizeof(TMemBlock),
  247                     DRM_MEM_DRIVER);
  248                 newblock->ofs = startofs + size;
  249                 newblock->size = p->size - size;
  250                 newblock->free = 1;
  251                 newblock->next = p->next;
  252                 p->size = size;
  253                 p->next = newblock;
  254         }
  255 
  256         /* p = middle block */
  257         p->align = alignment;
  258         p->free = 0;
  259         p->reserved = reserved;
  260         return p;
  261 }
  262 
  263 PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch)
  264 {
  265         int mask,startofs, endofs;
  266         TMemBlock *p;
  267         
  268         if (heap == NULL || align2 < 0 || size <= 0)
  269                 return NULL;
  270 
  271         mask = (1 << align2)-1;
  272         startofs = 0;
  273         p = (TMemBlock *)heap;
  274         while (p != NULL) {
  275                 if (ISFREE(p)) {
  276                         startofs = (p->ofs + mask) & ~mask;
  277                         if ( startofs < startSearch ) {
  278                                 startofs = startSearch;
  279                         }
  280                         endofs = startofs+size;
  281                         if (endofs <= (p->ofs+p->size))
  282                                 break;
  283                 }
  284                 p = p->next;
  285         }
  286         if (p == NULL)
  287                 return NULL;
  288         p = SliceBlock(p,startofs,size,0,mask+1);
  289         p->heap = heap;
  290         return p;
  291 }
  292 
  293 static __inline__ int Join2Blocks(TMemBlock *p)
  294 {
  295         if (p->free && p->next && p->next->free) {
  296                 TMemBlock *q = p->next;
  297                 p->size += q->size;
  298                 p->next = q->next;
  299                 DRM(free)(q, sizeof(TMemBlock), DRM_MEM_DRIVER);
  300                 return 1;
  301         }
  302         return 0;
  303 }
  304 
  305 int mmFreeMem(PMemBlock b)
  306 {
  307         TMemBlock *p, *prev;
  308 
  309         if (b == NULL)
  310                 return 0;
  311         if (b->heap == NULL)
  312                 return -1;
  313 
  314         p = b->heap;
  315         prev = NULL;
  316         while (p != NULL && p != b) {
  317                 prev = p;
  318                 p = p->next;
  319         }
  320         if (p == NULL || p->free || p->reserved)
  321                 return -1;
  322 
  323         p->free = 1;
  324         Join2Blocks(p);
  325         if (prev)
  326         Join2Blocks(prev);
  327         return 0;
  328 }
  329 
  330 int mmReserveMem(memHeap_t *heap, int offset,int size)
  331 {
  332         int endofs;
  333         TMemBlock *p;
  334 
  335         if (heap == NULL || size <= 0)
  336                 return -1;
  337 
  338         endofs = offset + size;
  339         p = (TMemBlock *)heap;
  340         while (p && p->ofs <= offset) {
  341                 if (ISFREE(p) && endofs <= (p->ofs+p->size)) {
  342                         SliceBlock(p,offset,size,1,1);
  343                         return 0;
  344                 }
  345                 p = p->next;
  346         }
  347         return -1;
  348 }
  349 
  350 int mmFreeReserved(memHeap_t *heap, int offset)
  351 {
  352         TMemBlock *p,*prev;
  353 
  354         if (heap == NULL)
  355                 return -1;
  356 
  357         p = (TMemBlock *)heap;
  358         prev = NULL;
  359         while (p != NULL && p->ofs != offset) {
  360                 prev = p;
  361                 p = p->next;
  362         }
  363         if (p == NULL || !p->reserved)
  364                 return -1;
  365 
  366         p->free = 1;
  367         p->reserved = 0;
  368         Join2Blocks(p);
  369         if (prev != NULL)
  370                 Join2Blocks(prev);
  371         return 0;
  372 }
  373 
  374 void mmDestroy(memHeap_t *heap)
  375 {
  376         TMemBlock *p,*q;
  377 
  378         if (heap == NULL)
  379                 return;
  380 
  381         p = (TMemBlock *)heap;
  382         while (p != NULL) {
  383                 q = p->next;
  384                 DRM(free)(p, sizeof(TMemBlock), DRM_MEM_DRIVER);
  385                 p = q;
  386         }
  387 }
Cache object: 821a2581c6b35e1f96cb801e12a6e219
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/drm/sis_ds.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/drm/sis_ds.c
