The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/drm/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  */
   30 
   31 #include <sys/cdefs.h>
   32 __FBSDID("$FreeBSD: releng/9.0/sys/dev/drm/sis_ds.c 157617 2006-04-09 20:45:45Z anholt $");
   33 
   34 #include "dev/drm/drmP.h"
   35 #include "dev/drm/drm.h"
   36 #include "dev/drm/sis_ds.h"
   37 
   38 /* Set Data Structure, not check repeated value
   39  * temporarily used
   40  */
   41 
   42 set_t *setInit(void)
   43 {
   44         int i;
   45         set_t *set;
   46 
   47         set = (set_t *) drm_alloc(sizeof(set_t), DRM_MEM_DRIVER);
   48         if (set != NULL) {
   49                 for (i = 0; i < SET_SIZE; i++) {
   50                         set->list[i].free_next = i + 1;
   51                         set->list[i].alloc_next = -1;
   52                 }
   53                 set->list[SET_SIZE - 1].free_next = -1;
   54                 set->free = 0;
   55                 set->alloc = -1;
   56                 set->trace = -1;
   57         }
   58         return set;
   59 }
   60 
   61 int setAdd(set_t * set, ITEM_TYPE item)
   62 {
   63         int free = set->free;
   64 
   65         if (free != -1) {
   66                 set->list[free].val = item;
   67                 set->free = set->list[free].free_next;
   68         } else {
   69                 return 0;
   70         }
   71 
   72         set->list[free].alloc_next = set->alloc;
   73         set->alloc = free;
   74         set->list[free].free_next = -1;
   75 
   76         return 1;
   77 }
   78 
   79 int setDel(set_t * set, ITEM_TYPE item)
   80 {
   81         int alloc = set->alloc;
   82         int prev = -1;
   83 
   84         while (alloc != -1) {
   85                 if (set->list[alloc].val == item) {
   86                         if (prev != -1)
   87                                 set->list[prev].alloc_next =
   88                                     set->list[alloc].alloc_next;
   89                         else
   90                                 set->alloc = set->list[alloc].alloc_next;
   91                         break;
   92                 }
   93                 prev = alloc;
   94                 alloc = set->list[alloc].alloc_next;
   95         }
   96 
   97         if (alloc == -1)
   98                 return 0;
   99 
  100         set->list[alloc].free_next = set->free;
  101         set->free = alloc;
  102         set->list[alloc].alloc_next = -1;
  103 
  104         return 1;
  105 }
  106 
  107 /* setFirst -> setAdd -> setNext is wrong */
  108 
  109 int setFirst(set_t * set, ITEM_TYPE * item)
  110 {
  111         if (set->alloc == -1)
  112                 return 0;
  113 
  114         *item = set->list[set->alloc].val;
  115         set->trace = set->list[set->alloc].alloc_next;
  116 
  117         return 1;
  118 }
  119 
  120 int setNext(set_t * set, ITEM_TYPE * item)
  121 {
  122         if (set->trace == -1)
  123                 return 0;
  124 
  125         *item = set->list[set->trace].val;
  126         set->trace = set->list[set->trace].alloc_next;
  127 
  128         return 1;
  129 }
  130 
  131 int setDestroy(set_t * set)
  132 {
  133         drm_free(set, sizeof(set_t), DRM_MEM_DRIVER);
  134 
  135         return 1;
  136 }
  137 
  138 /*
  139  * GLX Hardware Device Driver common code
  140  * Copyright (C) 1999 Wittawat Yamwong
  141  *
  142  * Permission is hereby granted, free of charge, to any person obtaining a
  143  * copy of this software and associated documentation files (the "Software"),
  144  * to deal in the Software without restriction, including without limitation
  145  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  146  * and/or sell copies of the Software, and to permit persons to whom the
  147  * Software is furnished to do so, subject to the following conditions:
  148  *
  149  * The above copyright notice and this permission notice shall be included
  150  * in all copies or substantial portions of the Software.
  151  *
  152  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  153  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  154  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  155  * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
  156  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  157  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
  158  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  159  *
  160  */
  161 
  162 #define ISFREE(bptr) ((bptr)->free)
  163 
  164 memHeap_t *mmInit(int ofs, int size)
  165 {
  166         PMemBlock blocks;
  167 
  168         if (size <= 0)
  169                 return NULL;
  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 NULL;
  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 static TMemBlock *SliceBlock(TMemBlock * p,
  200                              int startofs, int size,
  201                              int reserved, int alignment)
  202 {
  203         TMemBlock *newblock;
  204 
  205         /* break left */
  206         if (startofs > p->ofs) {
  207                 newblock = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
  208                                                     DRM_MEM_DRIVER);
  209                 newblock->ofs = startofs;
  210                 newblock->size = p->size - (startofs - p->ofs);
  211                 newblock->free = 1;
  212                 newblock->next = p->next;
  213                 p->size -= newblock->size;
  214                 p->next = newblock;
  215                 p = newblock;
  216         }
  217 
  218         /* break right */
  219         if (size < p->size) {
  220                 newblock = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
  221                                                     DRM_MEM_DRIVER);
  222                 newblock->ofs = startofs + size;
  223                 newblock->size = p->size - size;
  224                 newblock->free = 1;
  225                 newblock->next = p->next;
  226                 p->size = size;
  227                 p->next = newblock;
  228         }
  229 
  230         /* p = middle block */
  231         p->align = alignment;
  232         p->free = 0;
  233         p->reserved = reserved;
  234         return p;
  235 }
  236 
  237 PMemBlock mmAllocMem(memHeap_t * heap, int size, int align2, int startSearch)
  238 {
  239         int mask, startofs, endofs;
  240         TMemBlock *p;
  241 
  242         if (heap == NULL || align2 < 0 || size <= 0)
  243                 return NULL;
  244 
  245         mask = (1 << align2) - 1;
  246         startofs = 0;
  247         p = (TMemBlock *) heap;
  248         while (p != NULL) {
  249                 if (ISFREE(p)) {
  250                         startofs = (p->ofs + mask) & ~mask;
  251                         if (startofs < startSearch) {
  252                                 startofs = startSearch;
  253                         }
  254                         endofs = startofs + size;
  255                         if (endofs <= (p->ofs + p->size))
  256                                 break;
  257                 }
  258                 p = p->next;
  259         }
  260         if (p == NULL)
  261                 return NULL;
  262         p = SliceBlock(p, startofs, size, 0, mask + 1);
  263         p->heap = heap;
  264         return p;
  265 }
  266 
  267 static __inline__ int Join2Blocks(TMemBlock * p)
  268 {
  269         if (p->free && p->next && p->next->free) {
  270                 TMemBlock *q = p->next;
  271                 p->size += q->size;
  272                 p->next = q->next;
  273                 drm_free(q, sizeof(TMemBlock), DRM_MEM_DRIVER);
  274                 return 1;
  275         }
  276         return 0;
  277 }
  278 
  279 int mmFreeMem(PMemBlock b)
  280 {
  281         TMemBlock *p, *prev;
  282 
  283         if (b == NULL)
  284                 return 0;
  285         if (b->heap == NULL)
  286                 return -1;
  287 
  288         p = b->heap;
  289         prev = NULL;
  290         while (p != NULL && p != b) {
  291                 prev = p;
  292                 p = p->next;
  293         }
  294         if (p == NULL || p->free || p->reserved)
  295                 return -1;
  296 
  297         p->free = 1;
  298         Join2Blocks(p);
  299         if (prev)
  300                 Join2Blocks(prev);
  301         return 0;
  302 }

Cache object: 8d1a61fc3173fa506a4d6612c9669e4d


[ 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.