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

 #include
-#include
-#include "i915_drm.h"
+#include
 #include "i915_drv.h"
 #include "intel_drv.h"
+#include "hmm.h"
 #include "bitmap.h"
+#define DRIVER_CAPS_0   HW_BIT_BLIT;
-#define memmove __builtin_memmove
+#define DRIVER_CAPS_1   0
-int gem_object_lock(struct drm_i915_gem_object *obj);
 struct context *context_map[256];
-#define DRIVER_CAPS_0   HW_BIT_BLIT | HW_TEX_BLIT;
-#define DRIVER_CAPS_1   0
+struct hmm bm_mm;
+extern struct drm_device *main_device;
 extern struct drm_device *main_device;
+void __attribute__((regparm(1))) destroy_bitmap(bitmap_t *bitmap)
 struct hman bm_man;
     dma_addr_t *pages = bitmap->obj->allocated_pages;;
-void __attribute__((regparm(1))) destroy_bitmap(bitmap_t *bitmap)
+    int i;
     printf("destroy bitmap %d\n", bitmap->handle);
-    free_handle(&bm_man, bitmap->handle);
+    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);
-    bitmap->handle = 0;
+    if(pages != NULL)
     bitmap->obj->base.read_domains = I915_GEM_DOMAIN_GTT;
+        for (i = 0; i < bitmap->page_count; i++)
-    bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;
+            FreePage(pages[i]);
-    mutex_lock(&main_device->struct_mutex);
+        free(pages);
+    };
+    UserFree(bitmap->uaddr);
+    __DestroyObject(bitmap);
+};
-    drm_gem_object_unreference(&bitmap->obj->base);
+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.
+     */
-    mutex_unlock(&main_device->struct_mutex);
+    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,
+};
+#if 0
+struct  io_call_10         /*     SRV_CREATE_SURFACE    */
+{
+    u32     handle;       // ignored
-    __DestroyObject(bitmap);
+    void   *data;         // ignored
 };
     u32     width;
-int init_bitmaps()
+    u32     height;
     u32     pitch;        // ignored
     int ret;
     u32     max_width;
-    ret = init_hman(&bm_man, 1024);
+    u32     max_height;
     u32     format;       // reserved mbz
-    return ret;
+};
+#endif
+int create_surface(struct drm_device *dev, struct io_call_10 *pbitmap)
 };
     struct drm_i915_gem_object *obj;
-int create_surface(struct io_call_10 *pbitmap)
+    bitmap_t   *bitmap;
     u32         handle;
-    struct drm_i915_gem_object *obj;
     u32         width, max_width;
-    bitmap_t   *bitmap;
+    u32         height, max_height;
+    u32         size,  max_size;
-    u32         handle;
+    u32         pitch, max_pitch;
-    u32         width, max_width;
+    void       *uaddr;
-    u32         height, max_height;
+    dma_addr_t *pages;
-    u32         size,  max_size;
+    u32         page_count;
     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);
+    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 err1;
+        goto err2;
-    bitmap->handle = handle;
-    bitmap->header.destroy = destroy_bitmap;
+    bitmap->handle = handle;
-    bitmap->obj    = NULL;
     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)
+    hmm_set_data(&bm_mm, handle, bitmap);
+    pitch = ALIGN(width*4,64);
-        goto err2;
+    size =  roundup(pitch*height, PAGE_SIZE);
-    ret = i915_gem_object_pin(obj, 4096, true);
+//    printf("pitch %d size %d\n", pitch, size);
     if (ret)
-        goto err3;
+    max_pitch = ALIGN(max_width*4,64);
+    max_size =  roundup(max_pitch*max_height, PAGE_SIZE);
-    max_pitch = ALIGN(max_width*4,64);
+//    printf("max_pitch %d max_size %d\n", max_pitch, max_size);
-    max_size =  roundup(max_pitch*max_height, PAGE_SIZE);
+    uaddr = UserAlloc(max_size);
-    uaddr = UserAlloc(max_size);
+    if( uaddr == NULL)
-    if( uaddr == NULL)
+        goto err3;
-        goto err4;
+    else
-    else
+    {
         u32           max_count;
+        dma_addr_t    page;
+        char *vaddr = uaddr;
+        page_count = size/PAGE_SIZE;
+        max_count = max_size/PAGE_SIZE;
-        u32_t *src, *dst;
+        pages = kzalloc(max_count*sizeof(dma_addr_t), 0);
+        if( pages == NULL)
+            goto err4;
         u32 count, max_count;
+        for(i = 0; 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
-#define page_tabs  0xFDC00000      /* really dirty hack */
+        };
+        bitmap->page_count = page_count;
+        bitmap->max_count  = max_count;
-        src =  (u32_t*)obj->pages;
+    };
         dst =  &((u32_t*)page_tabs)[(u32_t)uaddr >> 12];
-        count = size/4096;
+    obj = i915_gem_alloc_object(dev, size);
             __FUNCTION__, handle, pitch, obj->gtt_offset, uaddr);
     return 0;
+err5:
+    mutex_lock(&dev->struct_mutex);
+    drm_gem_object_unreference(&obj->base);
+    mutex_unlock(&dev->struct_mutex);
+err4:
-err4:
+    while (i--)
+        FreePage(pages[i]);
+    free(pages);
+    UserFree(uaddr);
     i915_gem_object_unpin(obj);
-err3:
-    drm_gem_object_unreference(&obj->base);
-err2:
-    free_handle(&bm_man, handle);
+err3:
+    __DestroyObject(bitmap);
+err2:
-    __DestroyObject(bitmap);
+    free_handle(&bm_mm, handle);
 err1:
-    return -1;
     return -1;
 };
-int lock_surface(struct io_call_12 *pbitmap)
-{
-    int ret;
+int lock_surface(struct io_call_12 *pbitmap)
+{
-    drm_i915_private_t *dev_priv = main_device->dev_private;
+    int ret;
     bitmap_t  *bitmap;
     if(unlikely(pbitmap->handle == 0))
+        return -1;
         return -1;
     bitmap = (bitmap_t*)hmm_get_data(&bm_mm, pbitmap->handle);
     bitmap = (bitmap_t*)hman_get_data(&bm_man, pbitmap->handle);
     if(unlikely(bitmap==NULL))
     return 0;
 };
-int init_hman(struct hman *man, u32 count)
-{
-    u32* data;
-    data = malloc(count*sizeof(u32*));
-    if(data)
+int init_bitmaps()
-    {
-        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;
+    int ret;
-        return 0;
-    };
-    return -ENOMEM;
-};
-u32  alloc_handle(struct hman *man)
-{
-    u32 handle = 0;
-    if(man->avail)
-    {
-        handle = man->next;
-        man->next = man->table[handle];
+    ret = init_hmm(&bm_mm, 1024);
-        man->avail--;
-        handle++;
-    }
-    return handle;
+    return ret;
 };
-int free_handle(struct hman *man, u32 handle)
-{
-    int ret = -1;
+int get_driver_caps(hwcaps_t *caps)
+{
+    int ret = 0;
-    handle--;
+    switch(caps->idx)
+    {
+        case 0:
             caps->opt[0] = DRIVER_CAPS_0;
+            caps->opt[1] = DRIVER_CAPS_1;
+            break;
-    if(handle < man->count)
+        case 1:
             caps->cap1.max_tex_width  = 4096;
-        man->table[handle] = man->next;
+            caps->cap1.max_tex_height = 4096;
-        man->next = handle;
-        man->avail++;
-        ret = 0;
-    };
+            break;
-    return ret;
+        default:
+            ret = 1;
+    };
-};
+    caps->idx = 1;
-void *drm_intel_bo_map(struct drm_i915_gem_object *obj, int write_enable)
-{
-    u8 *kaddr;
+    return ret;
-    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--)
-        {
+void __attribute__((regparm(1))) destroy_context(struct context *context)
-            *dst++ = (0xFFFFF000 & *src++) | 0x003 ;
+{
+    printf("destroy context %x\n", context);
         };
-        return kaddr;
+    context_map[context->slot] = NULL;
-    };
-    return NULL;
-}
-void destroy_gem_object(uint32_t handle)
-{
-    struct drm_i915_gem_object *obj = (void*)handle;
+    mutex_lock(&main_device->struct_mutex);
-    drm_gem_object_unreference(&obj->base);
+    drm_gem_object_unreference(&context->obj->base);
-};
+    mutex_unlock(&main_device->struct_mutex);
     __DestroyObject(context);
+};
-void write_gem_object(uint32_t handle, u32 offset, u32 size, u8* src)
-{
-    struct drm_i915_gem_object *obj = (void*)handle;
+#define CURRENT_TASK             (0x80003000)
-    u8    *dst;
-    int    ret;
+struct context *get_context(struct drm_device *dev)
+{
-    ret = i915_gem_object_pin(obj, 4096, true);
-    if (ret)
+    struct context *context;
-        return;
+    struct io_call_10 io_10;
-    dst = drm_intel_bo_map(obj, true);
+    int    slot = *((u8*)CURRENT_TASK);
-    if( dst != NULL )
+    int    ret;
-    {
-        memmove(dst+offset, src, size);
-        FreeKernelSpace(dst);
-    };
-};
+    context = context_map[slot];
-u32 get_buffer_offset(uint32_t handle)
     if( context != NULL)
-    struct drm_i915_gem_object *obj = (void*)handle;
-    return obj->gtt_offset;

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/bitmap.c @ 3037 – Rev 2361 → 3033