WebSVN – Kolibri OS – Diff – /drivers/video/drm/radeon/utils.c


#include 
#include 
#include 
#include 
#include "radeon.h"
 
int x86_clflush_size;
unsigned int tsc_khz;
 
struct file *shmem_file_setup(const char *name, loff_t size, unsigned long flags)
{
    struct file *filep;
    int count;
 
    filep = __builtin_malloc(sizeof(*filep));
 
    if(unlikely(filep == NULL))
        return ERR_PTR(-ENOMEM);
 
    count = size / PAGE_SIZE;
 
    filep->pages = kzalloc(sizeof(struct page *) * count, 0);
    if(unlikely(filep->pages == NULL))
    {
        kfree(filep);
        return ERR_PTR(-ENOMEM);
    };
 
    filep->count     = count;
    filep->allocated = 0;
    filep->vma       = NULL;
 
//    printf("%s file %p pages %p count %d\n",
//              __FUNCTION__,filep, filep->pages, count);
 
    return filep;
}
 
static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
{
        while (bytes) {
                if (*start != value)
                        return (void *)start;
                start++;
                bytes--;
        }
        return NULL;
}
 
/**
 * memchr_inv - Find an unmatching character in an area of memory.
 * @start: The memory area
 * @c: Find a character other than c
 * @bytes: The size of the area.
 *
 * returns the address of the first character other than @c, or %NULL
 * if the whole buffer contains just @c.
 */
void *memchr_inv(const void *start, int c, size_t bytes)
{
        u8 value = c;
        u64 value64;
        unsigned int words, prefix;
 
        if (bytes <= 16)
                return check_bytes8(start, value, bytes);
 
        value64 = value;
#if defined(ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
        value64 *= 0x0101010101010101;
#elif defined(ARCH_HAS_FAST_MULTIPLIER)
        value64 *= 0x01010101;
        value64 |= value64 << 32;
#else
        value64 |= value64 << 8;
        value64 |= value64 << 16;
        value64 |= value64 << 32;
#endif
 
        prefix = (unsigned long)start % 8;
        if (prefix) {
                u8 *r;
 
                prefix = 8 - prefix;
                r = check_bytes8(start, value, prefix);
                if (r)
                        return r;
                start += prefix;
                bytes -= prefix;
        }
 
        words = bytes / 8;
 
        while (words) {
                if (*(u64 *)start != value64)
                        return check_bytes8(start, value, 8);
                start += 8;
                words--;
        }
 
        return check_bytes8(start, value, bytes % 8);
}
 
 
 
#define _U  0x01    /* upper */
#define _L  0x02    /* lower */
#define _D  0x04    /* digit */
#define _C  0x08    /* cntrl */
#define _P  0x10    /* punct */
#define _S  0x20    /* white space (space/lf/tab) */
#define _X  0x40    /* hex digit */
#define _SP 0x80    /* hard space (0x20) */
 
extern const unsigned char _ctype[];
 
#define __ismask(x) (_ctype[(int)(unsigned char)(x)])
 
#define isalnum(c)  ((__ismask(c)&(_U|_L|_D)) != 0)
#define isalpha(c)  ((__ismask(c)&(_U|_L)) != 0)
#define iscntrl(c)  ((__ismask(c)&(_C)) != 0)
#define isdigit(c)  ((__ismask(c)&(_D)) != 0)
#define isgraph(c)  ((__ismask(c)&(_P|_U|_L|_D)) != 0)
#define islower(c)  ((__ismask(c)&(_L)) != 0)
#define isprint(c)  ((__ismask(c)&(_P|_U|_L|_D|_SP)) != 0)
#define ispunct(c)  ((__ismask(c)&(_P)) != 0)
/* Note: isspace() must return false for %NUL-terminator */
#define isspace(c)  ((__ismask(c)&(_S)) != 0)
#define isupper(c)  ((__ismask(c)&(_U)) != 0)
#define isxdigit(c) ((__ismask(c)&(_D|_X)) != 0)
 
#define isascii(c) (((unsigned char)(c))<=0x7f)
#define toascii(c) (((unsigned char)(c))&0x7f)
 
static inline unsigned char __tolower(unsigned char c)
{
    if (isupper(c))
        c -= 'A'-'a';
    return c;
}
 
static inline unsigned char __toupper(unsigned char c)
{
    if (islower(c))
        c -= 'a'-'A';
    return c;
}
 
#define tolower(c) __tolower(c)
#define toupper(c) __toupper(c)
 
/*
 * Fast implementation of tolower() for internal usage. Do not use in your
 * code.
 */
static inline char _tolower(const char c)
{
    return c | 0x20;
}
 
 
//const char hex_asc[] = "0123456789abcdef";
 
/**
 * hex_to_bin - convert a hex digit to its real value
 * @ch: ascii character represents hex digit
 *
 * hex_to_bin() converts one hex digit to its actual value or -1 in case of bad
 * input.
 */
int hex_to_bin(char ch)
{
    if ((ch >= '0') && (ch <= '9'))
        return ch - '0';
    ch = tolower(ch);
    if ((ch >= 'a') && (ch <= 'f'))
        return ch - 'a' + 10;
    return -1;
}
EXPORT_SYMBOL(hex_to_bin);
 
/**
 * hex2bin - convert an ascii hexadecimal string to its binary representation
 * @dst: binary result
 * @src: ascii hexadecimal string
 * @count: result length
 *
 * Return 0 on success, -1 in case of bad input.
 */
int hex2bin(u8 *dst, const char *src, size_t count)
{
    while (count--) {
        int hi = hex_to_bin(*src++);
        int lo = hex_to_bin(*src++);
 
        if ((hi < 0) || (lo < 0))
            return -1;
 
        *dst++ = (hi << 4) | lo;
    }
    return 0;
}
EXPORT_SYMBOL(hex2bin);
 
/**
 * hex_dump_to_buffer - convert a blob of data to "hex ASCII" in memory
 * @buf: data blob to dump
 * @len: number of bytes in the @buf
 * @rowsize: number of bytes to print per line; must be 16 or 32
 * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
 * @linebuf: where to put the converted data
 * @linebuflen: total size of @linebuf, including space for terminating NUL
 * @ascii: include ASCII after the hex output
 *
 * hex_dump_to_buffer() works on one "line" of output at a time, i.e.,
 * 16 or 32 bytes of input data converted to hex + ASCII output.
 *
 * Given a buffer of u8 data, hex_dump_to_buffer() converts the input data
 * to a hex + ASCII dump at the supplied memory location.
 * The converted output is always NUL-terminated.
 *
 * E.g.:
 *   hex_dump_to_buffer(frame->data, frame->len, 16, 1,
 *          linebuf, sizeof(linebuf), true);
 *
 * example output buffer:
 * 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f  @ABCDEFGHIJKLMNO
 */
int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize,
               char *linebuf, size_t linebuflen, bool ascii)
 
{
    const u8 *ptr = buf;
    int ngroups;
    u8 ch;
    int j, lx = 0;
    int ascii_column;
    int ret;
 
    if (rowsize != 16 && rowsize != 32)
        rowsize = 16;
 
 
 
    if (len > rowsize)      /* limit to one line at a time */
        len = rowsize;
    if (!is_power_of_2(groupsize) || groupsize > 8)
        groupsize = 1;
    if ((len % groupsize) != 0) /* no mixed size output */
        groupsize = 1;
 
    ngroups = len / groupsize;
    ascii_column = rowsize * 2 + rowsize / groupsize + 1;
 
    if (!linebuflen)
        goto overflow1;
 
    if (!len)
        goto nil;
 
    if (groupsize == 8) {
 
        const u64 *ptr8 = buf;
 
        for (j = 0; j < ngroups; j++) {
            ret = snprintf(linebuf + lx, linebuflen - lx,
                       "%s%16.16llx", j ? " " : "",
                       (unsigned long long)*(ptr8 + j));
            if (ret >= linebuflen - lx)
                goto overflow1;
 
            lx += ret;
        }
 
    } else if (groupsize == 4) {
        const u32 *ptr4 = buf;
 
        for (j = 0; j < ngroups; j++) {
            ret = snprintf(linebuf + lx, linebuflen - lx,
                       "%s%8.8x", j ? " " : "",
                       *(ptr4 + j));
            if (ret >= linebuflen - lx)
 
                goto overflow1;
            lx += ret;
 
        }
    } else if (groupsize == 2) {
        const u16 *ptr2 = buf;
 
        for (j = 0; j < ngroups; j++) {
            ret = snprintf(linebuf + lx, linebuflen - lx,
                       "%s%4.4x", j ? " " : "",
                       *(ptr2 + j));
 
            if (ret >= linebuflen - lx)
                goto overflow1;
            lx += ret;
        }
    } else {
        for (j = 0; j < len; j++) {
            if (linebuflen < lx + 3)
                goto overflow2;
            ch = ptr[j];
            linebuf[lx++] = hex_asc_hi(ch);
            linebuf[lx++] = hex_asc_lo(ch);
            linebuf[lx++] = ' ';
        }
        if (j)
            lx--;
 
 
 
    }
    if (!ascii)
        goto nil;
 
    while (lx < ascii_column) {
        if (linebuflen < lx + 2)
            goto overflow2;
        linebuf[lx++] = ' ';
    }
    for (j = 0; j < len; j++) {
        if (linebuflen < lx + 2)
            goto overflow2;
        ch = ptr[j];
        linebuf[lx++] = (isascii(ch) && isprint(ch)) ? ch : '.';
    }
nil:
    linebuf[lx] = '\0';
    return lx;
overflow2:
    linebuf[lx++] = '\0';
overflow1:
    return ascii ? ascii_column + len : (groupsize * 2 + 1) * ngroups - 1;
}
 
/**
 * print_hex_dump - print a text hex dump to syslog for a binary blob of data
 * @level: kernel log level (e.g. KERN_DEBUG)
 * @prefix_str: string to prefix each line with;
 *  caller supplies trailing spaces for alignment if desired
 * @prefix_type: controls whether prefix of an offset, address, or none
 *  is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
 * @rowsize: number of bytes to print per line; must be 16 or 32
 * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
 * @buf: data blob to dump
 * @len: number of bytes in the @buf
 * @ascii: include ASCII after the hex output
 *
 * Given a buffer of u8 data, print_hex_dump() prints a hex + ASCII dump
 * to the kernel log at the specified kernel log level, with an optional
 * leading prefix.
 *
 * print_hex_dump() works on one "line" of output at a time, i.e.,
 * 16 or 32 bytes of input data converted to hex + ASCII output.
 * print_hex_dump() iterates over the entire input @buf, breaking it into
 * "line size" chunks to format and print.
 *
 * E.g.:
 *   print_hex_dump(KERN_DEBUG, "raw data: ", DUMP_PREFIX_ADDRESS,
 *          16, 1, frame->data, frame->len, true);
 *
 * Example output using %DUMP_PREFIX_OFFSET and 1-byte mode:
 * 0009ab42: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f  @ABCDEFGHIJKLMNO
 * Example output using %DUMP_PREFIX_ADDRESS and 4-byte mode:
 * ffffffff88089af0: 73727170 77767574 7b7a7978 7f7e7d7c  pqrstuvwxyz{|}~.
 */
void print_hex_dump(const char *level, const char *prefix_str, int prefix_type,
            int rowsize, int groupsize,
            const void *buf, size_t len, bool ascii)
{
    const u8 *ptr = buf;
    int i, linelen, remaining = len;
    unsigned char linebuf[32 * 3 + 2 + 32 + 1];
 
    if (rowsize != 16 && rowsize != 32)
        rowsize = 16;
 
    for (i = 0; i < len; i += rowsize) {
        linelen = min(remaining, rowsize);
        remaining -= rowsize;
 
        hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,
                   linebuf, sizeof(linebuf), ascii);
 
        switch (prefix_type) {
        case DUMP_PREFIX_ADDRESS:
            printk("%s%s%p: %s\n",
                   level, prefix_str, ptr + i, linebuf);
            break;
        case DUMP_PREFIX_OFFSET:
            printk("%s%s%.8x: %s\n", level, prefix_str, i, linebuf);
            break;
        default:
            printk("%s%s%s\n", level, prefix_str, linebuf);
            break;
        }
    }
}
 
void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
                          const void *buf, size_t len)
{
    print_hex_dump(KERN_DEBUG, prefix_str, prefix_type, 16, 1,
                       buf, len, true);
}
 
#define KMAP_MAX    256
 
static struct mutex kmap_mutex;
static struct page* kmap_table[KMAP_MAX];
static int kmap_av;
static int kmap_first;
static void* kmap_base;
 
 
int kmap_init()
{
    kmap_base = AllocKernelSpace(KMAP_MAX*4096);
    if(kmap_base == NULL)
        return -1;
 
    kmap_av = KMAP_MAX;
    MutexInit(&kmap_mutex);
    return 0;
};
 
void *kmap(struct page *page)
{
    void *vaddr = NULL;
    int i;
 
    do
    {
        MutexLock(&kmap_mutex);
        if(kmap_av != 0)
        {
            for(i = kmap_first; i < KMAP_MAX; i++)
            {
                if(kmap_table[i] == NULL)
                {
                    kmap_av--;
                    kmap_first = i;
                    kmap_table[i] = page;
                    vaddr = kmap_base + (i<<12);
                    MapPage(vaddr,(addr_t)page,3);
                    break;
                };
            };
        };
        MutexUnlock(&kmap_mutex);
    }while(vaddr == NULL);
 
    return vaddr;
};
 
void *kmap_atomic(struct page *page) __attribute__ ((alias ("kmap")));
 
void kunmap(struct page *page)
{
    void *vaddr;
    int   i;
 
    MutexLock(&kmap_mutex);
 
    for(i = 0; i < KMAP_MAX; i++)
    {
        if(kmap_table[i] == page)
        {
            kmap_av++;
            if(i < kmap_first)
                kmap_first = i;
            kmap_table[i] = NULL;
            vaddr = kmap_base + (i<<12);
            MapPage(vaddr,0,0);
            break;
        };
    };
 
    MutexUnlock(&kmap_mutex);
};
 
void kunmap_atomic(void *vaddr)
{
    int i;
 
    MapPage(vaddr,0,0);
 
    i = (vaddr - kmap_base) >> 12;
 
    MutexLock(&kmap_mutex);
 
    kmap_av++;
    if(i < kmap_first)
        kmap_first = i;
    kmap_table[i] = NULL;
 
    MutexUnlock(&kmap_mutex);
}
void msleep(unsigned int msecs)
{
    msecs /= 10;
    if(!msecs) msecs = 1;
 
     __asm__ __volatile__ (
     "call *__imp__Delay"
     ::"b" (msecs));
     __asm__ __volatile__ (
     "":::"ebx");
 
};
 
 
/* simple loop based delay: */
static void delay_loop(unsigned long loops)
{
        asm volatile(
                "       test %0,%0      \n"
                "       jz 3f           \n"
                "       jmp 1f          \n"
 
                ".align 16              \n"
                "1:     jmp 2f          \n"
 
                ".align 16              \n"
                "2:     dec %0          \n"
                "       jnz 2b          \n"
                "3:     dec %0          \n"
 
                : /* we don't need output */
                :"a" (loops)
        );
}
 
 
static void (*delay_fn)(unsigned long) = delay_loop;
 
void __delay(unsigned long loops)
{
        delay_fn(loops);
}
 
 
inline void __const_udelay(unsigned long xloops)
{
        int d0;
 
        xloops *= 4;
        asm("mull %%edx"
                : "=d" (xloops), "=&a" (d0)
                : "1" (xloops), ""
                (loops_per_jiffy * (HZ/4)));
 
        __delay(++xloops);
}
 
void __udelay(unsigned long usecs)
{
        __const_udelay(usecs * 0x000010c7); /* 2**32 / 1000000 (rounded up) */
}
 
unsigned int _sw_hweight32(unsigned int w)
{
#ifdef CONFIG_ARCH_HAS_FAST_MULTIPLIER
        w -= (w >> 1) & 0x55555555;
        w =  (w & 0x33333333) + ((w >> 2) & 0x33333333);
        w =  (w + (w >> 4)) & 0x0f0f0f0f;
        return (w * 0x01010101) >> 24;
#else
        unsigned int res = w - ((w >> 1) & 0x55555555);
        res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
        res = (res + (res >> 4)) & 0x0F0F0F0F;
        res = res + (res >> 8);
        return (res + (res >> 16)) & 0x000000FF;
#endif
}
EXPORT_SYMBOL(_sw_hweight32);
 
 
void usleep_range(unsigned long min, unsigned long max)
{
    udelay(max);
}
EXPORT_SYMBOL(usleep_range);
 
 
void *kmemdup(const void *src, size_t len, gfp_t gfp)
{
    void *p;
 
    p = kmalloc(len, gfp);
    if (p)
        memcpy(p, src, len);
    return p;
}
 
void cpu_detect1()
{
 
    u32 junk, tfms, cap0, misc;
    int i;
 
    cpuid(0x00000001, &tfms, &misc, &junk, &cap0);
 
    if (cap0 & (1<<19))
    {
        x86_clflush_size = ((misc >> 8) & 0xff) * 8;
    }
 
#if 0
    cpuid(0x80000002, (unsigned int*)&cpuinfo.model_name[0], (unsigned int*)&cpuinfo.model_name[4],
          (unsigned int*)&cpuinfo.model_name[8], (unsigned int*)&cpuinfo.model_name[12]);
    cpuid(0x80000003, (unsigned int*)&cpuinfo.model_name[16], (unsigned int*)&cpuinfo.model_name[20],
          (unsigned int*)&cpuinfo.model_name[24], (unsigned int*)&cpuinfo.model_name[28]);
    cpuid(0x80000004, (unsigned int*)&cpuinfo.model_name[32], (unsigned int*)&cpuinfo.model_name[36],
          (unsigned int*)&cpuinfo.model_name[40], (unsigned int*)&cpuinfo.model_name[44]);
 
    printf("\n%s\n\n",cpuinfo.model_name);
 
    cpuinfo.def_mtrr = read_msr(MSR_MTRRdefType);
    cpuinfo.mtrr_cap = read_msr(IA32_MTRRCAP);
 
    printf("MSR_MTRRdefType %016llx\n\n", cpuinfo.def_mtrr);
 
    cpuinfo.var_mtrr_count = (u8_t)cpuinfo.mtrr_cap;
 
    for(i = 0; i < cpuinfo.var_mtrr_count; i++)
    {
        u64_t mtrr_base;
        u64_t mtrr_mask;
 
        cpuinfo.var_mtrr[i].base = read_msr(MTRRphysBase_MSR(i));
        cpuinfo.var_mtrr[i].mask = read_msr(MTRRphysMask_MSR(i));
 
        printf("MTRR_%d base: %016llx mask: %016llx\n", i,
               cpuinfo.var_mtrr[i].base,
               cpuinfo.var_mtrr[i].mask);
    };
 
    unsigned int cr0, cr3, cr4, eflags;
 
    eflags = safe_cli();
 
    /* Enter the no-fill (CD=1, NW=0) cache mode and flush caches. */
    cr0 = read_cr0() | (1<<30);
    write_cr0(cr0);
    wbinvd();
 
    cr4 = read_cr4();
    write_cr4(cr4 & ~(1<<7));
 
    cr3 = read_cr3();
    write_cr3(cr3);
 
    /* Save MTRR state */
    rdmsr(MSR_MTRRdefType, deftype_lo, deftype_hi);
 
    /* Disable MTRRs, and set the default type to uncached */
    native_write_msr(MSR_MTRRdefType, deftype_lo & ~0xcff, deftype_hi);
    wbinvd();
 
    i = 0;
    set_mtrr(i++,0,0x80000000>>12,MTRR_WB);
    set_mtrr(i++,0x80000000>>12,0x40000000>>12,MTRR_WB);
    set_mtrr(i++,0xC0000000>>12,0x20000000>>12,MTRR_WB);
    set_mtrr(i++,0xdb800000>>12,0x00800000>>12,MTRR_UC);
    set_mtrr(i++,0xdc000000>>12,0x04000000>>12,MTRR_UC);
    set_mtrr(i++,0xE0000000>>12,0x10000000>>12,MTRR_WC);
 
    for(; i < cpuinfo.var_mtrr_count; i++)
        set_mtrr(i,0,0,0);
 
    write_cr3(cr3);
 
    /* Intel (P6) standard MTRRs */
    native_write_msr(MSR_MTRRdefType, deftype_lo, deftype_hi);
 
    /* Enable caches */
    write_cr0(read_cr0() & ~(1<<30));
 
    /* Restore value of CR4 */
    write_cr4(cr4);
 
    safe_sti(eflags);
 
    printf("\nnew MTRR map\n\n");
 
    for(i = 0; i < cpuinfo.var_mtrr_count; i++)
    {
        u64_t mtrr_base;
        u64_t mtrr_mask;
 
        cpuinfo.var_mtrr[i].base = read_msr(MTRRphysBase_MSR(i));
        cpuinfo.var_mtrr[i].mask = read_msr(MTRRphysMask_MSR(i));
 
        printf("MTRR_%d base: %016llx mask: %016llx\n", i,
               cpuinfo.var_mtrr[i].base,
               cpuinfo.var_mtrr[i].mask);
    };
#endif
 
    tsc_khz = (unsigned int)(GetCpuFreq()/1000);
}
 
 
static atomic_t fence_context_counter = ATOMIC_INIT(0);
 
/**
 * fence_context_alloc - allocate an array of fence contexts
 * @num:        [in]    amount of contexts to allocate
 *
 * This function will return the first index of the number of fences allocated.
 * The fence context is used for setting fence->context to a unique number.
 */
unsigned fence_context_alloc(unsigned num)
{
        BUG_ON(!num);
        return atomic_add_return(num, &fence_context_counter) - num;
}
EXPORT_SYMBOL(fence_context_alloc);
 
 
int fence_signal(struct fence *fence)
{
        unsigned long flags;
 
        if (!fence)
                return -EINVAL;
 
//        if (!ktime_to_ns(fence->timestamp)) {
//                fence->timestamp = ktime_get();
//                smp_mb__before_atomic();
//        }
 
        if (test_and_set_bit(FENCE_FLAG_SIGNALED_BIT, &fence->flags))
                return -EINVAL;
 
//        trace_fence_signaled(fence);
 
        if (test_bit(FENCE_FLAG_ENABLE_SIGNAL_BIT, &fence->flags)) {
                struct fence_cb *cur, *tmp;
 
                spin_lock_irqsave(fence->lock, flags);
                list_for_each_entry_safe(cur, tmp, &fence->cb_list, node) {
                        list_del_init(&cur->node);
                        cur->func(fence, cur);
                }
                spin_unlock_irqrestore(fence->lock, flags);
        }
        return 0;
}
EXPORT_SYMBOL(fence_signal);
 
int fence_signal_locked(struct fence *fence)
{
        struct fence_cb *cur, *tmp;
        int ret = 0;
 
        if (WARN_ON(!fence))
                return -EINVAL;
 
//        if (!ktime_to_ns(fence->timestamp)) {
//                fence->timestamp = ktime_get();
//                smp_mb__before_atomic();
//        }
 
        if (test_and_set_bit(FENCE_FLAG_SIGNALED_BIT, &fence->flags)) {
                ret = -EINVAL;
 
                /*
                 * we might have raced with the unlocked fence_signal,
                 * still run through all callbacks
                 */
        }// else
//                trace_fence_signaled(fence);
 
        list_for_each_entry_safe(cur, tmp, &fence->cb_list, node) {
                list_del_init(&cur->node);
                cur->func(fence, cur);
        }
        return ret;
}
EXPORT_SYMBOL(fence_signal_locked);
 
 
void fence_enable_sw_signaling(struct fence *fence)
{
        unsigned long flags;
 
        if (!test_and_set_bit(FENCE_FLAG_ENABLE_SIGNAL_BIT, &fence->flags) &&
            !test_bit(FENCE_FLAG_SIGNALED_BIT, &fence->flags)) {
//                trace_fence_enable_signal(fence);
 
                spin_lock_irqsave(fence->lock, flags);
 
                if (!fence->ops->enable_signaling(fence))
                        fence_signal_locked(fence);
 
                spin_unlock_irqrestore(fence->lock, flags);
        }
}
EXPORT_SYMBOL(fence_enable_sw_signaling);
 
 
 
signed long
fence_wait_timeout(struct fence *fence, bool intr, signed long timeout)
{
        signed long ret;
 
        if (WARN_ON(timeout < 0))
                return -EINVAL;
 
//        trace_fence_wait_start(fence);
        ret = fence->ops->wait(fence, intr, timeout);
//        trace_fence_wait_end(fence);
        return ret;
}
EXPORT_SYMBOL(fence_wait_timeout);
 
void fence_release(struct kref *kref)
{
        struct fence *fence =
                        container_of(kref, struct fence, refcount);
 
//        trace_fence_destroy(fence);
 
        BUG_ON(!list_empty(&fence->cb_list));
 
        if (fence->ops->release)
                fence->ops->release(fence);
        else
                fence_free(fence);
}
EXPORT_SYMBOL(fence_release);
 
void fence_free(struct fence *fence)
{
        kfree_rcu(fence, rcu);
}
EXPORT_SYMBOL(fence_free);
 
 
reservation_object_add_shared_inplace(struct reservation_object *obj,
                                      struct reservation_object_list *fobj,
                                      struct fence *fence)
{
        u32 i;
 
        fence_get(fence);
 
//        preempt_disable();
        write_seqcount_begin(&obj->seq);
 
        for (i = 0; i < fobj->shared_count; ++i) {
                struct fence *old_fence;
 
                old_fence = rcu_dereference_protected(fobj->shared[i],
                                                reservation_object_held(obj));
 
                if (old_fence->context == fence->context) {
                        /* memory barrier is added by write_seqcount_begin */
                        RCU_INIT_POINTER(fobj->shared[i], fence);
                        write_seqcount_end(&obj->seq);
                        preempt_enable();
 
                        fence_put(old_fence);
                        return;
                }
        }
 
        /*
         * memory barrier is added by write_seqcount_begin,
         * fobj->shared_count is protected by this lock too
         */
        RCU_INIT_POINTER(fobj->shared[fobj->shared_count], fence);
        fobj->shared_count++;
 
        write_seqcount_end(&obj->seq);
//        preempt_enable();
}
 
 
 
static void
reservation_object_add_shared_replace(struct reservation_object *obj,
                                      struct reservation_object_list *old,
                                      struct reservation_object_list *fobj,
                                      struct fence *fence)
{
        unsigned i;
        struct fence *old_fence = NULL;
 
        fence_get(fence);
 
        if (!old) {
                RCU_INIT_POINTER(fobj->shared[0], fence);
                fobj->shared_count = 1;
                goto done;
        }
 
        /*
         * no need to bump fence refcounts, rcu_read access
         * requires the use of kref_get_unless_zero, and the
         * references from the old struct are carried over to
         * the new.
         */
        fobj->shared_count = old->shared_count;
 
        for (i = 0; i < old->shared_count; ++i) {
                struct fence *check;
 
                check = rcu_dereference_protected(old->shared[i],
                                                reservation_object_held(obj));
 
                if (!old_fence && check->context == fence->context) {
                        old_fence = check;
                        RCU_INIT_POINTER(fobj->shared[i], fence);
                } else
                        RCU_INIT_POINTER(fobj->shared[i], check);
        }
        if (!old_fence) {
                RCU_INIT_POINTER(fobj->shared[fobj->shared_count], fence);
                fobj->shared_count++;
        }
 
done:
//        preempt_disable();
        write_seqcount_begin(&obj->seq);
        /*
         * RCU_INIT_POINTER can be used here,
         * seqcount provides the necessary barriers
         */
        RCU_INIT_POINTER(obj->fence, fobj);
        write_seqcount_end(&obj->seq);
//        preempt_enable();
 
        if (old)
                kfree_rcu(old, rcu);
 
        if (old_fence)
                fence_put(old_fence);
}
 
 
int reservation_object_reserve_shared(struct reservation_object *obj)
{
        struct reservation_object_list *fobj, *old;
        u32 max;
 
        old = reservation_object_get_list(obj);
 
        if (old && old->shared_max) {
                if (old->shared_count < old->shared_max) {
                        /* perform an in-place update */
                        kfree(obj->staged);
                        obj->staged = NULL;
                        return 0;
                } else
                        max = old->shared_max * 2;
        } else
                max = 4;
 
        /*
         * resize obj->staged or allocate if it doesn't exist,
         * noop if already correct size
         */
        fobj = krealloc(obj->staged, offsetof(typeof(*fobj), shared[max]),
                        GFP_KERNEL);
        if (!fobj)
                return -ENOMEM;
 
        obj->staged = fobj;
        fobj->shared_max = max;
        return 0;
}
EXPORT_SYMBOL(reservation_object_reserve_shared);
 
void reservation_object_add_shared_fence(struct reservation_object *obj,
                                         struct fence *fence)
{
        struct reservation_object_list *old, *fobj = obj->staged;
 
        old = reservation_object_get_list(obj);
        obj->staged = NULL;
 
        if (!fobj) {
                BUG_ON(old->shared_count >= old->shared_max);
                reservation_object_add_shared_inplace(obj, old, fence);
        } else
                reservation_object_add_shared_replace(obj, old, fobj, fence);
}
EXPORT_SYMBOL(reservation_object_add_shared_fence);
 
 
void reservation_object_add_excl_fence(struct reservation_object *obj,
                                       struct fence *fence)
{
        struct fence *old_fence = reservation_object_get_excl(obj);
        struct reservation_object_list *old;
        u32 i = 0;
 
        old = reservation_object_get_list(obj);
        if (old)
                i = old->shared_count;
 
        if (fence)
                fence_get(fence);
 
//        preempt_disable();
        write_seqcount_begin(&obj->seq);
        /* write_seqcount_begin provides the necessary memory barrier */
        RCU_INIT_POINTER(obj->fence_excl, fence);
        if (old)
                old->shared_count = 0;
        write_seqcount_end(&obj->seq);
//        preempt_enable();
 
        /* inplace update, no shared fences */
        while (i--)
                fence_put(rcu_dereference_protected(old->shared[i],
                                                reservation_object_held(obj)));
 
        if (old_fence)
                fence_put(old_fence);
}
EXPORT_SYMBOL(reservation_object_add_excl_fence);
 
void
fence_init(struct fence *fence, const struct fence_ops *ops,
             spinlock_t *lock, unsigned context, unsigned seqno)
{
        BUG_ON(!lock);
        BUG_ON(!ops || !ops->wait || !ops->enable_signaling ||
               !ops->get_driver_name || !ops->get_timeline_name);
 
        kref_init(&fence->refcount);
        fence->ops = ops;
        INIT_LIST_HEAD(&fence->cb_list);
        fence->lock = lock;
        fence->context = context;
        fence->seqno = seqno;
        fence->flags = 0UL;
 
//        trace_fence_init(fence);
}
EXPORT_SYMBOL(fence_init);
 
 
#include 
 
struct rcu_ctrlblk {
        struct rcu_head *rcucblist;     /* List of pending callbacks (CBs). */
        struct rcu_head **donetail;     /* ->next pointer of last "done" CB. */
        struct rcu_head **curtail;      /* ->next pointer of last CB. */
//        RCU_TRACE(long qlen);           /* Number of pending CBs. */
//        RCU_TRACE(unsigned long gp_start); /* Start time for stalls. */
//        RCU_TRACE(unsigned long ticks_this_gp); /* Statistic for stalls. */
//        RCU_TRACE(unsigned long jiffies_stall); /* Jiffies at next stall. */
//        RCU_TRACE(const char *name);    /* Name of RCU type. */
};
 
/* Definition for rcupdate control block. */
static struct rcu_ctrlblk rcu_sched_ctrlblk = {
        .donetail       = &rcu_sched_ctrlblk.rcucblist,
        .curtail        = &rcu_sched_ctrlblk.rcucblist,
//        RCU_TRACE(.name = "rcu_sched")
};
 
static void __call_rcu(struct rcu_head *head,
                       void (*func)(struct rcu_head *rcu),
                       struct rcu_ctrlblk *rcp)
{
        unsigned long flags;
 
//        debug_rcu_head_queue(head);
        head->func = func;
        head->next = NULL;
 
        local_irq_save(flags);
        *rcp->curtail = head;
        rcp->curtail = &head->next;
//        RCU_TRACE(rcp->qlen++);
        local_irq_restore(flags);
}
 
/*
 * Post an RCU callback to be invoked after the end of an RCU-sched grace
 * period.  But since we have but one CPU, that would be after any
 * quiescent state.
 */
void call_rcu_sched(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
{
        __call_rcu(head, func, &rcu_sched_ctrlblk);
}
 
fb_get_options(const char *name, char **option)
{
    return 1;
 
}
 
ktime_t ktime_get(void)
{
    ktime_t t;
 
    t.tv64 = GetClockNs();
 
    return t;
}
 
void radeon_cursor_reset(struct drm_crtc *crtc)
{
 
}
 
/* Greatest common divisor */
unsigned long gcd(unsigned long a, unsigned long b)
{
        unsigned long r;
 
        if (a < b)
                swap(a, b);
 
        if (!b)
                return a;
        while ((r = a % b) != 0) {
                a = b;
                b = r;
        }
        return b;
}
 
>
 
>
 
>
 
>
>
>
>
>
>
>
>
>
#define>

Rev 5271	Rev 6104
1	#include	1	#include
2	#include	2	#include
3	#include	3	#include
4	#include	4	#include
5	#include "radeon.h"	5	#include "radeon.h"
6		6
7	int x86_clflush_size;	7	int x86_clflush_size;
8	unsigned int tsc_khz;	8	unsigned int tsc_khz;
9		9
10	struct file shmem_file_setup(const char name, loff_t size, unsigned long flags)	10	struct file shmem_file_setup(const char name, loff_t size, unsigned long flags)
11	{	11	{
12	struct file *filep;	12	struct file *filep;
13	int count;	13	int count;
14		14
15	filep = __builtin_malloc(sizeof(*filep));	15	filep = __builtin_malloc(sizeof(*filep));
16		16
17	if(unlikely(filep == NULL))	17	if(unlikely(filep == NULL))
18	return ERR_PTR(-ENOMEM);	18	return ERR_PTR(-ENOMEM);
19		19
20	count = size / PAGE_SIZE;	20	count = size / PAGE_SIZE;
21		21
22	filep->pages = kzalloc(sizeof(struct page ) count, 0);	22	filep->pages = kzalloc(sizeof(struct page ) count, 0);
23	if(unlikely(filep->pages == NULL))	23	if(unlikely(filep->pages == NULL))
24	{	24	{
25	kfree(filep);	25	kfree(filep);
26	return ERR_PTR(-ENOMEM);	26	return ERR_PTR(-ENOMEM);
27	};	27	};
28		28
29	filep->count = count;	29	filep->count = count;
30	filep->allocated = 0;	30	filep->allocated = 0;
31	filep->vma = NULL;	31	filep->vma = NULL;
32		32
33	// printf("%s file %p pages %p count %d\n",	33	// printf("%s file %p pages %p count %d\n",
34	// __FUNCTION__,filep, filep->pages, count);	34	// __FUNCTION__,filep, filep->pages, count);
35		35
36	return filep;	36	return filep;
37	}	37	}
38		38
39	static void check_bytes8(const u8 start, u8 value, unsigned int bytes)	39	static void check_bytes8(const u8 start, u8 value, unsigned int bytes)
40	{	40	{
41	while (bytes) {	41	while (bytes) {
42	if (*start != value)	42	if (*start != value)
43	return (void *)start;	43	return (void *)start;
44	start++;	44	start++;
45	bytes--;	45	bytes--;
46	}	46	}
47	return NULL;	47	return NULL;
48	}	48	}
49		49
50	/**	50	/**
51	* memchr_inv - Find an unmatching character in an area of memory.	51	* memchr_inv - Find an unmatching character in an area of memory.
52	* @start: The memory area	52	* @start: The memory area
53	* @c: Find a character other than c	53	* @c: Find a character other than c
54	* @bytes: The size of the area.	54	* @bytes: The size of the area.
55	*	55	*
56	* returns the address of the first character other than @c, or %NULL	56	* returns the address of the first character other than @c, or %NULL
57	* if the whole buffer contains just @c.	57	* if the whole buffer contains just @c.
58	*/	58	*/
59	void memchr_inv(const void start, int c, size_t bytes)	59	void memchr_inv(const void start, int c, size_t bytes)
60	{	60	{
61	u8 value = c;	61	u8 value = c;
62	u64 value64;	62	u64 value64;
63	unsigned int words, prefix;	63	unsigned int words, prefix;
64		64
65	if (bytes <= 16)	65	if (bytes <= 16)
66	return check_bytes8(start, value, bytes);	66	return check_bytes8(start, value, bytes);
67		67
68	value64 = value;	68	value64 = value;
69	#if defined(ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64	69	#if defined(ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
70	value64 *= 0x0101010101010101;	70	value64 *= 0x0101010101010101;
71	#elif defined(ARCH_HAS_FAST_MULTIPLIER)	71	#elif defined(ARCH_HAS_FAST_MULTIPLIER)
72	value64 *= 0x01010101;	72	value64 *= 0x01010101;
73	value64 \|= value64 << 32;	73	value64 \|= value64 << 32;
74	#else	74	#else
75	value64 \|= value64 << 8;	75	value64 \|= value64 << 8;
76	value64 \|= value64 << 16;	76	value64 \|= value64 << 16;
77	value64 \|= value64 << 32;	77	value64 \|= value64 << 32;
78	#endif	78	#endif
79		79
80	prefix = (unsigned long)start % 8;	80	prefix = (unsigned long)start % 8;
81	if (prefix) {	81	if (prefix) {
82	u8 *r;	82	u8 *r;
83		83
84	prefix = 8 - prefix;	84	prefix = 8 - prefix;
85	r = check_bytes8(start, value, prefix);	85	r = check_bytes8(start, value, prefix);
86	if (r)	86	if (r)
87	return r;	87	return r;
88	start += prefix;	88	start += prefix;
89	bytes -= prefix;	89	bytes -= prefix;
90	}	90	}
91		91
92	words = bytes / 8;	92	words = bytes / 8;
93		93
94	while (words) {	94	while (words) {
95	if ((u64 )start != value64)	95	if ((u64 )start != value64)
96	return check_bytes8(start, value, 8);	96	return check_bytes8(start, value, 8);
97	start += 8;	97	start += 8;
98	words--;	98	words--;
99	}	99	}
100		100
101	return check_bytes8(start, value, bytes % 8);	101	return check_bytes8(start, value, bytes % 8);
102	}	102	}
103		103
104		104
105		105
106	#define _U 0x01 /* upper */	106	#define _U 0x01 /* upper */
107	#define _L 0x02 /* lower */	107	#define _L 0x02 /* lower */
108	#define _D 0x04 /* digit */	108	#define _D 0x04 /* digit */
109	#define _C 0x08 /* cntrl */	109	#define _C 0x08 /* cntrl */
110	#define _P 0x10 /* punct */	110	#define _P 0x10 /* punct */
111	#define _S 0x20 /* white space (space/lf/tab) */	111	#define _S 0x20 /* white space (space/lf/tab) */
112	#define _X 0x40 /* hex digit */	112	#define _X 0x40 /* hex digit */
113	#define _SP 0x80 /* hard space (0x20) */	113	#define _SP 0x80 /* hard space (0x20) */
114		114
115	extern const unsigned char _ctype[];	115	extern const unsigned char _ctype[];
116		116
117	#define __ismask(x) (_ctype[(int)(unsigned char)(x)])	117	#define __ismask(x) (_ctype[(int)(unsigned char)(x)])
118		118
119	#define isalnum(c) ((__ismask(c)&(_U\|_L\|_D)) != 0)	119	#define isalnum(c) ((__ismask(c)&(_U\|_L\|_D)) != 0)
120	#define isalpha(c) ((__ismask(c)&(_U\|_L)) != 0)	120	#define isalpha(c) ((__ismask(c)&(_U\|_L)) != 0)
121	#define iscntrl(c) ((__ismask(c)&(_C)) != 0)	121	#define iscntrl(c) ((__ismask(c)&(_C)) != 0)
122	#define isdigit(c) ((__ismask(c)&(_D)) != 0)	122	#define isdigit(c) ((__ismask(c)&(_D)) != 0)
123	#define isgraph(c) ((__ismask(c)&(_P\|_U\|_L\|_D)) != 0)	123	#define isgraph(c) ((__ismask(c)&(_P\|_U\|_L\|_D)) != 0)
124	#define islower(c) ((__ismask(c)&(_L)) != 0)	124	#define islower(c) ((__ismask(c)&(_L)) != 0)
125	#define isprint(c) ((__ismask(c)&(_P\|_U\|_L\|_D\|_SP)) != 0)	125	#define isprint(c) ((__ismask(c)&(_P\|_U\|_L\|_D\|_SP)) != 0)
126	#define ispunct(c) ((__ismask(c)&(_P)) != 0)	126	#define ispunct(c) ((__ismask(c)&(_P)) != 0)
127	/* Note: isspace() must return false for %NUL-terminator */	127	/* Note: isspace() must return false for %NUL-terminator */
128	#define isspace(c) ((__ismask(c)&(_S)) != 0)	128	#define isspace(c) ((__ismask(c)&(_S)) != 0)
129	#define isupper(c) ((__ismask(c)&(_U)) != 0)	129	#define isupper(c) ((__ismask(c)&(_U)) != 0)
130	#define isxdigit(c) ((__ismask(c)&(_D\|_X)) != 0)	130	#define isxdigit(c) ((__ismask(c)&(_D\|_X)) != 0)
131		131
132	#define isascii(c) (((unsigned char)(c))<=0x7f)	132	#define isascii(c) (((unsigned char)(c))<=0x7f)
133	#define toascii(c) (((unsigned char)(c))&0x7f)	133	#define toascii(c) (((unsigned char)(c))&0x7f)
134		134
135	static inline unsigned char __tolower(unsigned char c)	135	static inline unsigned char __tolower(unsigned char c)
136	{	136	{
137	if (isupper(c))	137	if (isupper(c))
138	c -= 'A'-'a';	138	c -= 'A'-'a';
139	return c;	139	return c;
140	}	140	}
141		141
142	static inline unsigned char __toupper(unsigned char c)	142	static inline unsigned char __toupper(unsigned char c)
143	{	143	{
144	if (islower(c))	144	if (islower(c))
145	c -= 'a'-'A';	145	c -= 'a'-'A';
146	return c;	146	return c;
147	}	147	}
148		148
149	#define tolower(c) __tolower(c)	149	#define tolower(c) __tolower(c)
150	#define toupper(c) __toupper(c)	150	#define toupper(c) __toupper(c)
151		151
152	/*	152	/*
153	* Fast implementation of tolower() for internal usage. Do not use in your	153	* Fast implementation of tolower() for internal usage. Do not use in your
154	* code.	154	* code.
155	*/	155	*/
156	static inline char _tolower(const char c)	156	static inline char _tolower(const char c)
157	{	157	{
158	return c \| 0x20;	158	return c \| 0x20;
159	}	159	}
160		160
161		161
162	//const char hex_asc[] = "0123456789abcdef";	162	//const char hex_asc[] = "0123456789abcdef";
163		163
164	/**	164	/**
165	* hex_to_bin - convert a hex digit to its real value	165	* hex_to_bin - convert a hex digit to its real value
166	* @ch: ascii character represents hex digit	166	* @ch: ascii character represents hex digit
167	*	167	*
168	* hex_to_bin() converts one hex digit to its actual value or -1 in case of bad	168	* hex_to_bin() converts one hex digit to its actual value or -1 in case of bad
169	* input.	169	* input.
170	*/	170	*/
171	int hex_to_bin(char ch)	171	int hex_to_bin(char ch)
172	{	172	{
173	if ((ch >= '0') && (ch <= '9'))	173	if ((ch >= '0') && (ch <= '9'))
174	return ch - '0';	174	return ch - '0';
175	ch = tolower(ch);	175	ch = tolower(ch);
176	if ((ch >= 'a') && (ch <= 'f'))	176	if ((ch >= 'a') && (ch <= 'f'))
177	return ch - 'a' + 10;	177	return ch - 'a' + 10;
178	return -1;	178	return -1;
179	}	179	}
180	EXPORT_SYMBOL(hex_to_bin);	180	EXPORT_SYMBOL(hex_to_bin);
181		181
182	/**	182	/**
183	* hex2bin - convert an ascii hexadecimal string to its binary representation	183	* hex2bin - convert an ascii hexadecimal string to its binary representation
184	* @dst: binary result	184	* @dst: binary result
185	* @src: ascii hexadecimal string	185	* @src: ascii hexadecimal string
186	* @count: result length	186	* @count: result length
187	*	187	*
188	* Return 0 on success, -1 in case of bad input.	188	* Return 0 on success, -1 in case of bad input.
189	*/	189	*/
190	int hex2bin(u8 dst, const char src, size_t count)	190	int hex2bin(u8 dst, const char src, size_t count)
191	{	191	{
192	while (count--) {	192	while (count--) {
193	int hi = hex_to_bin(*src++);	193	int hi = hex_to_bin(*src++);
194	int lo = hex_to_bin(*src++);	194	int lo = hex_to_bin(*src++);
195		195
196	if ((hi < 0) \|\| (lo < 0))	196	if ((hi < 0) \|\| (lo < 0))
197	return -1;	197	return -1;
198		198
199	*dst++ = (hi << 4) \| lo;	199	*dst++ = (hi << 4) \| lo;
200	}	200	}
201	return 0;	201	return 0;
202	}	202	}
203	EXPORT_SYMBOL(hex2bin);	203	EXPORT_SYMBOL(hex2bin);
204		204
205	/**	205	/**
206	* hex_dump_to_buffer - convert a blob of data to "hex ASCII" in memory	206	* hex_dump_to_buffer - convert a blob of data to "hex ASCII" in memory
207	* @buf: data blob to dump	207	* @buf: data blob to dump
208	* @len: number of bytes in the @buf	208	* @len: number of bytes in the @buf
209	* @rowsize: number of bytes to print per line; must be 16 or 32	209	* @rowsize: number of bytes to print per line; must be 16 or 32
210	* @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)	210	* @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
211	* @linebuf: where to put the converted data	211	* @linebuf: where to put the converted data
212	* @linebuflen: total size of @linebuf, including space for terminating NUL	212	* @linebuflen: total size of @linebuf, including space for terminating NUL
213	* @ascii: include ASCII after the hex output	213	* @ascii: include ASCII after the hex output
214	*	214	*
215	* hex_dump_to_buffer() works on one "line" of output at a time, i.e.,	215	* hex_dump_to_buffer() works on one "line" of output at a time, i.e.,
216	* 16 or 32 bytes of input data converted to hex + ASCII output.	216	* 16 or 32 bytes of input data converted to hex + ASCII output.
217	*	217	*
218	* Given a buffer of u8 data, hex_dump_to_buffer() converts the input data	218	* Given a buffer of u8 data, hex_dump_to_buffer() converts the input data
219	* to a hex + ASCII dump at the supplied memory location.	219	* to a hex + ASCII dump at the supplied memory location.
220	* The converted output is always NUL-terminated.	220	* The converted output is always NUL-terminated.
221	*	221	*
222	* E.g.:	222	* E.g.:
223	* hex_dump_to_buffer(frame->data, frame->len, 16, 1,	223	* hex_dump_to_buffer(frame->data, frame->len, 16, 1,
224	* linebuf, sizeof(linebuf), true);	224	* linebuf, sizeof(linebuf), true);
225	*	225	*
226	* example output buffer:	226	* example output buffer:
227	* 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO	227	* 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO
228	*/	228	*/
229	void hex_dump_to_buffer(const void *buf, size_t len, int rowsize,	229	int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize,
230	int groupsize, char *linebuf, size_t linebuflen,	230	char *linebuf, size_t linebuflen, bool ascii)
231	bool ascii)	-
232	{	231	{
233	const u8 *ptr = buf;	232	const u8 *ptr = buf;
-		233	int ngroups;
234	u8 ch;	234	u8 ch;
235	int j, lx = 0;	235	int j, lx = 0;
236	int ascii_column;	236	int ascii_column;
-		237	int ret;
237		238
238	if (rowsize != 16 && rowsize != 32)	239	if (rowsize != 16 && rowsize != 32)
239	rowsize = 16;	240	rowsize = 16;
240		-
241	if (!len)	-
242	goto nil;	241
243	if (len > rowsize) /* limit to one line at a time */	242	if (len > rowsize) /* limit to one line at a time */
-		243	len = rowsize;
-		244	if (!is_power_of_2(groupsize) \|\| groupsize > 8)
244	len = rowsize;	245	groupsize = 1;
245	if ((len % groupsize) != 0) /* no mixed size output */	246	if ((len % groupsize) != 0) /* no mixed size output */
246	groupsize = 1;	247	groupsize = 1;
247		248
-		249	ngroups = len / groupsize;
-		250	ascii_column = rowsize * 2 + rowsize / groupsize + 1;
-		251
-		252	if (!linebuflen)
-		253	goto overflow1;
248	switch (groupsize) {	254
-		255	if (!len)
-		256	goto nil;
-		257
249	case 8: {	258	if (groupsize == 8) {
250	const u64 *ptr8 = buf;	-
251	int ngroups = len / groupsize;	259	const u64 *ptr8 = buf;
252		260
253	for (j = 0; j < ngroups; j++)	261	for (j = 0; j < ngroups; j++) {
254	lx += scnprintf(linebuf + lx, linebuflen - lx,	262	ret = snprintf(linebuf + lx, linebuflen - lx,
255	"%s%16.16llx", j ? " " : "",	263	"%s%16.16llx", j ? " " : "",
-		264	(unsigned long long)*(ptr8 + j));
256	(unsigned long long)*(ptr8 + j));	265	if (ret >= linebuflen - lx)
257	ascii_column = 17 * ngroups + 2;	266	goto overflow1;
258	break;	-
259	}	267	lx += ret;
260		268	}
261	case 4: {	-
262	const u32 *ptr4 = buf;	269	} else if (groupsize == 4) {
263	int ngroups = len / groupsize;	270	const u32 *ptr4 = buf;
264		271
265	for (j = 0; j < ngroups; j++)	272	for (j = 0; j < ngroups; j++) {
-		273	ret = snprintf(linebuf + lx, linebuflen - lx,
-		274	"%s%8.8x", j ? " " : "",
266	lx += scnprintf(linebuf + lx, linebuflen - lx,	275	*(ptr4 + j));
267	"%s%8.8x", j ? " " : "", *(ptr4 + j));	276	if (ret >= linebuflen - lx)
268	ascii_column = 9 * ngroups + 2;	-
269	break;	277	goto overflow1;
270	}	278	lx += ret;
271		-
272	case 2: {	279	}
273	const u16 *ptr2 = buf;	280	} else if (groupsize == 2) {
274	int ngroups = len / groupsize;	281	const u16 *ptr2 = buf;
275		282
-		283	for (j = 0; j < ngroups; j++) {
-		284	ret = snprintf(linebuf + lx, linebuflen - lx,
276	for (j = 0; j < ngroups; j++)	285	"%s%4.4x", j ? " " : "",
277	lx += scnprintf(linebuf + lx, linebuflen - lx,	286	*(ptr2 + j));
278	"%s%4.4x", j ? " " : "", *(ptr2 + j));	-
279	ascii_column = 5 * ngroups + 2;	287	if (ret >= linebuflen - lx)
280	break;	288	goto overflow1;
-		289	lx += ret;
-		290	}
281	}	291	} else {
282		292	for (j = 0; j < len; j++) {
283	default:	293	if (linebuflen < lx + 3)
284	for (j = 0; (j < len) && (lx + 3) <= linebuflen; j++) {	294	goto overflow2;
285	ch = ptr[j];	295	ch = ptr[j];
286	linebuf[lx++] = hex_asc_hi(ch);	296	linebuf[lx++] = hex_asc_hi(ch);
287	linebuf[lx++] = hex_asc_lo(ch);	297	linebuf[lx++] = hex_asc_lo(ch);
288	linebuf[lx++] = ' ';	298	linebuf[lx++] = ' ';
289	}	299	}
290	if (j)	300	if (j)
291	lx--;	301	lx--;
292		-
293	ascii_column = 3 * rowsize + 2;	-
294	break;	-
295	}	302	}
296	if (!ascii)	303	if (!ascii)
297	goto nil;	304	goto nil;
298		305
-		306	while (lx < ascii_column) {
-		307	if (linebuflen < lx + 2)
299	while (lx < (linebuflen - 1) && lx < (ascii_column - 1))	308	goto overflow2;
-		309	linebuf[lx++] = ' ';
300	linebuf[lx++] = ' ';	310	}
-		311	for (j = 0; j < len; j++) {
-		312	if (linebuflen < lx + 2)
301	for (j = 0; (j < len) && (lx + 2) < linebuflen; j++) {	313	goto overflow2;
302	ch = ptr[j];	314	ch = ptr[j];
303	linebuf[lx++] = (isascii(ch) && isprint(ch)) ? ch : '.';	315	linebuf[lx++] = (isascii(ch) && isprint(ch)) ? ch : '.';
304	}	316	}
305	nil:	317	nil:
-		318	linebuf[lx] = '\0';
-		319	return lx;
-		320	overflow2:
306	linebuf[lx++] = '\0';	321	linebuf[lx++] = '\0';
-		322	overflow1:
-		323	return ascii ? ascii_column + len : (groupsize * 2 + 1) * ngroups - 1;
307	}	324	}
308		-
309	/**	325	/**
310	* print_hex_dump - print a text hex dump to syslog for a binary blob of data	326	* print_hex_dump - print a text hex dump to syslog for a binary blob of data
311	* @level: kernel log level (e.g. KERN_DEBUG)	327	* @level: kernel log level (e.g. KERN_DEBUG)
312	* @prefix_str: string to prefix each line with;	328	* @prefix_str: string to prefix each line with;
313	* caller supplies trailing spaces for alignment if desired	329	* caller supplies trailing spaces for alignment if desired
314	* @prefix_type: controls whether prefix of an offset, address, or none	330	* @prefix_type: controls whether prefix of an offset, address, or none
315	* is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)	331	* is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
316	* @rowsize: number of bytes to print per line; must be 16 or 32	332	* @rowsize: number of bytes to print per line; must be 16 or 32
317	* @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)	333	* @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
318	* @buf: data blob to dump	334	* @buf: data blob to dump
319	* @len: number of bytes in the @buf	335	* @len: number of bytes in the @buf
320	* @ascii: include ASCII after the hex output	336	* @ascii: include ASCII after the hex output
321	*	337	*
322	* Given a buffer of u8 data, print_hex_dump() prints a hex + ASCII dump	338	* Given a buffer of u8 data, print_hex_dump() prints a hex + ASCII dump
323	* to the kernel log at the specified kernel log level, with an optional	339	* to the kernel log at the specified kernel log level, with an optional
324	* leading prefix.	340	* leading prefix.
325	*	341	*
326	* print_hex_dump() works on one "line" of output at a time, i.e.,	342	* print_hex_dump() works on one "line" of output at a time, i.e.,
327	* 16 or 32 bytes of input data converted to hex + ASCII output.	343	* 16 or 32 bytes of input data converted to hex + ASCII output.
328	* print_hex_dump() iterates over the entire input @buf, breaking it into	344	* print_hex_dump() iterates over the entire input @buf, breaking it into
329	* "line size" chunks to format and print.	345	* "line size" chunks to format and print.
330	*	346	*
331	* E.g.:	347	* E.g.:
332	* print_hex_dump(KERN_DEBUG, "raw data: ", DUMP_PREFIX_ADDRESS,	348	* print_hex_dump(KERN_DEBUG, "raw data: ", DUMP_PREFIX_ADDRESS,
333	* 16, 1, frame->data, frame->len, true);	349	* 16, 1, frame->data, frame->len, true);
334	*	350	*
335	* Example output using %DUMP_PREFIX_OFFSET and 1-byte mode:	351	* Example output using %DUMP_PREFIX_OFFSET and 1-byte mode:
336	* 0009ab42: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO	352	* 0009ab42: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO
337	* Example output using %DUMP_PREFIX_ADDRESS and 4-byte mode:	353	* Example output using %DUMP_PREFIX_ADDRESS and 4-byte mode:
338	* ffffffff88089af0: 73727170 77767574 7b7a7978 7f7e7d7c pqrstuvwxyz{\|}~.	354	* ffffffff88089af0: 73727170 77767574 7b7a7978 7f7e7d7c pqrstuvwxyz{\|}~.
339	*/	355	*/
340	void print_hex_dump(const char level, const char prefix_str, int prefix_type,	356	void print_hex_dump(const char level, const char prefix_str, int prefix_type,
341	int rowsize, int groupsize,	357	int rowsize, int groupsize,
342	const void *buf, size_t len, bool ascii)	358	const void *buf, size_t len, bool ascii)
343	{	359	{
344	const u8 *ptr = buf;	360	const u8 *ptr = buf;
345	int i, linelen, remaining = len;	361	int i, linelen, remaining = len;
346	unsigned char linebuf[32 * 3 + 2 + 32 + 1];	362	unsigned char linebuf[32 * 3 + 2 + 32 + 1];
347		363
348	if (rowsize != 16 && rowsize != 32)	364	if (rowsize != 16 && rowsize != 32)
349	rowsize = 16;	365	rowsize = 16;
350		366
351	for (i = 0; i < len; i += rowsize) {	367	for (i = 0; i < len; i += rowsize) {
352	linelen = min(remaining, rowsize);	368	linelen = min(remaining, rowsize);
353	remaining -= rowsize;	369	remaining -= rowsize;
354		370
355	hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,	371	hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,
356	linebuf, sizeof(linebuf), ascii);	372	linebuf, sizeof(linebuf), ascii);
357		373
358	switch (prefix_type) {	374	switch (prefix_type) {
359	case DUMP_PREFIX_ADDRESS:	375	case DUMP_PREFIX_ADDRESS:
360	printk("%s%s%p: %s\n",	376	printk("%s%s%p: %s\n",
361	level, prefix_str, ptr + i, linebuf);	377	level, prefix_str, ptr + i, linebuf);
362	break;	378	break;
363	case DUMP_PREFIX_OFFSET:	379	case DUMP_PREFIX_OFFSET:
364	printk("%s%s%.8x: %s\n", level, prefix_str, i, linebuf);	380	printk("%s%s%.8x: %s\n", level, prefix_str, i, linebuf);
365	break;	381	break;
366	default:	382	default:
367	printk("%s%s%s\n", level, prefix_str, linebuf);	383	printk("%s%s%s\n", level, prefix_str, linebuf);
368	break;	384	break;
369	}	385	}
370	}	386	}
371	}	387	}
372		388
373	void print_hex_dump_bytes(const char *prefix_str, int prefix_type,	389	void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
374	const void *buf, size_t len)	390	const void *buf, size_t len)
375	{	391	{
376	print_hex_dump(KERN_DEBUG, prefix_str, prefix_type, 16, 1,	392	print_hex_dump(KERN_DEBUG, prefix_str, prefix_type, 16, 1,
377	buf, len, true);	393	buf, len, true);
378	}	394	}
-		395
-		396	#define KMAP_MAX 256
-		397
-		398	static struct mutex kmap_mutex;
-		399	static struct page* kmap_table[KMAP_MAX];
-		400	static int kmap_av;
-		401	static int kmap_first;
-		402	static void* kmap_base;
-		403
-		404
-		405	int kmap_init()
-		406	{
-		407	kmap_base = AllocKernelSpace(KMAP_MAX*4096);
-		408	if(kmap_base == NULL)
-		409	return -1;
-		410
-		411	kmap_av = KMAP_MAX;
-		412	MutexInit(&kmap_mutex);
-		413	return 0;
-		414	};
-		415
-		416	void kmap(struct page page)
-		417	{
-		418	void *vaddr = NULL;
-		419	int i;
-		420
-		421	do
-		422	{
-		423	MutexLock(&kmap_mutex);
-		424	if(kmap_av != 0)
-		425	{
-		426	for(i = kmap_first; i < KMAP_MAX; i++)
-		427	{
-		428	if(kmap_table[i] == NULL)
-		429	{
-		430	kmap_av--;
-		431	kmap_first = i;
-		432	kmap_table[i] = page;
-		433	vaddr = kmap_base + (i<<12);
-		434	MapPage(vaddr,(addr_t)page,3);
-		435	break;
-		436	};
-		437	};
-		438	};
-		439	MutexUnlock(&kmap_mutex);
-		440	}while(vaddr == NULL);
-		441
-		442	return vaddr;
-		443	};
-		444
-		445	void kmap_atomic(struct page page) __attribute__ ((alias ("kmap")));
-		446
-		447	void kunmap(struct page *page)
-		448	{
-		449	void *vaddr;
-		450	int i;
-		451
-		452	MutexLock(&kmap_mutex);
-		453
-		454	for(i = 0; i < KMAP_MAX; i++)
-		455	{
-		456	if(kmap_table[i] == page)
-		457	{
-		458	kmap_av++;
-		459	if(i < kmap_first)
-		460	kmap_first = i;
-		461	kmap_table[i] = NULL;
-		462	vaddr = kmap_base + (i<<12);
-		463	MapPage(vaddr,0,0);
-		464	break;
-		465	};
-		466	};
-		467
-		468	MutexUnlock(&kmap_mutex);
-		469	};
-		470
-		471	void kunmap_atomic(void *vaddr)
-		472	{
-		473	int i;
-		474
-		475	MapPage(vaddr,0,0);
-		476
-		477	i = (vaddr - kmap_base) >> 12;
-		478
-		479	MutexLock(&kmap_mutex);
-		480
-		481	kmap_av++;
-		482	if(i < kmap_first)
-		483	kmap_first = i;
-		484	kmap_table[i] = NULL;
-		485
-		486	MutexUnlock(&kmap_mutex);
379		487	}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/utils.c – Rev 5271 → 6104