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


#include 
#include 
#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 *sg, int nents,
           enum dma_data_direction direction)
{
    struct scatterlist *s;
    int i;
 
    for_each_sg(sg, s, nents, i) {
        s->dma_address = (dma_addr_t)sg_phys(s);
#ifdef CONFIG_NEED_SG_DMA_LENGTH
        s->dma_length  = s->length;
#endif
    }
 
    return nents;
}
 
void
dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
             enum dma_data_direction direction)
{
};
 
 
#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;
}
 
 
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 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)
{
        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;
}
 
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;
};
 
 
int 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;
}
 
void *vmap(struct page **pages, unsigned int count,
           unsigned long flags, pgprot_t prot)
{
    void *vaddr;
    char *tmp;
    int i;
 
    vaddr = AllocKernelSpace(count << 12);
    if(vaddr == NULL)
        return NULL;
 
    for(i = 0, tmp = vaddr; i < count; i++)
    {
        MapPage(tmp, page_to_phys(pages[i]), PG_SW);
        tmp+= 4096;
    };
 
    return vaddr;
};
 
void vunmap(const void *addr)
{
    FreeKernelSpace((void*)addr);
}
 
void __iomem *ioremap_nocache(resource_size_t offset, unsigned long size)
{
    return (void __iomem*) MapIoMem(offset, size, PG_SW|PG_NOCACHE|0x100);
}
 
void __iomem *ioremap_wc(resource_size_t offset, unsigned long size)
{
//    return (void __iomem*) MapIoMem(offset, size, PG_SW|PG_WRITEC|0x100);
    return (void __iomem*) MapIoMem(offset, size, PG_SW|0x100);
}
 
void iounmap(volatile void __iomem *addr)
{
    FreeKernelSpace((void*)addr);
}
 
unsigned long _copy_from_user(void *to, const void __user *from, unsigned n)
{
//    if (access_ok(VERIFY_READ, from, n))
        n = __copy_from_user(to, from, n);
//    else
//        memset(to, 0, n);
    return n;
}
#define>

Rev 6938	Rev 7144
1	#include	1	#include
2	#include	2	#include
3	#include	3	#include
4	#include	4	#include
5	#include	5	#include
6	#include	6	#include
7	#include "i915_drv.h"	7	#include "i915_drv.h"
8	#include "intel_drv.h"	8	#include "intel_drv.h"
9	#include	9	#include
10	#include	10	#include
11	#include	11	#include
12	#include "i915_kos32.h"	12	#include "i915_kos32.h"
13		13
14	struct file shmem_file_setup(const char name, loff_t size, unsigned long flags)	14	struct file shmem_file_setup(const char name, loff_t size, unsigned long flags)
15	{	15	{
16	struct file *filep;	16	struct file *filep;
17	int count;	17	int count;
18		18
19	filep = __builtin_malloc(sizeof(*filep));	19	filep = __builtin_malloc(sizeof(*filep));
20		20
21	if(unlikely(filep == NULL))	21	if(unlikely(filep == NULL))
22	return ERR_PTR(-ENOMEM);	22	return ERR_PTR(-ENOMEM);
23		23
24	count = size / PAGE_SIZE;	24	count = size / PAGE_SIZE;
25		25
26	filep->pages = kzalloc(sizeof(struct page ) count, 0);	26	filep->pages = kzalloc(sizeof(struct page ) count, 0);
27	if(unlikely(filep->pages == NULL))	27	if(unlikely(filep->pages == NULL))
28	{	28	{
29	kfree(filep);	29	kfree(filep);
30	return ERR_PTR(-ENOMEM);	30	return ERR_PTR(-ENOMEM);
31	};	31	};
32		32
33	filep->count = count;	33	filep->count = count;
34	filep->allocated = 0;	34	filep->allocated = 0;
35	filep->vma = NULL;	35	filep->vma = NULL;
36		36
37	// printf("%s file %p pages %p count %d\n",	37	// printf("%s file %p pages %p count %d\n",
38	// __FUNCTION__,filep, filep->pages, count);	38	// __FUNCTION__,filep, filep->pages, count);
39		39
40	return filep;	40	return filep;
41	}	41	}
42		42
43	struct page shmem_read_mapping_page_gfp(struct file filep,	43	struct page shmem_read_mapping_page_gfp(struct file filep,
44	pgoff_t index, gfp_t gfp)	44	pgoff_t index, gfp_t gfp)
45	{	45	{
46	struct page *page;	46	struct page *page;
47		47
48	if(unlikely(index >= filep->count))	48	if(unlikely(index >= filep->count))
49	return ERR_PTR(-EINVAL);	49	return ERR_PTR(-EINVAL);
50		50
51	page = filep->pages[index];	51	page = filep->pages[index];
52		52
53	if(unlikely(page == NULL))	53	if(unlikely(page == NULL))
54	{	54	{
55	page = (struct page *)AllocPage();	55	page = (struct page *)AllocPage();
56		56
57	if(unlikely(page == NULL))	57	if(unlikely(page == NULL))
58	return ERR_PTR(-ENOMEM);	58	return ERR_PTR(-ENOMEM);
59		59
60	filep->pages[index] = page;	60	filep->pages[index] = page;
61	// printf("file %p index %d page %x\n", filep, index, page);	61	// printf("file %p index %d page %x\n", filep, index, page);
62	// delay(1);	62	// delay(1);
63		63
64	};	64	};
65		65
66	return page;	66	return page;
67	};	67	};
68		68
69	unsigned long vm_mmap(struct file *file, unsigned long addr,	69	unsigned long vm_mmap(struct file *file, unsigned long addr,
70	unsigned long len, unsigned long prot,	70	unsigned long len, unsigned long prot,
71	unsigned long flag, unsigned long offset)	71	unsigned long flag, unsigned long offset)
72	{	72	{
73	char mem, ptr;	73	char mem, ptr;
74	int i;	74	int i;
75		75
76	if (unlikely(offset + PAGE_ALIGN(len) < offset))	76	if (unlikely(offset + PAGE_ALIGN(len) < offset))
77	return -EINVAL;	77	return -EINVAL;
78	if (unlikely(offset & ~PAGE_MASK))	78	if (unlikely(offset & ~PAGE_MASK))
79	return -EINVAL;	79	return -EINVAL;
80		80
81	mem = UserAlloc(len);	81	mem = UserAlloc(len);
82	if(unlikely(mem == NULL))	82	if(unlikely(mem == NULL))
83	return -ENOMEM;	83	return -ENOMEM;
84		84
85	for(i = offset, ptr = mem; i < offset+len; i+= 4096, ptr+= 4096)	85	for(i = offset, ptr = mem; i < offset+len; i+= 4096, ptr+= 4096)
86	{	86	{
87	struct page *page;	87	struct page *page;
88		88
89	page = shmem_read_mapping_page_gfp(file, i/PAGE_SIZE,0);	89	page = shmem_read_mapping_page_gfp(file, i/PAGE_SIZE,0);
90		90
91	if (unlikely(IS_ERR(page)))	91	if (unlikely(IS_ERR(page)))
92	goto err;	92	goto err;
93		93
94	MapPage(ptr, (addr_t)page, PG_SHARED\|PG_UW);	94	MapPage(ptr, (addr_t)page, PG_SHARED\|PG_UW);
95	}	95	}
96		96
97	return (unsigned long)mem;	97	return (unsigned long)mem;
98	err:	98	err:
99	UserFree(mem);	99	UserFree(mem);
100	return -ENOMEM;	100	return -ENOMEM;
101	};	101	};
102		102
103	void shmem_file_delete(struct file *filep)	103	void shmem_file_delete(struct file *filep)
104	{	104	{
105	// printf("%s file %p pages %p count %d\n",	105	// printf("%s file %p pages %p count %d\n",
106	// __FUNCTION__, filep, filep->pages, filep->count);	106	// __FUNCTION__, filep, filep->pages, filep->count);
107		107
108	if(filep->pages)	108	if(filep->pages)
109	kfree(filep->pages);	109	kfree(filep->pages);
110	}	110	}
111		111
112		112
113		113
114	static void check_bytes8(const u8 start, u8 value, unsigned int bytes)	114	static void check_bytes8(const u8 start, u8 value, unsigned int bytes)
115	{	115	{
116	while (bytes) {	116	while (bytes) {
117	if (*start != value)	117	if (*start != value)
118	return (void *)start;	118	return (void *)start;
119	start++;	119	start++;
120	bytes--;	120	bytes--;
121	}	121	}
122	return NULL;	122	return NULL;
123	}	123	}
124		124
125	/**	125	/**
126	* memchr_inv - Find an unmatching character in an area of memory.	126	* memchr_inv - Find an unmatching character in an area of memory.
127	* @start: The memory area	127	* @start: The memory area
128	* @c: Find a character other than c	128	* @c: Find a character other than c
129	* @bytes: The size of the area.	129	* @bytes: The size of the area.
130	*	130	*
131	* returns the address of the first character other than @c, or %NULL	131	* returns the address of the first character other than @c, or %NULL
132	* if the whole buffer contains just @c.	132	* if the whole buffer contains just @c.
133	*/	133	*/
134	void memchr_inv(const void start, int c, size_t bytes)	134	void memchr_inv(const void start, int c, size_t bytes)
135	{	135	{
136	u8 value = c;	136	u8 value = c;
137	u64 value64;	137	u64 value64;
138	unsigned int words, prefix;	138	unsigned int words, prefix;
139		139
140	if (bytes <= 16)	140	if (bytes <= 16)
141	return check_bytes8(start, value, bytes);	141	return check_bytes8(start, value, bytes);
142		142
143	value64 = value;	143	value64 = value;
144	#if defined(ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64	144	#if defined(ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
145	value64 *= 0x0101010101010101;	145	value64 *= 0x0101010101010101;
146	#elif defined(ARCH_HAS_FAST_MULTIPLIER)	146	#elif defined(ARCH_HAS_FAST_MULTIPLIER)
147	value64 *= 0x01010101;	147	value64 *= 0x01010101;
148	value64 \|= value64 << 32;	148	value64 \|= value64 << 32;
149	#else	149	#else
150	value64 \|= value64 << 8;	150	value64 \|= value64 << 8;
151	value64 \|= value64 << 16;	151	value64 \|= value64 << 16;
152	value64 \|= value64 << 32;	152	value64 \|= value64 << 32;
153	#endif	153	#endif
154		154
155	prefix = (unsigned long)start % 8;	155	prefix = (unsigned long)start % 8;
156	if (prefix) {	156	if (prefix) {
157	u8 *r;	157	u8 *r;
158		158
159	prefix = 8 - prefix;	159	prefix = 8 - prefix;
160	r = check_bytes8(start, value, prefix);	160	r = check_bytes8(start, value, prefix);
161	if (r)	161	if (r)
162	return r;	162	return r;
163	start += prefix;	163	start += prefix;
164	bytes -= prefix;	164	bytes -= prefix;
165	}	165	}
166		166
167	words = bytes / 8;	167	words = bytes / 8;
168		168
169	while (words) {	169	while (words) {
170	if ((u64 )start != value64)	170	if ((u64 )start != value64)
171	return check_bytes8(start, value, 8);	171	return check_bytes8(start, value, 8);
172	start += 8;	172	start += 8;
173	words--;	173	words--;
174	}	174	}
175		175
176	return check_bytes8(start, value, bytes % 8);	176	return check_bytes8(start, value, bytes % 8);
177	}	177	}
178		178
179		179
180	int dma_map_sg(struct device dev, struct scatterlist sg, int nents,	180	int dma_map_sg(struct device dev, struct scatterlist sg, int nents,
181	enum dma_data_direction direction)	181	enum dma_data_direction direction)
182	{	182	{
183	struct scatterlist *s;	183	struct scatterlist *s;
184	int i;	184	int i;
185		185
186	for_each_sg(sg, s, nents, i) {	186	for_each_sg(sg, s, nents, i) {
187	s->dma_address = (dma_addr_t)sg_phys(s);	187	s->dma_address = (dma_addr_t)sg_phys(s);
188	#ifdef CONFIG_NEED_SG_DMA_LENGTH	188	#ifdef CONFIG_NEED_SG_DMA_LENGTH
189	s->dma_length = s->length;	189	s->dma_length = s->length;
190	#endif	190	#endif
191	}	191	}
192		192
193	return nents;	193	return nents;
194	}	194	}
195		195
196	void	196	void
197	dma_unmap_sg(struct device dev, struct scatterlist sg, int nhwentries,	197	dma_unmap_sg(struct device dev, struct scatterlist sg, int nhwentries,
198	enum dma_data_direction direction)	198	enum dma_data_direction direction)
199	{	199	{
200	};	200	};
201		201
202		202
203	#define _U 0x01 /* upper */	203	#define _U 0x01 /* upper */
204	#define _L 0x02 /* lower */	204	#define _L 0x02 /* lower */
205	#define _D 0x04 /* digit */	205	#define _D 0x04 /* digit */
206	#define _C 0x08 /* cntrl */	206	#define _C 0x08 /* cntrl */
207	#define _P 0x10 /* punct */	207	#define _P 0x10 /* punct */
208	#define _S 0x20 /* white space (space/lf/tab) */	208	#define _S 0x20 /* white space (space/lf/tab) */
209	#define _X 0x40 /* hex digit */	209	#define _X 0x40 /* hex digit */
210	#define _SP 0x80 /* hard space (0x20) */	210	#define _SP 0x80 /* hard space (0x20) */
211		211
212	extern const unsigned char _ctype[];	212	extern const unsigned char _ctype[];
213		213
214	#define __ismask(x) (_ctype[(int)(unsigned char)(x)])	214	#define __ismask(x) (_ctype[(int)(unsigned char)(x)])
215		215
216	#define isalnum(c) ((__ismask(c)&(_U\|_L\|_D)) != 0)	216	#define isalnum(c) ((__ismask(c)&(_U\|_L\|_D)) != 0)
217	#define isalpha(c) ((__ismask(c)&(_U\|_L)) != 0)	217	#define isalpha(c) ((__ismask(c)&(_U\|_L)) != 0)
218	#define iscntrl(c) ((__ismask(c)&(_C)) != 0)	218	#define iscntrl(c) ((__ismask(c)&(_C)) != 0)
219	#define isdigit(c) ((__ismask(c)&(_D)) != 0)	219	#define isdigit(c) ((__ismask(c)&(_D)) != 0)
220	#define isgraph(c) ((__ismask(c)&(_P\|_U\|_L\|_D)) != 0)	220	#define isgraph(c) ((__ismask(c)&(_P\|_U\|_L\|_D)) != 0)
221	#define islower(c) ((__ismask(c)&(_L)) != 0)	221	#define islower(c) ((__ismask(c)&(_L)) != 0)
222	#define isprint(c) ((__ismask(c)&(_P\|_U\|_L\|_D\|_SP)) != 0)	222	#define isprint(c) ((__ismask(c)&(_P\|_U\|_L\|_D\|_SP)) != 0)
223	#define ispunct(c) ((__ismask(c)&(_P)) != 0)	223	#define ispunct(c) ((__ismask(c)&(_P)) != 0)
224	/* Note: isspace() must return false for %NUL-terminator */	224	/* Note: isspace() must return false for %NUL-terminator */
225	#define isspace(c) ((__ismask(c)&(_S)) != 0)	225	#define isspace(c) ((__ismask(c)&(_S)) != 0)
226	#define isupper(c) ((__ismask(c)&(_U)) != 0)	226	#define isupper(c) ((__ismask(c)&(_U)) != 0)
227	#define isxdigit(c) ((__ismask(c)&(_D\|_X)) != 0)	227	#define isxdigit(c) ((__ismask(c)&(_D\|_X)) != 0)
228		228
229	#define isascii(c) (((unsigned char)(c))<=0x7f)	229	#define isascii(c) (((unsigned char)(c))<=0x7f)
230	#define toascii(c) (((unsigned char)(c))&0x7f)	230	#define toascii(c) (((unsigned char)(c))&0x7f)
231		231
232	static inline unsigned char __tolower(unsigned char c)	232	static inline unsigned char __tolower(unsigned char c)
233	{	233	{
234	if (isupper(c))	234	if (isupper(c))
235	c -= 'A'-'a';	235	c -= 'A'-'a';
236	return c;	236	return c;
237	}	237	}
238		238
239	static inline unsigned char __toupper(unsigned char c)	239	static inline unsigned char __toupper(unsigned char c)
240	{	240	{
241	if (islower(c))	241	if (islower(c))
242	c -= 'a'-'A';	242	c -= 'a'-'A';
243	return c;	243	return c;
244	}	244	}
245		245
246	#define tolower(c) __tolower(c)	246	#define tolower(c) __tolower(c)
247	#define toupper(c) __toupper(c)	247	#define toupper(c) __toupper(c)
248		248
249	/*	249	/*
250	* Fast implementation of tolower() for internal usage. Do not use in your	250	* Fast implementation of tolower() for internal usage. Do not use in your
251	* code.	251	* code.
252	*/	252	*/
253	static inline char _tolower(const char c)	253	static inline char _tolower(const char c)
254	{	254	{
255	return c \| 0x20;	255	return c \| 0x20;
256	}	256	}
257		257
258		258
259	void kmemdup(const void src, size_t len, gfp_t gfp)	259	void kmemdup(const void src, size_t len, gfp_t gfp)
260	{	260	{
261	void *p;	261	void *p;
262		262
263	p = kmalloc(len, gfp);	263	p = kmalloc(len, gfp);
264	if (p)	264	if (p)
265	memcpy(p, src, len);	265	memcpy(p, src, len);
266	return p;	266	return p;
267	}	267	}
268		268
269		269
270	void msleep(unsigned int msecs)	270	void msleep(unsigned int msecs)
271	{	271	{
272	msecs /= 10;	272	msecs /= 10;
273	if(!msecs) msecs = 1;	273	if(!msecs) msecs = 1;
274		274
275	__asm__ __volatile__ (	275	__asm__ __volatile__ (
276	"call *__imp__Delay"	276	"call *__imp__Delay"
277	::"b" (msecs));	277	::"b" (msecs));
278	__asm__ __volatile__ (	278	__asm__ __volatile__ (
279	"":::"ebx");	279	"":::"ebx");
280		280
281	};	281	};
282		282
283		283
284	/* simple loop based delay: */	284	/* simple loop based delay: */
285	static void delay_loop(unsigned long loops)	285	static void delay_loop(unsigned long loops)
286	{	286	{
287	asm volatile(	287	asm volatile(
288	" test %0,%0 \n"	288	" test %0,%0 \n"
289	" jz 3f \n"	289	" jz 3f \n"
290	" jmp 1f \n"	290	" jmp 1f \n"
291		291
292	".align 16 \n"	292	".align 16 \n"
293	"1: jmp 2f \n"	293	"1: jmp 2f \n"
294		294
295	".align 16 \n"	295	".align 16 \n"
296	"2: dec %0 \n"	296	"2: dec %0 \n"
297	" jnz 2b \n"	297	" jnz 2b \n"
298	"3: dec %0 \n"	298	"3: dec %0 \n"
299		299
300	: /* we don't need output */	300	: /* we don't need output */
301	:"a" (loops)	301	:"a" (loops)
302	);	302	);
303	}	303	}
304		304
305		305
306	static void (*delay_fn)(unsigned long) = delay_loop;	306	static void (*delay_fn)(unsigned long) = delay_loop;
307		307
308	void __delay(unsigned long loops)	308	void __delay(unsigned long loops)
309	{	309	{
310	delay_fn(loops);	310	delay_fn(loops);
311	}	311	}
312		312
313		313
314	inline void __const_udelay(unsigned long xloops)	314	inline void __const_udelay(unsigned long xloops)
315	{	315	{
316	int d0;	316	int d0;
317		317
318	xloops *= 4;	318	xloops *= 4;
319	asm("mull %%edx"	319	asm("mull %%edx"
320	: "=d" (xloops), "=&a" (d0)	320	: "=d" (xloops), "=&a" (d0)
321	: "1" (xloops), ""	321	: "1" (xloops), ""
322	(loops_per_jiffy * (HZ/4)));	322	(loops_per_jiffy * (HZ/4)));
323		323
324	__delay(++xloops);	324	__delay(++xloops);
325	}	325	}
326		326
327	void __udelay(unsigned long usecs)	327	void __udelay(unsigned long usecs)
328	{	328	{
329	__const_udelay(usecs * 0x000010c7); /* 2*32 / 1000000 (rounded up) /	329	__const_udelay(usecs * 0x000010c7); /* 2*32 / 1000000 (rounded up) /
330	}	330	}
331		331
332	unsigned int _sw_hweight32(unsigned int w)	332	unsigned int _sw_hweight32(unsigned int w)
333	{	333	{
334	#ifdef CONFIG_ARCH_HAS_FAST_MULTIPLIER	334	#ifdef CONFIG_ARCH_HAS_FAST_MULTIPLIER
335	w -= (w >> 1) & 0x55555555;	335	w -= (w >> 1) & 0x55555555;
336	w = (w & 0x33333333) + ((w >> 2) & 0x33333333);	336	w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
337	w = (w + (w >> 4)) & 0x0f0f0f0f;	337	w = (w + (w >> 4)) & 0x0f0f0f0f;
338	return (w * 0x01010101) >> 24;	338	return (w * 0x01010101) >> 24;
339	#else	339	#else
340	unsigned int res = w - ((w >> 1) & 0x55555555);	340	unsigned int res = w - ((w >> 1) & 0x55555555);
341	res = (res & 0x33333333) + ((res >> 2) & 0x33333333);	341	res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
342	res = (res + (res >> 4)) & 0x0F0F0F0F;	342	res = (res + (res >> 4)) & 0x0F0F0F0F;
343	res = res + (res >> 8);	343	res = res + (res >> 8);
344	return (res + (res >> 16)) & 0x000000FF;	344	return (res + (res >> 16)) & 0x000000FF;
345	#endif	345	#endif
346	}	346	}
347	EXPORT_SYMBOL(_sw_hweight32);	347	EXPORT_SYMBOL(_sw_hweight32);
348		348
349		349
350	void usleep_range(unsigned long min, unsigned long max)	350	void usleep_range(unsigned long min, unsigned long max)
351	{	351	{
352	udelay(max);	352	udelay(max);
353	}	353	}
354	EXPORT_SYMBOL(usleep_range);	354	EXPORT_SYMBOL(usleep_range);
355		355
356		356
357	static unsigned long round_jiffies_common(unsigned long j, int cpu,	357	static unsigned long round_jiffies_common(unsigned long j, int cpu,
358	bool force_up)	358	bool force_up)
359	{	359	{
360	int rem;	360	int rem;
361	unsigned long original = j;	361	unsigned long original = j;
362		362
363	/*	363	/*
364	* We don't want all cpus firing their timers at once hitting the	364	* We don't want all cpus firing their timers at once hitting the
365	* same lock or cachelines, so we skew each extra cpu with an extra	365	* same lock or cachelines, so we skew each extra cpu with an extra
366	* 3 jiffies. This 3 jiffies came originally from the mm/ code which	366	* 3 jiffies. This 3 jiffies came originally from the mm/ code which
367	* already did this.	367	* already did this.
368	* The skew is done by adding 3*cpunr, then round, then subtract this	368	* The skew is done by adding 3*cpunr, then round, then subtract this
369	* extra offset again.	369	* extra offset again.
370	*/	370	*/
371	j += cpu * 3;	371	j += cpu * 3;
372		372
373	rem = j % HZ;	373	rem = j % HZ;
374		374
375	/*	375	/*
376	* If the target jiffie is just after a whole second (which can happen	376	* If the target jiffie is just after a whole second (which can happen
377	* due to delays of the timer irq, long irq off times etc etc) then	377	* due to delays of the timer irq, long irq off times etc etc) then
378	* we should round down to the whole second, not up. Use 1/4th second	378	* we should round down to the whole second, not up. Use 1/4th second
379	* as cutoff for this rounding as an extreme upper bound for this.	379	* as cutoff for this rounding as an extreme upper bound for this.
380	* But never round down if @force_up is set.	380	* But never round down if @force_up is set.
381	*/	381	*/
382	if (rem < HZ/4 && !force_up) /* round down */	382	if (rem < HZ/4 && !force_up) /* round down */
383	j = j - rem;	383	j = j - rem;
384	else /* round up */	384	else /* round up */
385	j = j - rem + HZ;	385	j = j - rem + HZ;
386		386
387	/* now that we have rounded, subtract the extra skew again */	387	/* now that we have rounded, subtract the extra skew again */
388	j -= cpu * 3;	388	j -= cpu * 3;
389		389
390	/*	390	/*
391	* Make sure j is still in the future. Otherwise return the	391	* Make sure j is still in the future. Otherwise return the
392	* unmodified value.	392	* unmodified value.
393	*/	393	*/
394	return time_is_after_jiffies(j) ? j : original;	394	return time_is_after_jiffies(j) ? j : original;
395	}	395	}
396		396
397		397
398	unsigned long round_jiffies_up_relative(unsigned long j)	398	unsigned long round_jiffies_up_relative(unsigned long j)
399	{	399	{
400	unsigned long j0 = jiffies;	400	unsigned long j0 = jiffies;
401		401
402	/* Use j0 because jiffies might change while we run */	402	/* Use j0 because jiffies might change while we run */
403	return round_jiffies_common(j + j0, 0, true) - j0;	403	return round_jiffies_common(j + j0, 0, true) - j0;
404	}	404	}
405	EXPORT_SYMBOL_GPL(__round_jiffies_up_relative);	405	EXPORT_SYMBOL_GPL(__round_jiffies_up_relative);
406		406
407		407
408	#include	408	#include
409		409
410	struct rcu_ctrlblk {	410	struct rcu_ctrlblk {
411	struct rcu_head rcucblist; / List of pending callbacks (CBs). */	411	struct rcu_head rcucblist; / List of pending callbacks (CBs). */
412	struct rcu_head *donetail; / ->next pointer of last "done" CB. */	412	struct rcu_head *donetail; / ->next pointer of last "done" CB. */
413	struct rcu_head *curtail; / ->next pointer of last CB. */	413	struct rcu_head *curtail; / ->next pointer of last CB. */
414	// RCU_TRACE(long qlen); /* Number of pending CBs. */	414	// RCU_TRACE(long qlen); /* Number of pending CBs. */
415	// RCU_TRACE(unsigned long gp_start); /* Start time for stalls. */	415	// RCU_TRACE(unsigned long gp_start); /* Start time for stalls. */
416	// RCU_TRACE(unsigned long ticks_this_gp); /* Statistic for stalls. */	416	// RCU_TRACE(unsigned long ticks_this_gp); /* Statistic for stalls. */
417	// RCU_TRACE(unsigned long jiffies_stall); /* Jiffies at next stall. */	417	// RCU_TRACE(unsigned long jiffies_stall); /* Jiffies at next stall. */
418	// RCU_TRACE(const char name); / Name of RCU type. */	418	// RCU_TRACE(const char name); / Name of RCU type. */
419	};	419	};
420		420
421	/* Definition for rcupdate control block. */	421	/* Definition for rcupdate control block. */
422	static struct rcu_ctrlblk rcu_sched_ctrlblk = {	422	static struct rcu_ctrlblk rcu_sched_ctrlblk = {
423	.donetail = &rcu_sched_ctrlblk.rcucblist,	423	.donetail = &rcu_sched_ctrlblk.rcucblist,
424	.curtail = &rcu_sched_ctrlblk.rcucblist,	424	.curtail = &rcu_sched_ctrlblk.rcucblist,
425	// RCU_TRACE(.name = "rcu_sched")	425	// RCU_TRACE(.name = "rcu_sched")
426	};	426	};
427		427
428	static void __call_rcu(struct rcu_head *head,	428	static void __call_rcu(struct rcu_head *head,
429	void (func)(struct rcu_head rcu),	429	void (func)(struct rcu_head rcu),
430	struct rcu_ctrlblk *rcp)	430	struct rcu_ctrlblk *rcp)
431	{	431	{
432	unsigned long flags;	432	unsigned long flags;
433		433
434	// debug_rcu_head_queue(head);	434	// debug_rcu_head_queue(head);
435	head->func = func;	435	head->func = func;
436	head->next = NULL;	436	head->next = NULL;
437		437
438	local_irq_save(flags);	438	local_irq_save(flags);
439	*rcp->curtail = head;	439	*rcp->curtail = head;
440	rcp->curtail = &head->next;	440	rcp->curtail = &head->next;
441	// RCU_TRACE(rcp->qlen++);	441	// RCU_TRACE(rcp->qlen++);
442	local_irq_restore(flags);	442	local_irq_restore(flags);
443	}	443	}
444		444
445	/*	445	/*
446	* Post an RCU callback to be invoked after the end of an RCU-sched grace	446	* Post an RCU callback to be invoked after the end of an RCU-sched grace
447	* period. But since we have but one CPU, that would be after any	447	* period. But since we have but one CPU, that would be after any
448	* quiescent state.	448	* quiescent state.
449	*/	449	*/
450	void call_rcu_sched(struct rcu_head head, void (func)(struct rcu_head *rcu))	450	void call_rcu_sched(struct rcu_head head, void (func)(struct rcu_head *rcu))
451	{	451	{
452	__call_rcu(head, func, &rcu_sched_ctrlblk);	452	__call_rcu(head, func, &rcu_sched_ctrlblk);
453	}	453	}
454		454
455	int seq_puts(struct seq_file m, const char s)	455	int seq_puts(struct seq_file m, const char s)
456	{	456	{
457	return 0;	457	return 0;
458	};	458	};
459		459
460	__printf(2, 3) int seq_printf(struct seq_file m, const char f, ...)	460	__printf(2, 3) int seq_printf(struct seq_file m, const char f, ...)
461	{	461	{
462	return 0;	462	return 0;
463	}	463	}
464		464
465	ktime_t ktime_get(void)	465	ktime_t ktime_get(void)
466	{	466	{
467	ktime_t t;	467	ktime_t t;
468		468
469	t.tv64 = GetClockNs();	469	t.tv64 = GetClockNs();
470		470
471	return t;	471	return t;
472	}	472	}
473		473
474	char strdup(const char str)	474	char strdup(const char str)
475	{	475	{
476	size_t len = strlen(str) + 1;	476	size_t len = strlen(str) + 1;
477	char *copy = __builtin_malloc(len);	477	char *copy = __builtin_malloc(len);
478	if (copy)	478	if (copy)
479	{	479	{
480	memcpy (copy, str, len);	480	memcpy (copy, str, len);
481	}	481	}
482	return copy;	482	return copy;
483	}	483	}
484		484
485	int split_cmdline(char cmdline, char *argv)	485	int split_cmdline(char cmdline, char *argv)
486	{	486	{
487	enum quote_state	487	enum quote_state
488	{	488	{
489	QUOTE_NONE, /* no " active in current parm */	489	QUOTE_NONE, /* no " active in current parm */
490	QUOTE_DELIMITER, /* " was first char and must be last */	490	QUOTE_DELIMITER, /* " was first char and must be last */
491	QUOTE_STARTED /* " was seen, look for a match */	491	QUOTE_STARTED /* " was seen, look for a match */
492	};	492	};
493		493
494	enum quote_state state;	494	enum quote_state state;
495	unsigned int argc;	495	unsigned int argc;
496	char *p = cmdline;	496	char *p = cmdline;
497	char new_arg, start;	497	char new_arg, start;
498		498
499	argc = 0;	499	argc = 0;
500		500

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/utils.c – Rev 6938 → 7144