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;
 
#if 0
 
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);
};
 
 
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
};
 
 
 
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;
 
#ifndef __TTM__
    ret = radeon_bo_user_map(obj, (void**)&uaddr);
    if (unlikely(ret != 0))
        goto err3;
#endif
 
    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;
};
 
#endif

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

Subversion Repositories Kolibri OS

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