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


#include 
#include 
#include 
#include 
#include "i915_drv.h"
#include "intel_drv.h"
#include 
#include 
#include 
#include "i915_kos32.h"
 
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;
}
 
struct page *shmem_read_mapping_page_gfp(struct file *filep,
                                         pgoff_t index, gfp_t gfp)
{
    struct page *page;
 
    if(unlikely(index >= filep->count))
        return ERR_PTR(-EINVAL);
 
    page = filep->pages[index];
 
    if(unlikely(page == NULL))
    {
        page = (struct page *)AllocPage();
 
        if(unlikely(page == NULL))
            return ERR_PTR(-ENOMEM);
 
        filep->pages[index] = page;
//        printf("file %p index %d page %x\n", filep, index, page);
//        delay(1);
 
    };
 
    return page;
};
 
unsigned long vm_mmap(struct file *file, unsigned long addr,
         unsigned long len, unsigned long prot,
         unsigned long flag, unsigned long offset)
{
    char *mem, *ptr;
    int i;
 
    if (unlikely(offset + PAGE_ALIGN(len) < offset))
        return -EINVAL;
    if (unlikely(offset & ~PAGE_MASK))
        return -EINVAL;
 
    mem = UserAlloc(len);
    if(unlikely(mem == NULL))
        return -ENOMEM;
 
    for(i = offset, ptr = mem; i < offset+len; i+= 4096, ptr+= 4096)
    {
        struct page *page;
 
        page = shmem_read_mapping_page_gfp(file, i/PAGE_SIZE,0);
 
        if (unlikely(IS_ERR(page)))
            goto err;
 
        MapPage(ptr, (addr_t)page, PG_SHARED|PG_UW);
    }
 
    return (unsigned long)mem;
err:
    UserFree(mem);
    return -ENOMEM;
};
 
void shmem_file_delete(struct file *filep)
{
//    printf("%s file %p pages %p count %d\n",
//            __FUNCTION__, filep, filep->pages, filep->count);
 
    if(filep->pages)
        kfree(filep->pages);
}
 
 
 
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);
}
 
 
 
int dma_map_sg(struct device *dev, struct scatterlist *sglist,
                           int nelems, int dir)
{
    struct scatterlist *s;
    int i;
 
    for_each_sg(sglist, s, nelems, i) {
        s->dma_address = (dma_addr_t)sg_phys(s);
#ifdef CONFIG_NEED_SG_DMA_LENGTH
        s->dma_length  = s->length;
#endif
    }
 
    return nelems;
}
 
 
 
#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);
}
 
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;
}
 
 
#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);
 
 
static unsigned long round_jiffies_common(unsigned long j, int cpu,
                bool force_up)
{
        int rem;
        unsigned long original = j;
 
        /*
         * We don't want all cpus firing their timers at once hitting the
         * same lock or cachelines, so we skew each extra cpu with an extra
         * 3 jiffies. This 3 jiffies came originally from the mm/ code which
         * already did this.
         * The skew is done by adding 3*cpunr, then round, then subtract this
         * extra offset again.
         */
        j += cpu * 3;
 
        rem = j % HZ;
 
        /*
         * If the target jiffie is just after a whole second (which can happen
         * due to delays of the timer irq, long irq off times etc etc) then
         * we should round down to the whole second, not up. Use 1/4th second
         * as cutoff for this rounding as an extreme upper bound for this.
         * But never round down if @force_up is set.
         */
        if (rem < HZ/4 && !force_up) /* round down */
                j = j - rem;
        else /* round up */
                j = j - rem + HZ;
 
        /* now that we have rounded, subtract the extra skew again */
        j -= cpu * 3;
 
        /*
         * Make sure j is still in the future. Otherwise return the
         * unmodified value.
         */
        return time_is_after_jiffies(j) ? j : original;
}
 
 
unsigned long round_jiffies_up_relative(unsigned long j, int cpu)
{
        unsigned long j0 = jiffies;
 
        /* Use j0 because jiffies might change while we run */
        return round_jiffies_common(j + j0, 0, true) - j0;
}
EXPORT_SYMBOL_GPL(__round_jiffies_up_relative);
 
 
#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);
}
 
int seq_puts(struct seq_file *m, const char *s)
{
    return 0;
};
 
__printf(2, 3) int seq_printf(struct seq_file *m, const char *f, ...)
{
    return 0;
}
 
 
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;
}
 
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);
}
 
void fence_free(struct fence *fence)
{
        kfree_rcu(fence, rcu);
}
EXPORT_SYMBOL(fence_free);
 
 
ktime_t ktime_get(void)
{
    ktime_t t;
 
    t.tv64 = GetClockNs();
 
    return t;
}
 
char *strdup(const char *str)
{
    size_t len = strlen(str) + 1;
    char *copy = __builtin_malloc(len);
    if (copy)
    {
        memcpy (copy, str, len);
    }
    return copy;
}
 
int split_cmdline(char *cmdline, char **argv)
{
    enum quote_state
    {
        QUOTE_NONE,         /* no " active in current parm       */
        QUOTE_DELIMITER,    /* " was first char and must be last */
        QUOTE_STARTED       /* " was seen, look for a match      */
    };
 
    enum quote_state state;
    unsigned int argc;
    char *p = cmdline;
    char *new_arg, *start;
 
    argc = 0;
 
    for(;;)
    {
        /* skip over spaces and tabs */
        if ( *p )
        {
            while (*p == ' ' || *p == '\t')
                ++p;
        }
 
        if (*p == '\0')
            break;
 
        state = QUOTE_NONE;
        if( *p == '\"' )
        {
            p++;
            state = QUOTE_DELIMITER;
        }
        new_arg = start = p;
        for (;;)
        {
            if( *p == '\"' )
            {
                p++;
                if( state == QUOTE_NONE )
                {
                    state = QUOTE_STARTED;
                }
                else
                {
                    state = QUOTE_NONE;
                }
                continue;
            }
 
            if( *p == ' ' || *p == '\t' )
            {
                if( state == QUOTE_NONE )
                {
                    break;
                }
            }
 
            if( *p == '\0' )
                break;
 
            if( *p == '\\' )
            {
                if( p[1] == '\"' )
                {
                    ++p;
                    if( p[-2] == '\\' )
                    {
                        continue;
                    }
                }
            }
            if( argv )
            {
                *(new_arg++) = *p;
            }
            ++p;
        };
 
        if( argv )
        {
            argv[ argc ] = start;
            ++argc;
 
            /*
              The *new = '\0' is req'd in case there was a \" to "
              translation. It must be after the *p check against
              '\0' because new and p could point to the same char
              in which case the scan would be terminated too soon.
            */
 
            if( *p == '\0' )
            {
                *new_arg = '\0';
                break;
            }
            *new_arg = '\0';
            ++p;
        }
        else
        {
            ++argc;
            if( *p == '\0' )
            {
                break;
            }
            ++p;
        }
    }
 
    return argc;
};
 
 
fb_get_options(const char *name, char **option)
{
    char *opt, *options = NULL;
    int retval = 1;
    int name_len;
 
    if(i915.cmdline_mode == NULL)
        return 1;
 
    name_len = __builtin_strlen(name);
 
    if (name_len )
    {
        opt = i915.cmdline_mode;
        if (!__builtin_strncmp(name, opt, name_len) &&
             opt[name_len] == ':')
        {
             options = opt + name_len + 1;
             retval = 0;
        }
    }
 
    if (option)
        *option = options;
 
    return retval;
}
>
>
>
>
#define>

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

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/utils.c – Rev 6103 → 6131