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


#include 
#include 
#include "radeon.h"
#include "hmm.h"
#include "bitmap.h"
 
//#define DRIVER_CAPS_0   HW_BIT_BLIT
 
#define DRIVER_CAPS_0   0
#define DRIVER_CAPS_1   0
 
struct context *context_map[256];
 
struct hmm bm_mm;
 
extern struct drm_device *main_drm_device;
 
 
void __attribute__((regparm(1))) destroy_bitmap(bitmap_t *bitmap)
{
//    dma_addr_t *pages = bitmap->obj->allocated_pages;
    int i;
 
    free_handle(&bm_mm, 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);
 
//    if(pages != NULL)
//    {
//        for (i = 0; i < bitmap->page_count; i++)
//            FreePage(pages[i]);
 
//        DRM_DEBUG("%s release %d pages\n", __FUNCTION__, bitmap->page_count);
 
//        free(pages);
//    };
    UserFree(bitmap->uaddr);
    __DestroyObject(bitmap);
};
 
#if 0
static int bitmap_get_pages_gtt(struct drm_i915_gem_object *obj)
{
    int page_count;
 
    /* Get the list of pages out of our struct file.  They'll be pinned
     * at this point until we release them.
     */
 
    page_count = obj->base.size / PAGE_SIZE;
    BUG_ON(obj->allocated_pages == NULL);
    BUG_ON(obj->pages.page != NULL);
 
    obj->pages.page = obj->allocated_pages;
    obj->pages.nents = page_count;
 
 
//   if (obj->tiling_mode != I915_TILING_NONE)
//       i915_gem_object_do_bit_17_swizzle(obj);
 
    return 0;
}
 
static void bitmap_put_pages_gtt(struct drm_i915_gem_object *obj)
{
    int ret, i;
 
    BUG_ON(obj->madv == __I915_MADV_PURGED);
 
    ret = i915_gem_object_set_to_cpu_domain(obj, true);
    if (ret) {
        /* In the event of a disaster, abandon all caches and
         * hope for the best.
         */
        WARN_ON(ret != -EIO);
        i915_gem_clflush_object(obj);
        obj->base.read_domains = obj->base.write_domain = I915_GEM_DOMAIN_CPU;
    }
 
    if (obj->madv == I915_MADV_DONTNEED)
        obj->dirty = 0;
 
    obj->dirty = 0;
}
 
static const struct drm_i915_gem_object_ops bitmap_object_ops = {
    .get_pages = bitmap_get_pages_gtt,
    .put_pages = bitmap_put_pages_gtt,
};
 
 
 
struct  io_call_10         /*     SRV_CREATE_SURFACE    */
{
    u32     handle;       // ignored
    void   *data;         // ignored
 
    u32     width;
    u32     height;
    u32     pitch;        // ignored
 
    u32     max_width;
    u32     max_height;
    u32     format;       // reserved mbz
};
 
#endif
 
int create_surface(struct drm_device *dev, struct io_call_10 *pbitmap)
{
    struct radeon_device *rdev = dev->dev_private;
    struct radeon_bo     *obj = NULL;
 
    bitmap_t   *bitmap;
    u32         handle;
    u32         width, max_width;
    u32         height, max_height;
    u32         size,  max_size;
    u32         pitch, max_pitch;
    void       *uaddr;
    dma_addr_t *pages;
    u32         page_count;
 
    int         i;
 
    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;
 
    max_width  = (pbitmap->max_width ==0) ? width  : pbitmap->max_width;
    max_height = (pbitmap->max_height==0) ? height : pbitmap->max_height;
 
    handle = alloc_handle(&bm_mm);
//    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 err2;
 
    bitmap->handle = handle;
    bitmap->header.destroy = destroy_bitmap;
    bitmap->obj    = NULL;
 
    hmm_set_data(&bm_mm, handle, bitmap);
 
    pitch = ALIGN(width*4,64);
    size =  roundup(pitch*height, PAGE_SIZE);
 
//    printf("pitch %d size %d\n", pitch, size);
 
    max_pitch = ALIGN(max_width*4,64);
    max_size =  roundup(max_pitch*max_height, PAGE_SIZE);
 
//    printf("max_pitch %d max_size %d\n", max_pitch, max_size);
 
    ret = radeon_bo_create(rdev, size, PAGE_SIZE, false, RADEON_GEM_DOMAIN_GTT, NULL, &obj);
 
    if (unlikely(ret != 0))
        goto err3;
 
    ret = radeon_bo_reserve(obj, false);
    if (unlikely(ret != 0))
        goto err3;
 
    ret = radeon_bo_pin(obj, RADEON_GEM_DOMAIN_GTT, NULL);
    if (unlikely(ret != 0))
        goto err3;
 
    ret = radeon_bo_user_map(obj, (void**)&uaddr);
    if (unlikely(ret != 0))
        goto err3;
 
    bitmap->page_count = size/PAGE_SIZE;
    bitmap->max_count  =  max_size/PAGE_SIZE;
 
//    DRM_DEBUG("%s alloc %d pages\n", __FUNCTION__, page_count);
 
    bitmap->handle = handle;
    bitmap->uaddr  = uaddr;
    bitmap->pitch  = pitch;
    bitmap->gaddr  = radeon_bo_gpu_offset(obj);
 
    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;
 
 
    DRM_DEBUG("%s handle: %d pitch: %d gpu_addr: %x user_addr: %x\n",
            __FUNCTION__, handle, pitch, bitmap->gaddr, uaddr);
 
    return 0;
 
err5:
//    mutex_lock(&dev->struct_mutex);
//    drm_gem_object_unreference(&obj->base);
//    mutex_unlock(&dev->struct_mutex);
 
err4:
//    while (i--)
//        FreePage(pages[i]);
//    free(pages);
//    UserFree(uaddr);
 
err3:
    __DestroyObject(bitmap);
err2:
    free_handle(&bm_mm, handle);
err1:
    return -1;
};
 
 
int lock_surface(struct io_call_12 *pbitmap)
{
    int ret;
 
    bitmap_t  *bitmap;
 
    if(unlikely(pbitmap->handle == 0))
        return -1;
 
    bitmap = (bitmap_t*)hmm_get_data(&bm_mm, pbitmap->handle);
 
    if(unlikely(bitmap==NULL))
        return -1;
/*
    mutex_lock(&main_device->struct_mutex);
    ret = i915_gem_object_set_to_cpu_domain(bitmap->obj, true);
    mutex_unlock(&main_device->struct_mutex);
 
    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;
};
 
 
#if 0
 
int resize_surface(struct io_call_14 *pbitmap)
{
    bitmap_t  *bitmap;
    dma_addr_t page, *pages;
    u32        size, page_count;
    u32        width, height;
    u32        pitch;
    int        i;
    int        ret = 0;
 
 
    if(unlikely(pbitmap->handle == 0))
        return -1;
 
    bitmap = (bitmap_t*)hmm_get_data(&bm_mm, pbitmap->handle);
 
    if(unlikely(bitmap==NULL))
        return -1;
 
    if( pbitmap->new_width > bitmap->max_width ||
        pbitmap->new_height > bitmap->max_height)
        return -1;
 
    width  = pbitmap->new_width;
    height = pbitmap->new_height;
 
    pitch = ALIGN(width*4,64);
    size =  roundup(pitch * height, PAGE_SIZE);
    page_count = size/PAGE_SIZE;
 
    DRM_DEBUG("new width %d height %d pitch %d size %d\n",
            width, height, pitch, size);
 
    if(page_count > bitmap->page_count)
    {
        char *vaddr = bitmap->uaddr + PAGE_SIZE * bitmap->page_count;
 
        pages = bitmap->obj->allocated_pages;
 
        DRM_DEBUG("old pages %d new_pages %d vaddr %x\n",
                bitmap->page_count, page_count, vaddr);
 
        for(i = bitmap->page_count; i < page_count; i++, vaddr+= PAGE_SIZE)
        {
            page = AllocPage();
            if ( page == 0 )
                goto err4;
            pages[i] = page;
            MapPage(vaddr, page, 0x207);        //map as shared page
        };
 
        DRM_DEBUG("%s alloc %d pages\n", __FUNCTION__,
                  page_count - bitmap->page_count);
 
        i915_gem_object_unpin(bitmap->obj);
        i915_gem_object_unbind(bitmap->obj);
        bitmap->obj->base.size = size;
        bitmap->obj->pages.nents = page_count;
 
        ret = i915_gem_object_pin(bitmap->obj, PAGE_SIZE, true,true);
        if (ret)
            goto err4;
 
        bitmap->page_count = page_count;
        bitmap->gaddr  = bitmap->obj->gtt_offset;
    }
    else if(page_count < bitmap->page_count)
    {
        char *vaddr = bitmap->uaddr + PAGE_SIZE * page_count;
 
        i915_gem_object_unpin(bitmap->obj);
        i915_gem_object_unbind(bitmap->obj);
 
        pages = bitmap->obj->allocated_pages;
 
        DRM_DEBUG("old pages %d new_pages %d vaddr %x\n",
                bitmap->page_count, page_count, vaddr);
 
        for(i = page_count; i < bitmap->page_count; i++, vaddr+= PAGE_SIZE)
        {
            MapPage(vaddr, 0, 0);        //unmap
 
            FreePage(pages[i]);
            pages[i] = 0;
        };
 
        DRM_DEBUG("%s release %d pages\n", __FUNCTION__,
                  bitmap->page_count - page_count);
 
        bitmap->obj->base.size = size;
        bitmap->obj->pages.nents = page_count;
 
        ret = i915_gem_object_pin(bitmap->obj, PAGE_SIZE, true,true);
        if (ret)
            goto err3;
 
        bitmap->page_count = page_count;
        bitmap->gaddr  = bitmap->obj->gtt_offset;
    };
 
    bitmap->width  = width;
    bitmap->height = height;
    bitmap->pitch  = pitch;
 
 
    pbitmap->data  = bitmap->uaddr;
    pbitmap->pitch = bitmap->pitch;
 
    return 0;
 
err4:
    while (i-- > bitmap->page_count)
        FreePage(pages[i]);
 
err3:
    return -1;
};
#endif
 
 
int init_bitmaps()
{
    int ret;
 
    ret = init_hmm(&bm_mm, 1024);
 
    return ret;
};
 
 
 
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;
    LEAVE();
    return ret;
}
 
 
void __attribute__((regparm(1))) destroy_context(struct context *context)
{
    struct radeon_device *rdev = main_drm_device->dev_private;
 
    DRM_DEBUG("destroy context %x\n", context);
 
    context_map[context->slot] = NULL;
 
    radeon_ib_free(rdev, &context->ib);
 
    __DestroyObject(context);
};
 
 
#define CURRENT_TASK             (0x80003000)
 
struct context *get_context(struct drm_device *dev)
{
    struct radeon_device *rdev = dev->dev_private;
    struct context *context;
    struct io_call_10 io_10;
    int    slot = *((u8*)CURRENT_TASK);
    int    ret;
 
    context = context_map[slot];
 
    if( context != NULL)
        return context;
 
    context = CreateObject(GetPid(), sizeof(*context));
 
    if( context != NULL)
    {
        ret = radeon_ib_get(rdev, RADEON_RING_TYPE_GFX_INDEX, &context->ib, NULL, 4096);
        if (ret) {
            DRM_ERROR("radeon: failed to get ib (%d).\n", ret);
            goto err;
        };
 
        context->cmd_buffer = context->ib.ptr;
 
        context->header.destroy = destroy_context;
        context->mask  = NULL;
        context->seqno = 0;
        context->slot  = slot;
 
        context_map[slot] = context;
    };
    return context;
 
err:
    __DestroyObject(context);
    return NULL;
};

Rev 3120	Rev 3192
1	#include	1	#include
2	#include	2	#include
3	#include "radeon.h"	3	#include "radeon.h"
4	#include "hmm.h"	4	#include "hmm.h"
5	#include "bitmap.h"	5	#include "bitmap.h"
6		6
7	//#define DRIVER_CAPS_0 HW_BIT_BLIT	7	//#define DRIVER_CAPS_0 HW_BIT_BLIT
8		8
9	#define DRIVER_CAPS_0 0	9	#define DRIVER_CAPS_0 0
10	#define DRIVER_CAPS_1 0	10	#define DRIVER_CAPS_1 0
11		11
12	struct context *context_map[256];	12	struct context *context_map[256];
13		13
14	struct hmm bm_mm;	14	struct hmm bm_mm;
15		15
16	extern struct drm_device *main_drm_device;	16	extern struct drm_device *main_drm_device;
17		17
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	// dma_addr_t *pages = bitmap->obj->allocated_pages;	21	// dma_addr_t *pages = bitmap->obj->allocated_pages;
22	int i;	22	int i;
23		23
24	free_handle(&bm_mm, bitmap->handle);	24	free_handle(&bm_mm, bitmap->handle);
25	bitmap->handle = 0;	25	bitmap->handle = 0;
26	// bitmap->obj->base.read_domains = I915_GEM_DOMAIN_GTT;	26	// bitmap->obj->base.read_domains = I915_GEM_DOMAIN_GTT;
27	// bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;	27	// bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;
28		28
29	// mutex_lock(&main_device->struct_mutex);	29	// mutex_lock(&main_device->struct_mutex);
30	// drm_gem_object_unreference(&bitmap->obj->base);	30	// drm_gem_object_unreference(&bitmap->obj->base);
31	// mutex_unlock(&main_device->struct_mutex);	31	// mutex_unlock(&main_device->struct_mutex);
32		32
33	// if(pages != NULL)	33	// if(pages != NULL)
34	// {	34	// {
35	// for (i = 0; i < bitmap->page_count; i++)	35	// for (i = 0; i < bitmap->page_count; i++)
36	// FreePage(pages[i]);	36	// FreePage(pages[i]);
37		37
38	// DRM_DEBUG("%s release %d pages\n", __FUNCTION__, bitmap->page_count);	38	// DRM_DEBUG("%s release %d pages\n", __FUNCTION__, bitmap->page_count);
39		39
40	// free(pages);	40	// free(pages);
41	// };	41	// };
42	UserFree(bitmap->uaddr);	42	UserFree(bitmap->uaddr);
43	__DestroyObject(bitmap);	43	__DestroyObject(bitmap);
44	};	44	};
45		45
46	#if 0	46	#if 0
47	static int bitmap_get_pages_gtt(struct drm_i915_gem_object *obj)	47	static int bitmap_get_pages_gtt(struct drm_i915_gem_object *obj)
48	{	48	{
49	int page_count;	49	int page_count;
50		50
51	/* Get the list of pages out of our struct file. They'll be pinned	51	/* Get the list of pages out of our struct file. They'll be pinned
52	* at this point until we release them.	52	* at this point until we release them.
53	*/	53	*/
54		54
55	page_count = obj->base.size / PAGE_SIZE;	55	page_count = obj->base.size / PAGE_SIZE;
56	BUG_ON(obj->allocated_pages == NULL);	56	BUG_ON(obj->allocated_pages == NULL);
57	BUG_ON(obj->pages.page != NULL);	57	BUG_ON(obj->pages.page != NULL);
58		58
59	obj->pages.page = obj->allocated_pages;	59	obj->pages.page = obj->allocated_pages;
60	obj->pages.nents = page_count;	60	obj->pages.nents = page_count;
61		61
62		62
63	// if (obj->tiling_mode != I915_TILING_NONE)	63	// if (obj->tiling_mode != I915_TILING_NONE)
64	// i915_gem_object_do_bit_17_swizzle(obj);	64	// i915_gem_object_do_bit_17_swizzle(obj);
65		65
66	return 0;	66	return 0;
67	}	67	}
68		68
69	static void bitmap_put_pages_gtt(struct drm_i915_gem_object *obj)	69	static void bitmap_put_pages_gtt(struct drm_i915_gem_object *obj)
70	{	70	{
71	int ret, i;	71	int ret, i;
72		72
73	BUG_ON(obj->madv == __I915_MADV_PURGED);	73	BUG_ON(obj->madv == __I915_MADV_PURGED);
74		74
75	ret = i915_gem_object_set_to_cpu_domain(obj, true);	75	ret = i915_gem_object_set_to_cpu_domain(obj, true);
76	if (ret) {	76	if (ret) {
77	/* In the event of a disaster, abandon all caches and	77	/* In the event of a disaster, abandon all caches and
78	* hope for the best.	78	* hope for the best.
79	*/	79	*/
80	WARN_ON(ret != -EIO);	80	WARN_ON(ret != -EIO);
81	i915_gem_clflush_object(obj);	81	i915_gem_clflush_object(obj);
82	obj->base.read_domains = obj->base.write_domain = I915_GEM_DOMAIN_CPU;	82	obj->base.read_domains = obj->base.write_domain = I915_GEM_DOMAIN_CPU;
83	}	83	}
84		84
85	if (obj->madv == I915_MADV_DONTNEED)	85	if (obj->madv == I915_MADV_DONTNEED)
86	obj->dirty = 0;	86	obj->dirty = 0;
87		87
88	obj->dirty = 0;	88	obj->dirty = 0;
89	}	89	}
90		90
91	static const struct drm_i915_gem_object_ops bitmap_object_ops = {	91	static const struct drm_i915_gem_object_ops bitmap_object_ops = {
92	.get_pages = bitmap_get_pages_gtt,	92	.get_pages = bitmap_get_pages_gtt,
93	.put_pages = bitmap_put_pages_gtt,	93	.put_pages = bitmap_put_pages_gtt,
94	};	94	};
95		95
96		96
97		97
98	struct io_call_10 /* SRV_CREATE_SURFACE */	98	struct io_call_10 /* SRV_CREATE_SURFACE */
99	{	99	{
100	u32 handle; // ignored	100	u32 handle; // ignored
101	void *data; // ignored	101	void *data; // ignored
102		102
103	u32 width;	103	u32 width;
104	u32 height;	104	u32 height;
105	u32 pitch; // ignored	105	u32 pitch; // ignored
106		106
107	u32 max_width;	107	u32 max_width;
108	u32 max_height;	108	u32 max_height;
109	u32 format; // reserved mbz	109	u32 format; // reserved mbz
110	};	110	};
111		111
112	#endif	112	#endif
113		113
114	int create_surface(struct drm_device dev, struct io_call_10 pbitmap)	114	int create_surface(struct drm_device dev, struct io_call_10 pbitmap)
115	{	115	{
116	struct radeon_device *rdev = dev->dev_private;	116	struct radeon_device *rdev = dev->dev_private;
117	struct radeon_bo *obj = NULL;	117	struct radeon_bo *obj = NULL;
118		118
119	bitmap_t *bitmap;	119	bitmap_t *bitmap;
120	u32 handle;	120	u32 handle;
121	u32 width, max_width;	121	u32 width, max_width;
122	u32 height, max_height;	122	u32 height, max_height;
123	u32 size, max_size;	123	u32 size, max_size;
124	u32 pitch, max_pitch;	124	u32 pitch, max_pitch;
125	void *uaddr;	125	void *uaddr;
126	dma_addr_t *pages;	126	dma_addr_t *pages;
127	u32 page_count;	127	u32 page_count;
128		128
129	int i;	129	int i;
130		130
131	int ret;	131	int ret;
132		132
133	pbitmap->handle = 0;	133	pbitmap->handle = 0;
134	pbitmap->data = (void*)-1;	134	pbitmap->data = (void*)-1;
135		135
136	width = pbitmap->width;	136	width = pbitmap->width;
137	height = pbitmap->height;	137	height = pbitmap->height;
138		138
139	if((width == 0)\|\|(height == 0)\|\|(width > 4096)\|\|(height > 4096))	139	if((width == 0)\|\|(height == 0)\|\|(width > 4096)\|\|(height > 4096))
140	goto err1;	140	goto err1;
141		141
142	max_width = (pbitmap->max_width ==0) ? width : pbitmap->max_width;	142	max_width = (pbitmap->max_width ==0) ? width : pbitmap->max_width;
143	max_height = (pbitmap->max_height==0) ? height : pbitmap->max_height;	143	max_height = (pbitmap->max_height==0) ? height : pbitmap->max_height;
144		144
145	handle = alloc_handle(&bm_mm);	145	handle = alloc_handle(&bm_mm);
146	// printf("%s %d\n",__FUNCTION__, handle);	146	// printf("%s %d\n",__FUNCTION__, handle);
147		147
148	if(handle == 0)	148	if(handle == 0)
149	goto err1;	149	goto err1;
150		150
151	bitmap = CreateObject(GetPid(), sizeof(*bitmap));	151	bitmap = CreateObject(GetPid(), sizeof(*bitmap));
152	// printf("bitmap %x\n", bitmap);	152	// printf("bitmap %x\n", bitmap);
153	if( bitmap == NULL)	153	if( bitmap == NULL)
154	goto err2;	154	goto err2;
155		155
156	bitmap->handle = handle;	156	bitmap->handle = handle;
157	bitmap->header.destroy = destroy_bitmap;	157	bitmap->header.destroy = destroy_bitmap;
158	bitmap->obj = NULL;	158	bitmap->obj = NULL;
159		159
160	hmm_set_data(&bm_mm, handle, bitmap);	160	hmm_set_data(&bm_mm, handle, bitmap);
161		161
162	pitch = ALIGN(width*4,64);	162	pitch = ALIGN(width*4,64);
163	size = roundup(pitch*height, PAGE_SIZE);	163	size = roundup(pitch*height, PAGE_SIZE);
164		164
165	// printf("pitch %d size %d\n", pitch, size);	165	// printf("pitch %d size %d\n", pitch, size);
166		166
167	max_pitch = ALIGN(max_width*4,64);	167	max_pitch = ALIGN(max_width*4,64);
168	max_size = roundup(max_pitch*max_height, PAGE_SIZE);	168	max_size = roundup(max_pitch*max_height, PAGE_SIZE);
169		169
170	// printf("max_pitch %d max_size %d\n", max_pitch, max_size);	170	// printf("max_pitch %d max_size %d\n", max_pitch, max_size);
171		171
172	ret = radeon_bo_create(rdev, size, PAGE_SIZE, false, RADEON_GEM_DOMAIN_GTT, NULL, &obj);	172	ret = radeon_bo_create(rdev, size, PAGE_SIZE, false, RADEON_GEM_DOMAIN_GTT, NULL, &obj);
173		173
174	if (unlikely(ret != 0))	174	if (unlikely(ret != 0))
175	goto err3;	175	goto err3;
176		176
177	ret = radeon_bo_reserve(obj, false);	177	ret = radeon_bo_reserve(obj, false);
178	if (unlikely(ret != 0))	178	if (unlikely(ret != 0))
179	goto err3;	179	goto err3;
180		180
181	ret = radeon_bo_pin(obj, RADEON_GEM_DOMAIN_GTT, NULL);	181	ret = radeon_bo_pin(obj, RADEON_GEM_DOMAIN_GTT, NULL);
182	if (unlikely(ret != 0))	182	if (unlikely(ret != 0))
183	goto err3;	183	goto err3;
184		184
185	ret = radeon_bo_user_map(obj, (void**)&uaddr);	185	ret = radeon_bo_user_map(obj, (void**)&uaddr);
186	if (unlikely(ret != 0))	186	if (unlikely(ret != 0))
187	goto err3;	187	goto err3;
188		188
189	bitmap->page_count = size/PAGE_SIZE;	189	bitmap->page_count = size/PAGE_SIZE;
190	bitmap->max_count = max_size/PAGE_SIZE;	190	bitmap->max_count = max_size/PAGE_SIZE;
191		191
192	DRM_DEBUG("%s alloc %d pages\n", __FUNCTION__, page_count);	192	// DRM_DEBUG("%s alloc %d pages\n", __FUNCTION__, page_count);
193		193
194	bitmap->handle = handle;	194	bitmap->handle = handle;
195	bitmap->uaddr = uaddr;	195	bitmap->uaddr = uaddr;
196	bitmap->pitch = pitch;	196	bitmap->pitch = pitch;
197	bitmap->gaddr = radeon_bo_gpu_offset(obj);	197	bitmap->gaddr = radeon_bo_gpu_offset(obj);
198		198
199	bitmap->width = width;	199	bitmap->width = width;
200	bitmap->height = height;	200	bitmap->height = height;
201	bitmap->max_width = max_width;	201	bitmap->max_width = max_width;
202	bitmap->max_height = max_height;	202	bitmap->max_height = max_height;
203		203
204	bitmap->obj = obj;	204	bitmap->obj = obj;
205	bitmap->header.destroy = destroy_bitmap;	205	bitmap->header.destroy = destroy_bitmap;
206		206
207	pbitmap->handle = handle;	207	pbitmap->handle = handle;
208	pbitmap->data = uaddr;	208	pbitmap->data = uaddr;
209	pbitmap->pitch = pitch;	209	pbitmap->pitch = pitch;
210		210
211		211
212	DRM_DEBUG("%s handle: %d pitch: %d gpu_addr: %x user_addr: %x\n",	212	DRM_DEBUG("%s handle: %d pitch: %d gpu_addr: %x user_addr: %x\n",
213	__FUNCTION__, handle, pitch, bitmap->gaddr, uaddr);	213	__FUNCTION__, handle, pitch, bitmap->gaddr, uaddr);
214		214
215	return 0;	215	return 0;
216		216
217	err5:	217	err5:
218	// mutex_lock(&dev->struct_mutex);	218	// mutex_lock(&dev->struct_mutex);
219	// drm_gem_object_unreference(&obj->base);	219	// drm_gem_object_unreference(&obj->base);
220	// mutex_unlock(&dev->struct_mutex);	220	// mutex_unlock(&dev->struct_mutex);
221		221
222	err4:	222	err4:
223	// while (i--)	223	// while (i--)
224	// FreePage(pages[i]);	224	// FreePage(pages[i]);
225	// free(pages);	225	// free(pages);
226	// UserFree(uaddr);	226	// UserFree(uaddr);
227		227
228	err3:	228	err3:
229	__DestroyObject(bitmap);	229	__DestroyObject(bitmap);
230	err2:	230	err2:
231	free_handle(&bm_mm, handle);	231	free_handle(&bm_mm, handle);
232	err1:	232	err1:
233	return -1;	233	return -1;
234	};	234	};
235		235
236		236
237	int lock_surface(struct io_call_12 *pbitmap)	237	int lock_surface(struct io_call_12 *pbitmap)
238	{	238	{
239	int ret;	239	int ret;
240		240
241	bitmap_t *bitmap;	241	bitmap_t *bitmap;
242		242
243	if(unlikely(pbitmap->handle == 0))	243	if(unlikely(pbitmap->handle == 0))
244	return -1;	244	return -1;
245		245
246	bitmap = (bitmap_t*)hmm_get_data(&bm_mm, pbitmap->handle);	246	bitmap = (bitmap_t*)hmm_get_data(&bm_mm, pbitmap->handle);
247		247
248	if(unlikely(bitmap==NULL))	248	if(unlikely(bitmap==NULL))
249	return -1;	249	return -1;
250	/*	250	/*
251	mutex_lock(&main_device->struct_mutex);	251	mutex_lock(&main_device->struct_mutex);
252	ret = i915_gem_object_set_to_cpu_domain(bitmap->obj, true);	252	ret = i915_gem_object_set_to_cpu_domain(bitmap->obj, true);
253	mutex_unlock(&main_device->struct_mutex);	253	mutex_unlock(&main_device->struct_mutex);
254		254
255	if(ret != 0 )	255	if(ret != 0 )
256	{	256	{
257	pbitmap->data = NULL;	257	pbitmap->data = NULL;
258	pbitmap->pitch = 0;	258	pbitmap->pitch = 0;
259		259
260	dbgprintf("%s fail\n", __FUNCTION__);	260	dbgprintf("%s fail\n", __FUNCTION__);
261	return ret;	261	return ret;
262	};	262	};
263	*/	263	*/
264	pbitmap->data = bitmap->uaddr;	264	pbitmap->data = bitmap->uaddr;
265	pbitmap->pitch = bitmap->pitch;	265	pbitmap->pitch = bitmap->pitch;
266		266
267	return 0;	267	return 0;
268	};	268	};
269		269
270		270
271	#if 0	271	#if 0
272		272
273	int resize_surface(struct io_call_14 *pbitmap)	273	int resize_surface(struct io_call_14 *pbitmap)
274	{	274	{
275	bitmap_t *bitmap;	275	bitmap_t *bitmap;
276	dma_addr_t page, *pages;	276	dma_addr_t page, *pages;
277	u32 size, page_count;	277	u32 size, page_count;
278	u32 width, height;	278	u32 width, height;
279	u32 pitch;	279	u32 pitch;
280	int i;	280	int i;
281	int ret = 0;	281	int ret = 0;
282		282
283		283
284	if(unlikely(pbitmap->handle == 0))	284	if(unlikely(pbitmap->handle == 0))
285	return -1;	285	return -1;
286		286
287	bitmap = (bitmap_t*)hmm_get_data(&bm_mm, pbitmap->handle);	287	bitmap = (bitmap_t*)hmm_get_data(&bm_mm, pbitmap->handle);
288		288
289	if(unlikely(bitmap==NULL))	289	if(unlikely(bitmap==NULL))
290	return -1;	290	return -1;
291		291
292	if( pbitmap->new_width > bitmap->max_width \|\|	292	if( pbitmap->new_width > bitmap->max_width \|\|
293	pbitmap->new_height > bitmap->max_height)	293	pbitmap->new_height > bitmap->max_height)
294	return -1;	294	return -1;
295		295
296	width = pbitmap->new_width;	296	width = pbitmap->new_width;
297	height = pbitmap->new_height;	297	height = pbitmap->new_height;
298		298
299	pitch = ALIGN(width*4,64);	299	pitch = ALIGN(width*4,64);
300	size = roundup(pitch * height, PAGE_SIZE);	300	size = roundup(pitch * height, PAGE_SIZE);
301	page_count = size/PAGE_SIZE;	301	page_count = size/PAGE_SIZE;
302		302
303	DRM_DEBUG("new width %d height %d pitch %d size %d\n",	303	DRM_DEBUG("new width %d height %d pitch %d size %d\n",
304	width, height, pitch, size);	304	width, height, pitch, size);
305		305
306	if(page_count > bitmap->page_count)	306	if(page_count > bitmap->page_count)
307	{	307	{
308	char vaddr = bitmap->uaddr + PAGE_SIZE bitmap->page_count;	308	char vaddr = bitmap->uaddr + PAGE_SIZE bitmap->page_count;
309		309
310	pages = bitmap->obj->allocated_pages;	310	pages = bitmap->obj->allocated_pages;
311		311
312	DRM_DEBUG("old pages %d new_pages %d vaddr %x\n",	312	DRM_DEBUG("old pages %d new_pages %d vaddr %x\n",
313	bitmap->page_count, page_count, vaddr);	313	bitmap->page_count, page_count, vaddr);
314		314
315	for(i = bitmap->page_count; i < page_count; i++, vaddr+= PAGE_SIZE)	315	for(i = bitmap->page_count; i < page_count; i++, vaddr+= PAGE_SIZE)
316	{	316	{
317	page = AllocPage();	317	page = AllocPage();
318	if ( page == 0 )	318	if ( page == 0 )
319	goto err4;	319	goto err4;
320	pages[i] = page;	320	pages[i] = page;
321	MapPage(vaddr, page, 0x207); //map as shared page	321	MapPage(vaddr, page, 0x207); //map as shared page
322	};	322	};
323		323
324	DRM_DEBUG("%s alloc %d pages\n", __FUNCTION__,	324	DRM_DEBUG("%s alloc %d pages\n", __FUNCTION__,
325	page_count - bitmap->page_count);	325	page_count - bitmap->page_count);
326		326
327	i915_gem_object_unpin(bitmap->obj);	327	i915_gem_object_unpin(bitmap->obj);
328	i915_gem_object_unbind(bitmap->obj);	328	i915_gem_object_unbind(bitmap->obj);
329	bitmap->obj->base.size = size;	329	bitmap->obj->base.size = size;
330	bitmap->obj->pages.nents = page_count;	330	bitmap->obj->pages.nents = page_count;
331		331
332	ret = i915_gem_object_pin(bitmap->obj, PAGE_SIZE, true,true);	332	ret = i915_gem_object_pin(bitmap->obj, PAGE_SIZE, true,true);
333	if (ret)	333	if (ret)
334	goto err4;	334	goto err4;
335		335
336	bitmap->page_count = page_count;	336	bitmap->page_count = page_count;
337	bitmap->gaddr = bitmap->obj->gtt_offset;	337	bitmap->gaddr = bitmap->obj->gtt_offset;
338	}	338	}
339	else if(page_count < bitmap->page_count)	339	else if(page_count < bitmap->page_count)
340	{	340	{
341	char vaddr = bitmap->uaddr + PAGE_SIZE page_count;	341	char vaddr = bitmap->uaddr + PAGE_SIZE page_count;
342		342
343	i915_gem_object_unpin(bitmap->obj);	343	i915_gem_object_unpin(bitmap->obj);
344	i915_gem_object_unbind(bitmap->obj);	344	i915_gem_object_unbind(bitmap->obj);
345		345
346	pages = bitmap->obj->allocated_pages;	346	pages = bitmap->obj->allocated_pages;
347		347
348	DRM_DEBUG("old pages %d new_pages %d vaddr %x\n",	348	DRM_DEBUG("old pages %d new_pages %d vaddr %x\n",
349	bitmap->page_count, page_count, vaddr);	349	bitmap->page_count, page_count, vaddr);
350		350
351	for(i = page_count; i < bitmap->page_count; i++, vaddr+= PAGE_SIZE)	351	for(i = page_count; i < bitmap->page_count; i++, vaddr+= PAGE_SIZE)
352	{	352	{
353	MapPage(vaddr, 0, 0); //unmap	353	MapPage(vaddr, 0, 0); //unmap
354		354
355	FreePage(pages[i]);	355	FreePage(pages[i]);
356	pages[i] = 0;	356	pages[i] = 0;
357	};	357	};
358		358
359	DRM_DEBUG("%s release %d pages\n", __FUNCTION__,	359	DRM_DEBUG("%s release %d pages\n", __FUNCTION__,
360	bitmap->page_count - page_count);	360	bitmap->page_count - page_count);
361		361
362	bitmap->obj->base.size = size;	362	bitmap->obj->base.size = size;
363	bitmap->obj->pages.nents = page_count;	363	bitmap->obj->pages.nents = page_count;
364		364
365	ret = i915_gem_object_pin(bitmap->obj, PAGE_SIZE, true,true);	365	ret = i915_gem_object_pin(bitmap->obj, PAGE_SIZE, true,true);
366	if (ret)	366	if (ret)
367	goto err3;	367	goto err3;
368		368
369	bitmap->page_count = page_count;	369	bitmap->page_count = page_count;
370	bitmap->gaddr = bitmap->obj->gtt_offset;	370	bitmap->gaddr = bitmap->obj->gtt_offset;
371	};	371	};
372		372
373	bitmap->width = width;	373	bitmap->width = width;
374	bitmap->height = height;	374	bitmap->height = height;
375	bitmap->pitch = pitch;	375	bitmap->pitch = pitch;
376		376
377		377
378	pbitmap->data = bitmap->uaddr;	378	pbitmap->data = bitmap->uaddr;
379	pbitmap->pitch = bitmap->pitch;	379	pbitmap->pitch = bitmap->pitch;
380		380
381	return 0;	381	return 0;
382		382
383	err4:	383	err4:
384	while (i-- > bitmap->page_count)	384	while (i-- > bitmap->page_count)
385	FreePage(pages[i]);	385	FreePage(pages[i]);
386		386
387	err3:	387	err3:
388	return -1;	388	return -1;
389	};	389	};
390	#endif	390	#endif
391		391
392		392
393	int init_bitmaps()	393	int init_bitmaps()
394	{	394	{
395	int ret;	395	int ret;
396		396
397	ret = init_hmm(&bm_mm, 1024);	397	ret = init_hmm(&bm_mm, 1024);
398		398
399	return ret;	399	return ret;
400	};	400	};
401		401
402		402
403		403
404	int get_driver_caps(hwcaps_t *caps)	404	int get_driver_caps(hwcaps_t *caps)
405	{	405	{
406	int ret = 0;	406	int ret = 0;
407		407
408	ENTER();	408	ENTER();
409	switch(caps->idx)	409	switch(caps->idx)
410	{	410	{
411	case 0:	411	case 0:
412	caps->opt[0] = DRIVER_CAPS_0;	412	caps->opt[0] = DRIVER_CAPS_0;
413	caps->opt[1] = DRIVER_CAPS_1;	413	caps->opt[1] = DRIVER_CAPS_1;
414	break;	414	break;
415		415
416	case 1:	416	case 1:
417	caps->cap1.max_tex_width = 4096;	417	caps->cap1.max_tex_width = 4096;
418	caps->cap1.max_tex_height = 4096;	418	caps->cap1.max_tex_height = 4096;
419	break;	419	break;
420	default:	420	default:
421	ret = 1;	421	ret = 1;
422	};	422	};
423	caps->idx = 1;	423	caps->idx = 1;
424	LEAVE();	424	LEAVE();
425	return ret;	425	return ret;
426	}	426	}
427		427
428		428
429	void __attribute__((regparm(1))) destroy_context(struct context *context)	429	void __attribute__((regparm(1))) destroy_context(struct context *context)
430	{	430	{
431	struct radeon_device *rdev = main_drm_device->dev_private;	431	struct radeon_device *rdev = main_drm_device->dev_private;
432		432
433	DRM_DEBUG("destroy context %x\n", context);	433	DRM_DEBUG("destroy context %x\n", context);
434		434
435	context_map[context->slot] = NULL;	435	context_map[context->slot] = NULL;
436		436
437	radeon_ib_free(rdev, &context->ib);	437	radeon_ib_free(rdev, &context->ib);
438		438
439	__DestroyObject(context);	439	__DestroyObject(context);
440	};	440	};
441		441
442		442
443	#define CURRENT_TASK (0x80003000)	443	#define CURRENT_TASK (0x80003000)
444		444
445	struct context get_context(struct drm_device dev)	445	struct context get_context(struct drm_device dev)
446	{	446	{
447	struct radeon_device *rdev = dev->dev_private;	447	struct radeon_device *rdev = dev->dev_private;
448	struct context *context;	448	struct context *context;
449	struct io_call_10 io_10;	449	struct io_call_10 io_10;
450	int slot = ((u8)CURRENT_TASK);	450	int slot = ((u8)CURRENT_TASK);
451	int ret;	451	int ret;
452		452
453	context = context_map[slot];	453	context = context_map[slot];
454		454
455	if( context != NULL)	455	if( context != NULL)
456	return context;	456	return context;
457		457
458	context = CreateObject(GetPid(), sizeof(*context));	458	context = CreateObject(GetPid(), sizeof(*context));
459		459
460	if( context != NULL)	460	if( context != NULL)
461	{	461	{
462	ret = radeon_ib_get(rdev, RADEON_RING_TYPE_GFX_INDEX, &context->ib, NULL, 4096);	462	ret = radeon_ib_get(rdev, RADEON_RING_TYPE_GFX_INDEX, &context->ib, NULL, 4096);
463	if (ret) {	463	if (ret) {
464	DRM_ERROR("radeon: failed to get ib (%d).\n", ret);	464	DRM_ERROR("radeon: failed to get ib (%d).\n", ret);
465	goto err;	465	goto err;
466	};	466	};
467		467
468	context->cmd_buffer = context->ib.ptr;	468	context->cmd_buffer = context->ib.ptr;
469		469
470	context->header.destroy = destroy_context;	470	context->header.destroy = destroy_context;
471	context->mask = NULL;	471	context->mask = NULL;
472	context->seqno = 0;	472	context->seqno = 0;
473	context->slot = slot;	473	context->slot = slot;
474		474
475	context_map[slot] = context;	475	context_map[slot] = context;
476	};	476	};
477	return context;	477	return context;
478		478
479	err:	479	err:
480	__DestroyObject(context);	480	__DestroyObject(context);
481	return NULL;	481	return NULL;
482	};	482	};

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/bitmap.c – Rev 3120 → 3192