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));
//    printf("bitmap %x\n", bitmap);
    if( bitmap == NULL)
        goto err1;
 
    bitmap->handle = handle;
    bitmap->header.destroy = destroy_bitmap;
    bitmap->obj    = NULL;
 
 
 
 
 
    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 2360	Rev 2361
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	// printf("bitmap %x\n", bitmap);
-		93	if( bitmap == NULL)
-		94	goto err1;
-		95
-		96	bitmap->handle = handle;
93	bitmap->header.destroy = destroy_bitmap;	97	bitmap->header.destroy = destroy_bitmap;
94	bitmap->obj = NULL;	98	bitmap->obj = NULL;
95		99
96	// printf("bitmap %x\n", bitmap);	-
97	if( bitmap == NULL)	-
98	goto err1;	-
99		100
100	hman_set_data(&bm_man, handle, bitmap);	101	hman_set_data(&bm_man, handle, bitmap);
101		102
102	pitch = ALIGN(width*4,64);	103	pitch = ALIGN(width*4,64);
103		104
104	size = roundup(pitch*height, PAGE_SIZE);	105	size = roundup(pitch*height, PAGE_SIZE);
105		106
106	// printf("pitch %d size %d\n", pitch, size);	107	// printf("pitch %d size %d\n", pitch, size);
107		108
108	obj = i915_gem_alloc_object(main_device, size);	109	obj = i915_gem_alloc_object(main_device, size);
109	if (obj == NULL)	110	if (obj == NULL)
110	goto err2;	111	goto err2;
111		112
112	ret = i915_gem_object_pin(obj, 4096, true);	113	ret = i915_gem_object_pin(obj, 4096, true);
113	if (ret)	114	if (ret)
114	goto err3;	115	goto err3;
115		116
116	max_pitch = ALIGN(max_width*4,64);	117	max_pitch = ALIGN(max_width*4,64);
117	max_size = roundup(max_pitch*max_height, PAGE_SIZE);	118	max_size = roundup(max_pitch*max_height, PAGE_SIZE);
118		119
119	uaddr = UserAlloc(max_size);	120	uaddr = UserAlloc(max_size);
120	if( uaddr == NULL)	121	if( uaddr == NULL)
121	goto err4;	122	goto err4;
122	else	123	else
123	{	124	{
124	u32_t src, dst;	125	u32_t src, dst;
125	u32 count, max_count;	126	u32 count, max_count;
126		127
127	#define page_tabs 0xFDC00000 /* really dirty hack */	128	#define page_tabs 0xFDC00000 /* really dirty hack */
128		129
129	src = (u32_t*)obj->pages;	130	src = (u32_t*)obj->pages;
130	dst = &((u32_t*)page_tabs)[(u32_t)uaddr >> 12];	131	dst = &((u32_t*)page_tabs)[(u32_t)uaddr >> 12];
131	count = size/4096;	132	count = size/4096;
132	max_count = max_size/4096 - count;	133	max_count = max_size/4096 - count;
133		134
134	while(count--)	135	while(count--)
135	{	136	{
136	dst++ = (0xFFFFF000 & src++) \| 0x207 ; // map as shared page	137	dst++ = (0xFFFFF000 & src++) \| 0x207 ; // map as shared page
137	};	138	};
138	while(max_count--)	139	while(max_count--)
139	*dst++ = 0; // cleanup unused space	140	*dst++ = 0; // cleanup unused space
140	}	141	}
141		142
142	obj->mapped = uaddr ;	143	obj->mapped = uaddr ;
143		144
144	bitmap->handle = handle;	145	bitmap->handle = handle;
145	bitmap->uaddr = uaddr;	146	bitmap->uaddr = uaddr;
146	bitmap->pitch = pitch;	147	bitmap->pitch = pitch;
147	bitmap->gaddr = obj->gtt_offset;	148	bitmap->gaddr = obj->gtt_offset;
148		149
149	bitmap->width = width;	150	bitmap->width = width;
150	bitmap->height = height;	151	bitmap->height = height;
151	bitmap->max_width = max_width;	152	bitmap->max_width = max_width;
152	bitmap->max_height = max_height;	153	bitmap->max_height = max_height;
153		154
154	bitmap->obj = obj;	155	bitmap->obj = obj;
155	bitmap->header.destroy = destroy_bitmap;	156	bitmap->header.destroy = destroy_bitmap;
156		157
157	pbitmap->handle = handle;	158	pbitmap->handle = handle;
158	pbitmap->data = uaddr;	159	pbitmap->data = uaddr;
159	pbitmap->pitch = pitch;	160	pbitmap->pitch = pitch;
160		161
161		162
162	printf("%s handle: %d pitch: %d gpu_addr: %x user_addr: %x\n",	163	printf("%s handle: %d pitch: %d gpu_addr: %x user_addr: %x\n",
163	__FUNCTION__, handle, pitch, obj->gtt_offset, uaddr);	164	__FUNCTION__, handle, pitch, obj->gtt_offset, uaddr);
164		165
165	return 0;	166	return 0;
166		167
167	err4:	168	err4:
168	i915_gem_object_unpin(obj);	169	i915_gem_object_unpin(obj);
169	err3:	170	err3:
170	drm_gem_object_unreference(&obj->base);	171	drm_gem_object_unreference(&obj->base);
171	err2:	172	err2:
172	free_handle(&bm_man, handle);	173	free_handle(&bm_man, handle);
173	__DestroyObject(bitmap);	174	__DestroyObject(bitmap);
174	err1:	175	err1:
175	return -1;	176	return -1;
176		177
177	};	178	};
178		179
179		180
180	int lock_surface(struct io_call_12 *pbitmap)	181	int lock_surface(struct io_call_12 *pbitmap)
181	{	182	{
182	int ret;	183	int ret;
183		184
184	drm_i915_private_t *dev_priv = main_device->dev_private;	185	drm_i915_private_t *dev_priv = main_device->dev_private;
185		186
186	bitmap_t *bitmap;	187	bitmap_t *bitmap;
187		188
188	if(unlikely(pbitmap->handle == 0))	189	if(unlikely(pbitmap->handle == 0))
189	return -1;	190	return -1;
190		191
191	bitmap = (bitmap_t*)hman_get_data(&bm_man, pbitmap->handle);	192	bitmap = (bitmap_t*)hman_get_data(&bm_man, pbitmap->handle);
192		193
193	if(unlikely(bitmap==NULL))	194	if(unlikely(bitmap==NULL))
194	return -1;	195	return -1;
195		196
196	ret = gem_object_lock(bitmap->obj);	197	ret = gem_object_lock(bitmap->obj);
197	if(ret !=0 )	198	if(ret !=0 )
198	{	199	{
199	pbitmap->data = NULL;	200	pbitmap->data = NULL;
200	pbitmap->pitch = 0;	201	pbitmap->pitch = 0;
201		202
202	dbgprintf("%s fail\n", __FUNCTION__);	203	dbgprintf("%s fail\n", __FUNCTION__);
203	return ret;	204	return ret;
204	};	205	};
205		206
206	pbitmap->data = bitmap->uaddr;	207	pbitmap->data = bitmap->uaddr;
207	pbitmap->pitch = bitmap->pitch;	208	pbitmap->pitch = bitmap->pitch;
208		209
209	return 0;	210	return 0;
210	};	211	};
211		212
-		213
212	int init_hman(struct hman *man, u32 count)	214	int init_hman(struct hman *man, u32 count)
213	{	215	{
214	u32* data;	216	u32* data;
215		217
216	data = malloc(countsizeof(u32));	218	data = malloc(countsizeof(u32));
217	if(data)	219	if(data)
218	{	220	{
219	int i;	221	int i;
220		222
221	for(i=0;i < count-1;)	223	for(i=0;i < count-1;)
222	data[i] = ++i;	224	data[i] = ++i;
223	data[i] = 0;	225	data[i] = 0;
224		226
225	man->table = data;	227	man->table = data;
226	man->next = 0;	228	man->next = 0;
227	man->avail = count;	229	man->avail = count;
228	man->count = count;	230	man->count = count;
229		231
230	return 0;	232	return 0;
231	};	233	};
232	return -ENOMEM;	234	return -ENOMEM;
233	};	235	};
234		236
235	u32 alloc_handle(struct hman *man)	237	u32 alloc_handle(struct hman *man)
236	{	238	{
237	u32 handle = 0;	239	u32 handle = 0;
238		240
239	if(man->avail)	241	if(man->avail)
240	{	242	{
241	handle = man->next;	243	handle = man->next;
242	man->next = man->table[handle];	244	man->next = man->table[handle];
243	man->avail--;	245	man->avail--;
244	handle++;	246	handle++;
245	}	247	}
246	return handle;	248	return handle;
247	};	249	};
248		250
249	int free_handle(struct hman *man, u32 handle)	251	int free_handle(struct hman *man, u32 handle)
250	{	252	{
251	int ret = -1;	253	int ret = -1;
252		254
253	handle--;	255	handle--;
254		256
255	if(handle < man->count)	257	if(handle < man->count)
256	{	258	{
257	man->table[handle] = man->next;	259	man->table[handle] = man->next;
258	man->next = handle;	260	man->next = handle;
259	man->avail++;	261	man->avail++;
260	ret = 0;	262	ret = 0;
261	};	263	};
262		264
263	return ret;	265	return ret;
264	};	266	};
265		267
266		268
267	void drm_intel_bo_map(struct drm_i915_gem_object obj, int write_enable)	269	void drm_intel_bo_map(struct drm_i915_gem_object obj, int write_enable)
268	{	270	{
269	u8 *kaddr;	271	u8 *kaddr;
270		272
271	kaddr = AllocKernelSpace(obj->base.size);	273	kaddr = AllocKernelSpace(obj->base.size);
272	if( kaddr != NULL)	274	if( kaddr != NULL)
273	{	275	{
274	u32_t src = (u32_t)obj->pages;	276	u32_t src = (u32_t)obj->pages;
275	u32_t dst = &((u32_t)page_tabs)[(u32_t)kaddr >> 12];	277	u32_t dst = &((u32_t)page_tabs)[(u32_t)kaddr >> 12];
276		278
277	u32 count = obj->base.size/4096;	279	u32 count = obj->base.size/4096;
278		280
279	while(count--)	281	while(count--)
280	{	282	{
281	dst++ = (0xFFFFF000 & src++) \| 0x003 ;	283	dst++ = (0xFFFFF000 & src++) \| 0x003 ;
282	};	284	};
283	return kaddr;	285	return kaddr;
284	};	286	};
285	return NULL;	287	return NULL;
286	}	288	}
287		289
288	void destroy_gem_object(uint32_t handle)	290	void destroy_gem_object(uint32_t handle)
289	{	291	{
290	struct drm_i915_gem_object obj = (void)handle;	292	struct drm_i915_gem_object obj = (void)handle;
291	drm_gem_object_unreference(&obj->base);	293	drm_gem_object_unreference(&obj->base);
292		294
293	};	295	};
294		296
295		297
296	void write_gem_object(uint32_t handle, u32 offset, u32 size, u8* src)	298	void write_gem_object(uint32_t handle, u32 offset, u32 size, u8* src)
297	{	299	{
298	struct drm_i915_gem_object obj = (void)handle;	300	struct drm_i915_gem_object obj = (void)handle;
299	u8 *dst;	301	u8 *dst;
300	int ret;	302	int ret;
301		303
302	ret = i915_gem_object_pin(obj, 4096, true);	304	ret = i915_gem_object_pin(obj, 4096, true);
303	if (ret)	305	if (ret)
304	return;	306	return;
305		307
306	dst = drm_intel_bo_map(obj, true);	308	dst = drm_intel_bo_map(obj, true);
307	if( dst != NULL )	309	if( dst != NULL )
308	{	310	{
309	memmove(dst+offset, src, size);	311	memmove(dst+offset, src, size);
310	FreeKernelSpace(dst);	312	FreeKernelSpace(dst);
311	};	313	};
312	};	314	};
313		315
314	u32 get_buffer_offset(uint32_t handle)	316	u32 get_buffer_offset(uint32_t handle)
315	{	317	{
316	struct drm_i915_gem_object obj = (void)handle;	318	struct drm_i915_gem_object obj = (void)handle;
317		319
318	return obj->gtt_offset;	320	return obj->gtt_offset;
319	};	321	};
320		322
321		323
322	int get_driver_caps(hwcaps_t *caps)	324	int get_driver_caps(hwcaps_t *caps)
323	{	325	{
324	int ret = 0;	326	int ret = 0;
325	ENTER();	327	ENTER();
326		328
327	switch(caps->idx)	329	switch(caps->idx)
328	{	330	{
329	case 0:	331	case 0:
330	caps->opt[0] = DRIVER_CAPS_0;	332	caps->opt[0] = DRIVER_CAPS_0;
331	caps->opt[1] = DRIVER_CAPS_1;	333	caps->opt[1] = DRIVER_CAPS_1;
332	break;	334	break;
333		335
334	case 1:	336	case 1:
335	caps->cap1.max_tex_width = 4096;	337	caps->cap1.max_tex_width = 4096;
336	caps->cap1.max_tex_height = 4096;	338	caps->cap1.max_tex_height = 4096;
337	break;	339	break;
338	default:	340	default:
339	ret = 1;	341	ret = 1;
340	};	342	};
341	caps->idx = 1;	343	caps->idx = 1;
342	return ret;	344	return ret;
343	}	345	}

Subversion Repositories Kolibri OS

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