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


#include 
#include 
#include 
#include 
#include "i915_drv.h"
#include "intel_drv.h"
 
 
struct file *shmem_file_setup(const char *name, loff_t size, unsigned long flags)
{
    struct file *filep;
    int count;
 
    filep = 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;
 
//    dbgprintf("%s, file %p index %d\n", __FUNCTION__, filep, index);
 
    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;
    };
 
    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);
}

Rev 3263	Rev 3290
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		7
8		8
9	struct file shmem_file_setup(const char name, loff_t size, unsigned long flags)	9	struct file shmem_file_setup(const char name, loff_t size, unsigned long flags)
10	{	10	{
11	struct file *filep;	11	struct file *filep;
12	int count;	12	int count;
13		13
14	filep = malloc(sizeof(*filep));	14	filep = malloc(sizeof(*filep));
15		15
16	if(unlikely(filep == NULL))	16	if(unlikely(filep == NULL))
17	return ERR_PTR(-ENOMEM);	17	return ERR_PTR(-ENOMEM);
18		18
19	count = size / PAGE_SIZE;	19	count = size / PAGE_SIZE;
20		20
21	filep->pages = kzalloc(sizeof(struct page ) count, 0);	21	filep->pages = kzalloc(sizeof(struct page ) count, 0);
22	if(unlikely(filep->pages == NULL))	22	if(unlikely(filep->pages == NULL))
23	{	23	{
24	kfree(filep);	24	kfree(filep);
25	return ERR_PTR(-ENOMEM);	25	return ERR_PTR(-ENOMEM);
26	};	26	};
27		27
28	filep->count = count;	28	filep->count = count;
29	filep->allocated = 0;	29	filep->allocated = 0;
30	filep->vma = NULL;	30	filep->vma = NULL;
31		31
32	// dbgprintf("%s file %p pages %p count %d\n",	32	printf("%s file %p pages %p count %d\n",
33	// __FUNCTION__,filep, filep->pages, filep->pages);	33	__FUNCTION__,filep, filep->pages, count);
34		34
35	return filep;	35	return filep;
36	}	36	}
37		37
38	struct page shmem_read_mapping_page_gfp(struct file filep,	38	struct page shmem_read_mapping_page_gfp(struct file filep,
39	pgoff_t index, gfp_t gfp)	39	pgoff_t index, gfp_t gfp)
40	{	40	{
41	struct page *page;	41	struct page *page;
42		42
43	// dbgprintf("%s, file %p index %d\n", __FUNCTION__, filep, index);	43	// dbgprintf("%s, file %p index %d\n", __FUNCTION__, filep, index);
44		44
45	if(unlikely(index >= filep->count))	45	if(unlikely(index >= filep->count))
46	return ERR_PTR(-EINVAL);	46	return ERR_PTR(-EINVAL);
47		47
48	page = filep->pages[index];	48	page = filep->pages[index];
49		49
50	if(unlikely(page == NULL))	50	if(unlikely(page == NULL))
51	{	51	{
52	page = (struct page *)AllocPage();	52	page = (struct page *)AllocPage();
53		53
54	if(unlikely(page == NULL))	54	if(unlikely(page == NULL))
55	return ERR_PTR(-ENOMEM);	55	return ERR_PTR(-ENOMEM);
56		56
57	filep->pages[index] = page;	57	filep->pages[index] = page;
58	};	58	};
59		59
60	return page;	60	return page;
61	};	61	};
62		62
63	unsigned long vm_mmap(struct file *file, unsigned long addr,	63	unsigned long vm_mmap(struct file *file, unsigned long addr,
64	unsigned long len, unsigned long prot,	64	unsigned long len, unsigned long prot,
65	unsigned long flag, unsigned long offset)	65	unsigned long flag, unsigned long offset)
66	{	66	{
67	char mem, ptr;	67	char mem, ptr;
68	int i;	68	int i;
69		69
70	if (unlikely(offset + PAGE_ALIGN(len) < offset))	70	if (unlikely(offset + PAGE_ALIGN(len) < offset))
71	return -EINVAL;	71	return -EINVAL;
72	if (unlikely(offset & ~PAGE_MASK))	72	if (unlikely(offset & ~PAGE_MASK))
73	return -EINVAL;	73	return -EINVAL;
74		74
75	mem = UserAlloc(len);	75	mem = UserAlloc(len);
76	if(unlikely(mem == NULL))	76	if(unlikely(mem == NULL))
77	return -ENOMEM;	77	return -ENOMEM;
78		78
79	for(i = offset, ptr = mem; i < offset+len; i+= 4096, ptr+= 4096)	79	for(i = offset, ptr = mem; i < offset+len; i+= 4096, ptr+= 4096)
80	{	80	{
81	struct page *page;	81	struct page *page;
82		82
83	page = shmem_read_mapping_page_gfp(file, i/PAGE_SIZE,0);	83	page = shmem_read_mapping_page_gfp(file, i/PAGE_SIZE,0);
84		84
85	if (unlikely(IS_ERR(page)))	85	if (unlikely(IS_ERR(page)))
86	goto err;	86	goto err;
87		87
88	MapPage(ptr, (addr_t)page, PG_SHARED\|PG_UW);	88	MapPage(ptr, (addr_t)page, PG_SHARED\|PG_UW);
89	}	89	}
90		90
91	return (unsigned long)mem;	91	return (unsigned long)mem;
92	err:	92	err:
93	UserFree(mem);	93	UserFree(mem);
94	return -ENOMEM;	94	return -ENOMEM;
95	};	95	};
-		96
-		97	void shmem_file_delete(struct file *filep)
-		98	{
-		99	printf("%s file %p pages %p count %d\n",
-		100	__FUNCTION__, filep, filep->pages, filep->count);
-		101
-		102	if(filep->pages)
-		103	kfree(filep->pages);
-		104	}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/utils.c – Rev 3263 → 3290