#include <drm/drmP.h>

#include <drm/radeon_drm.h>

#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 */

};

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