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


#include 
#include 
#include "i915_drm.h"
#include "i915_drv.h"
#include "intel_drv.h"
#include "bitmap.h"
 
#define memmove __builtin_memmove
 
int gem_object_lock(struct drm_i915_gem_object *obj);
 
#define DRIVER_CAPS_0   HW_BIT_BLIT | HW_TEX_BLIT;
#define DRIVER_CAPS_1   0
 
extern struct drm_device *main_device;
 
struct hman bm_man;
 
void __attribute__((regparm(1))) destroy_bitmap(bitmap_t *bitmap)
{
    printf("destroy bitmap %d\n", bitmap->handle);
    free_handle(&bm_man, bitmap->handle);
    bitmap->handle = 0;
    bitmap->obj->base.read_domains = I915_GEM_DOMAIN_GTT;
    bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;
 
    mutex_lock(&main_device->struct_mutex);
    drm_gem_object_unreference(&bitmap->obj->base);
    mutex_unlock(&main_device->struct_mutex);
 
    __DestroyObject(bitmap);
};
 
int init_bitmaps()
{
    int ret;
 
    ret = init_hman(&bm_man, 1024);
 
    return ret;
};
 
 
int create_surface(struct io_call_10 *pbitmap)
{
    struct drm_i915_gem_object *obj;
 
    bitmap_t   *bitmap;
    u32         handle;
    u32         width, max_width;
    u32         height, max_height;
    u32         size,  max_size;
    u32         pitch, max_pitch;
    void       *uaddr;
 
    int   ret;
 
    pbitmap->handle = 0;
    pbitmap->data   = (void*)-1;
 
    width  = pbitmap->width;
    height = pbitmap->height;
 
/*
    if((width==0)||(height==0)||(width>4096)||(height>4096))
        goto err1;
 
    if( ((pbitmap->max_width !=0 ) &&
         (pbitmap->max_width < width)) ||
         (pbitmap->max_width > 4096) )
        goto err1;
 
    if( ((pbitmap->max_height !=0 ) &&
         (pbitmap->max_height < width)) ||
         (pbitmap->max_height > 4096) )
        goto err1;
 
    if( pbitmap->format != 0)
        goto err1;
*/
 
    max_width  = (pbitmap->max_width ==0) ? width  : pbitmap->max_width;
    max_height = (pbitmap->max_height==0) ? height : pbitmap->max_height;
 
    handle = alloc_handle(&bm_man);
//    printf("%s %d\n",__FUNCTION__, handle);
 
    if(handle == 0)
        goto err1;
 
    bitmap = CreateObject(GetPid(), sizeof(*bitmap));
    bitmap->handle = handle;
    bitmap->header.destroy = destroy_bitmap;
    bitmap->obj    = NULL;
 
//    printf("bitmap %x\n", bitmap);
    if( bitmap == NULL)
        goto err1;
 
    hman_set_data(&bm_man, handle, bitmap);
 
    pitch = ALIGN(width*4,64);
 
    size =  roundup(pitch*height, PAGE_SIZE);
 
//    printf("pitch %d size %d\n", pitch, size);
 
    obj = i915_gem_alloc_object(main_device, size);
    if (obj == NULL)
        goto err2;
 
    ret = i915_gem_object_pin(obj, 4096, true);
    if (ret)
        goto err3;
 
    max_pitch = ALIGN(max_width*4,64);
    max_size =  roundup(max_pitch*max_height, PAGE_SIZE);
 
    uaddr = UserAlloc(max_size);
    if( uaddr == NULL)
        goto err4;
    else
    {
        u32_t *src, *dst;
        u32 count, max_count;
 
#define page_tabs  0xFDC00000      /* really dirty hack */
 
        src =  (u32_t*)obj->pages;
        dst =  &((u32_t*)page_tabs)[(u32_t)uaddr >> 12];
        count = size/4096;
        max_count = max_size/4096 - count;
 
        while(count--)
        {
            *dst++ = (0xFFFFF000 & *src++) | 0x207 ; // map as shared page
        };
        while(max_count--)
            *dst++ = 0;                              // cleanup unused space
    }
 
    obj->mapped = uaddr ;
 
    bitmap->handle = handle;
    bitmap->uaddr  = uaddr;
    bitmap->pitch  = pitch;
    bitmap->gaddr  = obj->gtt_offset;
 
    bitmap->width  = width;
    bitmap->height = height;
    bitmap->max_width  = max_width;
    bitmap->max_height = max_height;
 
    bitmap->obj    = obj;
    bitmap->header.destroy = destroy_bitmap;
 
    pbitmap->handle = handle;
    pbitmap->data   = uaddr;
    pbitmap->pitch  = pitch;
 
 
    printf("%s handle: %d pitch: %d gpu_addr: %x user_addr: %x\n",
            __FUNCTION__, handle, pitch, obj->gtt_offset, uaddr);
 
    return 0;
 
err4:
    i915_gem_object_unpin(obj);
err3:
    drm_gem_object_unreference(&obj->base);
err2:
    free_handle(&bm_man, handle);
    __DestroyObject(bitmap);
err1:
    return -1;
 
};
 
 
int lock_surface(struct io_call_12 *pbitmap)
{
    int ret;
 
    drm_i915_private_t *dev_priv = main_device->dev_private;
 
    bitmap_t  *bitmap;
 
    if(unlikely(pbitmap->handle == 0))
        return -1;
 
    bitmap = (bitmap_t*)hman_get_data(&bm_man, pbitmap->handle);
 
    if(unlikely(bitmap==NULL))
        return -1;
 
    ret = gem_object_lock(bitmap->obj);
    if(ret !=0 )
    {
        pbitmap->data  = NULL;
        pbitmap->pitch = 0;
 
        dbgprintf("%s fail\n", __FUNCTION__);
        return ret;
    };
 
    pbitmap->data  = bitmap->uaddr;
    pbitmap->pitch = bitmap->pitch;
 
    return 0;
};
 
int init_hman(struct hman *man, u32 count)
{
    u32* data;
 
    data = malloc(count*sizeof(u32*));
    if(data)
    {
        int i;
 
        for(i=0;i < count-1;)
            data[i] = ++i;
        data[i] = 0;
 
        man->table = data;
        man->next  = 0;
        man->avail = count;
        man->count = count;
 
        return 0;
    };
    return -ENOMEM;
};
 
u32  alloc_handle(struct hman *man)
{
    u32 handle = 0;
 
    if(man->avail)
    {
        handle = man->next;
        man->next = man->table[handle];
        man->avail--;
        handle++;
    }
    return handle;
};
 
int free_handle(struct hman *man, u32 handle)
{
    int ret = -1;
 
    handle--;
 
    if(handle < man->count)
    {
        man->table[handle] = man->next;
        man->next = handle;
        man->avail++;
        ret = 0;
    };
 
    return ret;
};
 
 
void *drm_intel_bo_map(struct drm_i915_gem_object *obj, int write_enable)
{
    u8 *kaddr;
 
    kaddr = AllocKernelSpace(obj->base.size);
    if( kaddr != NULL)
    {
        u32_t *src = (u32_t*)obj->pages;
        u32_t *dst = &((u32_t*)page_tabs)[(u32_t)kaddr >> 12];
 
        u32 count  = obj->base.size/4096;
 
        while(count--)
        {
            *dst++ = (0xFFFFF000 & *src++) | 0x003 ;
        };
        return kaddr;
    };
    return NULL;
}
 
void destroy_gem_object(uint32_t handle)
{
    struct drm_i915_gem_object *obj = (void*)handle;
    drm_gem_object_unreference(&obj->base);
 
};
 
 
void write_gem_object(uint32_t handle, u32 offset, u32 size, u8* src)
{
    struct drm_i915_gem_object *obj = (void*)handle;
    u8    *dst;
    int    ret;
 
    ret = i915_gem_object_pin(obj, 4096, true);
    if (ret)
        return;
 
    dst = drm_intel_bo_map(obj, true);
    if( dst != NULL )
    {
        memmove(dst+offset, src, size);
        FreeKernelSpace(dst);
    };
};
 
u32 get_buffer_offset(uint32_t handle)
{
    struct drm_i915_gem_object *obj = (void*)handle;
 
    return obj->gtt_offset;
};
 
 
int get_driver_caps(hwcaps_t *caps)
{
    int ret = 0;
    ENTER();
 
 
 
    switch(caps->idx)
    {
        case 0:
            caps->opt[0] = DRIVER_CAPS_0;
            caps->opt[1] = DRIVER_CAPS_1;
            break;
 
        case 1:
            caps->cap1.max_tex_width  = 4096;
            caps->cap1.max_tex_height = 4096;
            break;
        default:
            ret = 1;
    };
    caps->idx = 1;
    return ret;
}

Rev 2352	Rev 2360
1	#include	1	#include
2	#include	2	#include
3	#include "i915_drm.h"	3	#include "i915_drm.h"
4	#include "i915_drv.h"	4	#include "i915_drv.h"
5	#include "intel_drv.h"	5	#include "intel_drv.h"
6	#include "bitmap.h"	6	#include "bitmap.h"
7		7
8	#define memmove __builtin_memmove	8	#define memmove __builtin_memmove
9		9
10	int gem_object_lock(struct drm_i915_gem_object *obj);	10	int gem_object_lock(struct drm_i915_gem_object *obj);
11		11
12	#define DRIVER_CAPS_0 HW_BIT_BLIT \| HW_TEX_BLIT;	12	#define DRIVER_CAPS_0 HW_BIT_BLIT \| HW_TEX_BLIT;
13	#define DRIVER_CAPS_1 0	13	#define DRIVER_CAPS_1 0
14		14
15	extern struct drm_device *main_device;	15	extern struct drm_device *main_device;
16		16
17	struct hman bm_man;	17	struct hman bm_man;
18		18
19	void __attribute__((regparm(1))) destroy_bitmap(bitmap_t *bitmap)	19	void __attribute__((regparm(1))) destroy_bitmap(bitmap_t *bitmap)
20	{	20	{
21	printf("destroy bitmap %d\n", bitmap->handle);	21	printf("destroy bitmap %d\n", bitmap->handle);
22	free_handle(&bm_man, bitmap->handle);	22	free_handle(&bm_man, bitmap->handle);
23	bitmap->handle = 0;	23	bitmap->handle = 0;
24	bitmap->obj->base.read_domains = I915_GEM_DOMAIN_GTT;	24	bitmap->obj->base.read_domains = I915_GEM_DOMAIN_GTT;
25	bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;	25	bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;
26		26
27	mutex_lock(&main_device->struct_mutex);	27	mutex_lock(&main_device->struct_mutex);
28	drm_gem_object_unreference(&bitmap->obj->base);	28	drm_gem_object_unreference(&bitmap->obj->base);
29	mutex_unlock(&main_device->struct_mutex);	29	mutex_unlock(&main_device->struct_mutex);
30		30
31	__DestroyObject(bitmap);	31	__DestroyObject(bitmap);
32	};	32	};
33		33
34	int init_bitmaps()	34	int init_bitmaps()
35	{	35	{
36	int ret;	36	int ret;
37		37
38	ret = init_hman(&bm_man, 1024);	38	ret = init_hman(&bm_man, 1024);
39		39
40	return ret;	40	return ret;
41	};	41	};
42		42
43		43
44	int create_surface(struct io_call_10 *pbitmap)	44	int create_surface(struct io_call_10 *pbitmap)
45	{	45	{
46	struct drm_i915_gem_object *obj;	46	struct drm_i915_gem_object *obj;
47		47
48	bitmap_t *bitmap;	48	bitmap_t *bitmap;
49	u32 handle;	49	u32 handle;
50	u32 width, max_width;	50	u32 width, max_width;
51	u32 height, max_height;	51	u32 height, max_height;
52	u32 size, max_size;	52	u32 size, max_size;
53	u32 pitch, max_pitch;	53	u32 pitch, max_pitch;
54	void *uaddr;	54	void *uaddr;
55		55
56	int ret;	56	int ret;
57		57
58	pbitmap->handle = 0;	58	pbitmap->handle = 0;
59	pbitmap->data = (void*)-1;	59	pbitmap->data = (void*)-1;
60		60
61	width = pbitmap->width;	61	width = pbitmap->width;
62	height = pbitmap->height;	62	height = pbitmap->height;
63		63
64	/*	64	/*
65	if((width==0)\|\|(height==0)\|\|(width>4096)\|\|(height>4096))	65	if((width==0)\|\|(height==0)\|\|(width>4096)\|\|(height>4096))
66	goto err1;	66	goto err1;
67		67
68	if( ((pbitmap->max_width !=0 ) &&	68	if( ((pbitmap->max_width !=0 ) &&
69	(pbitmap->max_width < width)) \|\|	69	(pbitmap->max_width < width)) \|\|
70	(pbitmap->max_width > 4096) )	70	(pbitmap->max_width > 4096) )
71	goto err1;	71	goto err1;
72		72
73	if( ((pbitmap->max_height !=0 ) &&	73	if( ((pbitmap->max_height !=0 ) &&
74	(pbitmap->max_height < width)) \|\|	74	(pbitmap->max_height < width)) \|\|
75	(pbitmap->max_height > 4096) )	75	(pbitmap->max_height > 4096) )
76	goto err1;	76	goto err1;
77		77
78	if( pbitmap->format != 0)	78	if( pbitmap->format != 0)
79	goto err1;	79	goto err1;
80	*/	80	*/
81		81
82	max_width = (pbitmap->max_width ==0) ? width : pbitmap->max_width;	82	max_width = (pbitmap->max_width ==0) ? width : pbitmap->max_width;
83	max_height = (pbitmap->max_height==0) ? height : pbitmap->max_height;	83	max_height = (pbitmap->max_height==0) ? height : pbitmap->max_height;
84		84
85	handle = alloc_handle(&bm_man);	85	handle = alloc_handle(&bm_man);
86	// printf("%s %d\n",__FUNCTION__, handle);	86	// printf("%s %d\n",__FUNCTION__, handle);
87		87
88	if(handle == 0)	88	if(handle == 0)
89	goto err1;	89	goto err1;
90		90
91	bitmap = CreateObject(GetPid(), sizeof(*bitmap));	91	bitmap = CreateObject(GetPid(), sizeof(*bitmap));
92	bitmap->handle = handle;	92	bitmap->handle = handle;
93	bitmap->header.destroy = destroy_bitmap;	93	bitmap->header.destroy = destroy_bitmap;
94	bitmap->obj = NULL;	94	bitmap->obj = NULL;
95		95
96	// printf("bitmap %x\n", bitmap);	96	// printf("bitmap %x\n", bitmap);
97	if( bitmap == NULL)	97	if( bitmap == NULL)
98	goto err1;	98	goto err1;
99		99
100	hman_set_data(&bm_man, handle, bitmap);	100	hman_set_data(&bm_man, handle, bitmap);
101		101
102	pitch = ALIGN(width*4,64);	102	pitch = ALIGN(width*4,64);
103		103
104	size = roundup(pitch*height, PAGE_SIZE);	104	size = roundup(pitch*height, PAGE_SIZE);
105		105
106	// printf("pitch %d size %d\n", pitch, size);	106	// printf("pitch %d size %d\n", pitch, size);
107		107
108	obj = i915_gem_alloc_object(main_device, size);	108	obj = i915_gem_alloc_object(main_device, size);
109	if (obj == NULL)	109	if (obj == NULL)
110	goto err2;	110	goto err2;
111		111
112	ret = i915_gem_object_pin(obj, 4096, true);	112	ret = i915_gem_object_pin(obj, 4096, true);
113	if (ret)	113	if (ret)
114	goto err3;	114	goto err3;
115		115
116	max_pitch = ALIGN(max_width*4,64);	116	max_pitch = ALIGN(max_width*4,64);
117	max_size = roundup(max_pitch*max_height, PAGE_SIZE);	117	max_size = roundup(max_pitch*max_height, PAGE_SIZE);
118		118
119	uaddr = UserAlloc(max_size);	119	uaddr = UserAlloc(max_size);
120	if( uaddr == NULL)	120	if( uaddr == NULL)
121	goto err4;	121	goto err4;
122	else	122	else
123	{	123	{
124	u32_t src, dst;	124	u32_t src, dst;
125	u32 count, max_count;	125	u32 count, max_count;
126		126
127	#define page_tabs 0xFDC00000 /* really dirty hack */	127	#define page_tabs 0xFDC00000 /* really dirty hack */
128		128
129	src = (u32_t*)obj->pages;	129	src = (u32_t*)obj->pages;
130	dst = &((u32_t*)page_tabs)[(u32_t)uaddr >> 12];	130	dst = &((u32_t*)page_tabs)[(u32_t)uaddr >> 12];
131	count = size/4096;	131	count = size/4096;
132	max_count = max_size/4096 - count;	132	max_count = max_size/4096 - count;
133		133
134	while(count--)	134	while(count--)
135	{	135	{
136	dst++ = (0xFFFFF000 & src++) \| 0x207 ; // map as shared page	136	dst++ = (0xFFFFF000 & src++) \| 0x207 ; // map as shared page
137	};	137	};
138	while(max_count--)	138	while(max_count--)
139	*dst++ = 0; // cleanup unused space	139	*dst++ = 0; // cleanup unused space
140	}	140	}
141		141
142	obj->mapped = uaddr ;	142	obj->mapped = uaddr ;
143		143
144	bitmap->handle = handle;	144	bitmap->handle = handle;
145	bitmap->uaddr = uaddr;	145	bitmap->uaddr = uaddr;
146	bitmap->pitch = pitch;	146	bitmap->pitch = pitch;
147	bitmap->gaddr = obj->gtt_offset;	147	bitmap->gaddr = obj->gtt_offset;
148		148
149	bitmap->width = width;	149	bitmap->width = width;
150	bitmap->height = height;	150	bitmap->height = height;
151	bitmap->max_width = max_width;	151	bitmap->max_width = max_width;
152	bitmap->max_height = max_height;	152	bitmap->max_height = max_height;
153		153
154	bitmap->obj = obj;	154	bitmap->obj = obj;
155	bitmap->header.destroy = destroy_bitmap;	155	bitmap->header.destroy = destroy_bitmap;
156		156
157	pbitmap->handle = handle;	157	pbitmap->handle = handle;
158	pbitmap->data = uaddr;	158	pbitmap->data = uaddr;
159	pbitmap->pitch = pitch;	159	pbitmap->pitch = pitch;
160		160
161		161
162	printf("%s handle: %d pitch: %d gpu_addr: %x user_addr: %x\n",	162	printf("%s handle: %d pitch: %d gpu_addr: %x user_addr: %x\n",
163	__FUNCTION__, handle, pitch, obj->gtt_offset, uaddr);	163	__FUNCTION__, handle, pitch, obj->gtt_offset, uaddr);
164		164
165	return 0;	165	return 0;
166		166
167	err4:	167	err4:
168	i915_gem_object_unpin(obj);	168	i915_gem_object_unpin(obj);
169	err3:	169	err3:
170	drm_gem_object_unreference(&obj->base);	170	drm_gem_object_unreference(&obj->base);
171	err2:	171	err2:
172	free_handle(&bm_man, handle);	172	free_handle(&bm_man, handle);
173	__DestroyObject(bitmap);	173	__DestroyObject(bitmap);
174	err1:	174	err1:
175	return -1;	175	return -1;
176		176
177	};	177	};
178		178
179		179
180	int lock_surface(struct io_call_12 *pbitmap)	180	int lock_surface(struct io_call_12 *pbitmap)
181	{	181	{
182	int ret;	182	int ret;
183		183
184	drm_i915_private_t *dev_priv = main_device->dev_private;	184	drm_i915_private_t *dev_priv = main_device->dev_private;
185		185
186	bitmap_t *bitmap;	186	bitmap_t *bitmap;
187		187
188	if(unlikely(pbitmap->handle == 0))	188	if(unlikely(pbitmap->handle == 0))
189	return -1;	189	return -1;
190		190
191	bitmap = (bitmap_t*)hman_get_data(&bm_man, pbitmap->handle);	191	bitmap = (bitmap_t*)hman_get_data(&bm_man, pbitmap->handle);
192		192
193	if(unlikely(bitmap==NULL))	193	if(unlikely(bitmap==NULL))
194	return -1;	194	return -1;
195		195
196	ret = gem_object_lock(bitmap->obj);	196	ret = gem_object_lock(bitmap->obj);
197	if(ret !=0 )	197	if(ret !=0 )
198	{	198	{
199	pbitmap->data = NULL;	199	pbitmap->data = NULL;
200	pbitmap->pitch = 0;	200	pbitmap->pitch = 0;
201		201
202	dbgprintf("%s fail\n", __FUNCTION__);	202	dbgprintf("%s fail\n", __FUNCTION__);
203	return ret;	203	return ret;
204	};	204	};
205		205
206	pbitmap->data = bitmap->uaddr;	206	pbitmap->data = bitmap->uaddr;
207	pbitmap->pitch = bitmap->pitch;	207	pbitmap->pitch = bitmap->pitch;
208		208
209	return 0;	209	return 0;
210	};	210	};
211		211
212	int init_hman(struct hman *man, u32 count)	212	int init_hman(struct hman *man, u32 count)
213	{	213	{
214	u32* data;	214	u32* data;
215		215
216	data = malloc(countsizeof(u32));	216	data = malloc(countsizeof(u32));
217	if(data)	217	if(data)
218	{	218	{
219	int i;	219	int i;
220		220
221	for(i=0;i < count-1;)	221	for(i=0;i < count-1;)
222	data[i] = ++i;	222	data[i] = ++i;
223	data[i] = 0;	223	data[i] = 0;
224		224
225	man->table = data;	225	man->table = data;
226	man->next = 0;	226	man->next = 0;
227	man->avail = count;	227	man->avail = count;
228	man->count = count;	228	man->count = count;
229		229
230	return 0;	230	return 0;
231	};	231	};
232	return -ENOMEM;	232	return -ENOMEM;
233	};	233	};
234		234
235	u32 alloc_handle(struct hman *man)	235	u32 alloc_handle(struct hman *man)
236	{	236	{
237	u32 handle = 0;	237	u32 handle = 0;
238		238
239	if(man->avail)	239	if(man->avail)
240	{	240	{
241	handle = man->next;	241	handle = man->next;
242	man->next = man->table[handle];	242	man->next = man->table[handle];
243	man->avail--;	243	man->avail--;
244	handle++;	244	handle++;
245	}	245	}
246	return handle;	246	return handle;
247	};	247	};
248		248
249	int free_handle(struct hman *man, u32 handle)	249	int free_handle(struct hman *man, u32 handle)
250	{	250	{
251	int ret = -1;	251	int ret = -1;
252		252
253	handle--;	253	handle--;
254		254
255	if(handle < man->count)	255	if(handle < man->count)
256	{	256	{
257	man->table[handle] = man->next;	257	man->table[handle] = man->next;
258	man->next = handle;	258	man->next = handle;
259	man->avail++;	259	man->avail++;
260	ret = 0;	260	ret = 0;
261	};	261	};
262		262
263	return ret;	263	return ret;
264	};	264	};
265		265
266		266
267	void drm_intel_bo_map(struct drm_i915_gem_object obj, int write_enable)	267	void drm_intel_bo_map(struct drm_i915_gem_object obj, int write_enable)
268	{	268	{
269	u8 *kaddr;	269	u8 *kaddr;
270		270
271	kaddr = AllocKernelSpace(obj->base.size);	271	kaddr = AllocKernelSpace(obj->base.size);
272	if( kaddr != NULL)	272	if( kaddr != NULL)
273	{	273	{
274	u32_t src = (u32_t)obj->pages;	274	u32_t src = (u32_t)obj->pages;
275	u32_t dst = &((u32_t)page_tabs)[(u32_t)kaddr >> 12];	275	u32_t dst = &((u32_t)page_tabs)[(u32_t)kaddr >> 12];
276		276
277	u32 count = obj->base.size/4096;	277	u32 count = obj->base.size/4096;
278		278
279	while(count--)	279	while(count--)
280	{	280	{
281	dst++ = (0xFFFFF000 & src++) \| 0x003 ;	281	dst++ = (0xFFFFF000 & src++) \| 0x003 ;
282	};	282	};
283	return kaddr;	283	return kaddr;
284	};	284	};
285	return NULL;	285	return NULL;
286	}	286	}
287		287
288	void destroy_gem_object(uint32_t handle)	288	void destroy_gem_object(uint32_t handle)
289	{	289	{
290	struct drm_i915_gem_object obj = (void)handle;	290	struct drm_i915_gem_object obj = (void)handle;
291	drm_gem_object_unreference(&obj->base);	291	drm_gem_object_unreference(&obj->base);
292		292
293	};	293	};
294		294
295		295
296	void write_gem_object(uint32_t handle, u32 offset, u32 size, u8* src)	296	void write_gem_object(uint32_t handle, u32 offset, u32 size, u8* src)
297	{	297	{
298	struct drm_i915_gem_object obj = (void)handle;	298	struct drm_i915_gem_object obj = (void)handle;
299	u8 *dst;	299	u8 *dst;
300	int ret;	300	int ret;
301		301
302	ret = i915_gem_object_pin(obj, 4096, true);	302	ret = i915_gem_object_pin(obj, 4096, true);
303	if (ret)	303	if (ret)
304	return;	304	return;
305		305
306	dst = drm_intel_bo_map(obj, true);	306	dst = drm_intel_bo_map(obj, true);
307	if( dst != NULL )	307	if( dst != NULL )
308	{	308	{
309	memmove(dst+offset, src, size);	309	memmove(dst+offset, src, size);
310	FreeKernelSpace(dst);	310	FreeKernelSpace(dst);
311	};	311	};
312	};	312	};
313		313
314	u32 get_buffer_offset(uint32_t handle)	314	u32 get_buffer_offset(uint32_t handle)
315	{	315	{
316	struct drm_i915_gem_object obj = (void)handle;	316	struct drm_i915_gem_object obj = (void)handle;
317		317
318	return obj->gtt_offset;	318	return obj->gtt_offset;
319	};	319	};
320		320
321		321
322	int get_driver_caps(hwcaps_t *caps)	322	int get_driver_caps(hwcaps_t *caps)
323	{	323	{
324	int ret = 0;	324	int ret = 0;
325	ENTER();	325	ENTER();
326		326
327	dbgprintf("caps ptr %x\n", caps);	-
328		-
329	switch(caps->idx)	327	switch(caps->idx)
330	{	328	{
331	case 0:	329	case 0:
332	caps->opt[0] = DRIVER_CAPS_0;	330	caps->opt[0] = DRIVER_CAPS_0;
333	caps->opt[1] = DRIVER_CAPS_1;	331	caps->opt[1] = DRIVER_CAPS_1;
334	break;	332	break;
335		333
336	case 1:	334	case 1:
337	caps->cap1.max_tex_width = 4096;	335	caps->cap1.max_tex_width = 4096;
338	caps->cap1.max_tex_height = 4096;	336	caps->cap1.max_tex_height = 4096;
339	break;	337	break;
340	default:	338	default:
341	ret = 1;	339	ret = 1;
342	};	340	};
343	caps->idx = 1;	341	caps->idx = 1;
344	return ret;	342	return ret;
345	}	343	}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/bitmap.c – Rev 2352 → 2360