arch/common/hidd.radeon/bitmap.c

   1 /*
   2     Copyright © 2003-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #include "bitmap.h"
   8 #include <exec/types.h>
   9 #include <proto/exec.h>
  10 #include <aros/debug.h>
  11
  12 LONG bfffo(ULONG val, UBYTE bitoffset)
  13 {
  14     val &= (0xffffffff >> bitoffset);
  15     if (val)
  16         return __builtin_clz(val);
  17     else
  18         return 32;
  19 }
  20
  21 LONG bfflo(ULONG val, UBYTE bitoffset)
  22 {
  23     val &= (0xffffffff << (31-bitoffset));
  24     if (val)
  25         return 31-__builtin_ctz(val);
  26     else
  27         return -1;
  28 }
  29
  30 LONG bfffz(ULONG val, UBYTE bitoffset)
  31 {
  32     return bfffo(~val, bitoffset);
  33 }
  34
  35 LONG bfflz(ULONG val, UBYTE bitoffset)
  36 {
  37     return bfflo(~val, bitoffset);
  38 }
  39
  40 ULONG bfset(ULONG data, UBYTE bitoffset, UBYTE bits)
  41 {
  42     ULONG mask = ~((1 << (32 - bits)) - 1);
  43     mask >>= bitoffset;
  44     return data | mask;
  45 }
  46
  47 ULONG bfclr(ULONG data, UBYTE bitoffset, UBYTE bits)
  48 {
  49     ULONG mask = ~((1 << (32 - bits)) - 1);
  50     mask >>= bitoffset;
  51     return data & ~mask;
  52 }
  53
  54 LONG bmffo(ULONG *bitmap, ULONG longs, LONG bitoffset)
  55 {
  56     ULONG *scan = bitmap;
  57     ULONG err = 32*longs;
  58     int longoffset, bit;
  59
  60     longoffset = bitoffset >> 5;
  61     longs -= longoffset;
  62     scan += longoffset;
  63
  64     bitoffset = bitoffset & 0x1F;
  65
  66     if (bitoffset != 0) {
  67         if ((bit = bfffo(*scan, bitoffset)) < 32) {
  68             return (bit + ((scan - bitmap) << 5));
  69         }
  70         scan++;
  71         longs--;
  72     }
  73
  74     while (longs-- > 0) {
  75         if (*scan++ != 0) {
  76             return (bfffo(*--scan,0) + ((scan - bitmap) << 5));
  77         }
  78     }
  79
  80     return (err);
  81 }
  82
  83 LONG bmffz(ULONG *bitmap, ULONG longs, LONG bitoffset)
  84 {
  85     ULONG *scan = bitmap;
  86     ULONG err = 32*longs;
  87     int longoffset, bit;
  88
  89     longoffset = bitoffset >> 5;
  90     longs -= longoffset;
  91     scan += longoffset;
  92
  93     bitoffset = bitoffset & 0x1F;
  94
  95     if (bitoffset != 0) {
  96         if ((bit = bfffz(*scan, bitoffset)) < 32) {
  97             return (bit + ((scan - bitmap) << 5));
  98         }
  99         scan++;
 100         longs--;
 101     }
 102
 103     while (longs-- > 0) {
 104         if (*scan++ != 0xFFFFFFFF) {
 105             return (bfffz(*--scan,0) + ((scan - bitmap) << 5));
 106         }
 107     }
 108
 109     return (err);
 110 }
 111
 112 LONG bmclr(ULONG *bitmap, ULONG longs, LONG bitoffset, LONG bits)
 113 {
 114     ULONG *scan = bitmap;
 115     int longoffset;
 116     int orgbits = bits;
 117
 118     longoffset = bitoffset >> 5;
 119     longs -= longoffset;
 120     scan += longoffset;
 121
 122     bitoffset = bitoffset & 0x1F;
 123
 124     if (bitoffset != 0) {
 125         if (bits < 32) {
 126             *scan = bfclr(*scan, bitoffset, bits);
 127         } else {
 128             *scan = bfclr(*scan, bitoffset, 32);
 129         }
 130         scan++;
 131         longs--;
 132         bits -= 32 - bitoffset;
 133     }
 134
 135     while (bits > 0 && longs-- > 0) {
 136         if (bits > 31) {
 137             *scan++ = 0;
 138         } else {
 139             *scan = bfclr(*scan, 0, bits);
 140         }
 141         bits -= 32;
 142     }
 143
 144     if (bits <= 0) {
 145         return (orgbits);
 146     }
 147     return (orgbits - bits);
 148 }
 149
 150 LONG bmset(ULONG *bitmap, ULONG longs, LONG bitoffset, LONG bits)
 151 {
 152     ULONG *scan = bitmap;
 153     int longoffset;
 154     int orgbits = bits;
 155
 156     longoffset = bitoffset >> 5;
 157     longs -= longoffset;
 158     scan += longoffset;
 159
 160     bitoffset = bitoffset & 0x1F;
 161
 162     if (bitoffset != 0) {
 163         if (bits < 32) {
 164             *scan = (bfset((*scan), bitoffset, bits));
 165         } else {
 166             *scan = (bfset((*scan), bitoffset, 32));
 167         }
 168         scan++;
 169         longs--;
 170         bits -= 32 - bitoffset;
 171     }
 172
 173     while (bits > 0 && longs-- > 0) {
 174         if (bits > 31) {
 175             *scan++ = 0xFFFFFFFF;
 176         } else {
 177             *scan = (bfset((*scan), 0, bits));
 178         }
 179         bits -= 32;
 180     }
 181
 182     if (bits <= 0) {
 183         return (orgbits);
 184     }
 185     return (orgbits - bits);
 186 }
 187
 188 int bmtstz(ULONG *bitmap, ULONG bitoffset, LONG bits)
 189 {
 190     LONG longoffset = bitoffset >> 5;
 191     ULONG *scan = bitmap;
 192     ULONG mask;
 193
 194     scan += longoffset;
 195     bitoffset &= 0x1f;
 196
 197     if (bitoffset != 0)
 198     {
 199         if ((bits + bitoffset) < 32)
 200         {
 201             mask = (0xffffffff >> bitoffset) & (0xffffffff << (32 - (bits+bitoffset)));
 202             bits=0;
 203         }
 204         else
 205         {
 206             mask = (0xffffffff >> bitoffset);
 207             bits -= (32-bitoffset);
 208         }
 209         if ((mask & (*scan++)) != 0)
 210             return 0;
 211     }
 212
 213     while (bits > 0)
 214     {
 215         if (bits >= 32)
 216         {
 217             mask=0xffffffff;
 218             bits -= 32;
 219         }
 220         else
 221         {
 222             mask = 0xffffffff << (32-bits);
 223             bits = 0;
 224         }
 225         if ((mask & (*scan++)) != 0)
 226             return 0;
 227     }
 228
 229     return 1;
 230 }
 231
 232 void BitmapInit(struct ati_staticdata *sd)
 233 {
 234     /*
 235      * If Radeon chip has some video memory, create a bitmap representing all allocations.
 236      * Divide whole memory into 1KB chunks
 237      */
 238     if (sd->Card.FbUsableSize)
 239         sd->CardMemBmp = AllocPooled(sd->memPool, sd->Card.FbUsableSize >> 13);
 240
 241     /* Number of ULONG's in bitmap */
 242     sd->CardMemSize = sd->Card.FbUsableSize >> 15;
 243
 244     bug("[ATIBMP] Bitmap at %p, size %d bytes (%d bits)\n", sd->CardMemBmp, sd->CardMemSize << 2, sd->Card.FbUsableSize >> 10);
 245 }
 246
 247 void BitmapFree(struct ati_staticdata *sd, ULONG ptr, ULONG size)
 248 {
 249     if (ptr + size < sd->Card.FbUsableSize)
 250     {
 251         bmclr(sd->CardMemBmp, sd->CardMemSize, ptr >> 10, (size + 1023) >> 10);
 252     }
 253 }
 254
 255 ULONG BitmapAlloc(struct ati_staticdata *sd, ULONG size)
 256 {
 257     ULONG ptr;
 258     size = (size + 1023) >> 10;
 259
 260     ptr = bmffz(sd->CardMemBmp, sd->CardMemSize, 0);
 261
 262     D(bug("[ATIBMP] BitmapAlloc(%d)\n", size));
 263
 264     while (ptr <= (sd->CardMemSize << 5) + size)
 265     {
 266         D(bug("[ATIBMP] ptr=%08x\n", ptr));
 267
 268         if (bmtstz(sd->CardMemBmp, ptr, size))
 269         {
 270             bmset(sd->CardMemBmp, sd->CardMemSize, ptr, size);
 271             break;
 272         }
 273
 274         ptr = bmffo(sd->CardMemBmp, sd->CardMemSize, ptr);
 275         ptr = bmffz(sd->CardMemBmp, sd->CardMemSize, ptr);
 276     }
 277
 278     if (ptr > (sd->CardMemSize << 5) - size)
 279         ptr = 0xffffffff;
 280     else
 281         ptr <<= 10;
 282
 283     return ptr;
 284 }