Subversion Repositories Kolibri OS

#include 

#include "i915_drv.h"

#include "intel_drv.h"

#include "hmm.h"

#include "bitmap.h"

#define DRIVER_CAPS_1   0

{

    dma_addr_t *pages = bitmap->obj->allocated_pages;

    int i;

    bitmap->handle = 0;

    bitmap->obj->base.read_domains = I915_GEM_DOMAIN_GTT;

    bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;

    drm_gem_object_unreference(&bitmap->obj->base);

    mutex_unlock(&main_device->struct_mutex);

    {

        for (i = 0; i < bitmap->page_count; i++)

            FreePage(pages[i]);

    };

    UserFree(bitmap->uaddr);

    __DestroyObject(bitmap);

};

{

    int page_count;

     * at this point until we release them.

     */

    BUG_ON(obj->allocated_pages == NULL);

    BUG_ON(obj->pages.page != NULL);

    obj->pages.nents = page_count;

//       i915_gem_object_do_bit_17_swizzle(obj);

}

{

    int ret, i;

    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;

    }

        obj->dirty = 0;

}

    .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     height;

    u32     pitch;        // ignored

    u32     max_height;

    u32     format;       // reserved mbz

};

{

    struct drm_i915_gem_object *obj;

    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;

    pbitmap->data   = (void*)-1;

    height = pbitmap->height;

        goto err1;

    if( ((pbitmap->max_width !=0 ) &&

         (pbitmap->max_width < width)) ||

         (pbitmap->max_width > 4096) )

        goto err1;

         (pbitmap->max_height < width)) ||

         (pbitmap->max_height > 4096) )

        goto err1;

        goto err1;

*/

    max_height = (pbitmap->max_height==0) ? height : pbitmap->max_height;

//    printf("%s %d\n",__FUNCTION__, handle);

        goto err1;

//    printf("bitmap %x\n", bitmap);

    if( bitmap == NULL)

        goto err2;

    bitmap->header.destroy = destroy_bitmap;

    bitmap->obj    = NULL;

    size =  roundup(pitch*height, PAGE_SIZE);

    max_size =  roundup(max_pitch*max_height, PAGE_SIZE);

    if( uaddr == NULL)

        goto err3;

    else

    {

        u32           max_count;

        dma_addr_t    page;

        char *vaddr = uaddr;

        max_count = max_size/PAGE_SIZE;

        if( pages == NULL)

            goto err4;

        {

            page = AllocPage();

            if ( page == 0 )

                goto err4;

            pages[i] = page;

        };

        for(;i < max_count; i++, vaddr+= PAGE_SIZE)

        {

            MapPage(vaddr, 0, 0);        //map as shared page

        };

        bitmap->max_count  = max_count;

    };

    if (obj == NULL)

        goto err4;

    obj->allocated_pages = pages;

    if (ret)

        goto err5;

    bitmap->uaddr  = uaddr;

    bitmap->pitch  = pitch;

    bitmap->gaddr  = obj->gtt_offset;

    bitmap->height = height;

    bitmap->max_width  = max_width;

    bitmap->max_height = max_height;

    bitmap->header.destroy = destroy_bitmap;

    pbitmap->data   = uaddr;

    pbitmap->pitch  = pitch;

            __FUNCTION__, handle, pitch, obj->gtt_offset, uaddr);

    mutex_lock(&dev->struct_mutex);

    drm_gem_object_unreference(&obj->base);

    mutex_unlock(&dev->struct_mutex);

    while (i--)

        FreePage(pages[i]);

    free(pages);

    UserFree(uaddr);

    __DestroyObject(bitmap);

err2:

    free_handle(&bm_mm, handle);

err1:

    return -1;

};

{

    int ret;

        return -1;

        return -1;

    ret = i915_gem_object_set_to_cpu_domain(bitmap->obj, true);

    mutex_unlock(&main_device->struct_mutex);

    {

        pbitmap->data  = NULL;

        pbitmap->pitch = 0;

        return ret;

    };

    pbitmap->pitch = bitmap->pitch;

};

{

    bitmap_t  *bitmap;

    dma_addr_t page, *pages;

    u32        size, page_count;

    u32        width, height;

    u32        pitch;

    int        i;

    int        ret = 0;

        return -1;

        return -1;

        pbitmap->new_height > bitmap->max_height)

        return -1;

    height = pbitmap->new_height;

    size =  roundup(pitch * height, PAGE_SIZE);

    page_count = size/PAGE_SIZE;

            width, height, pitch, size);

    {

        char *vaddr = bitmap->uaddr + PAGE_SIZE * bitmap->page_count;

                bitmap->page_count, page_count, vaddr);

        {

            page = AllocPage();

            if ( page == 0 )

                goto err4;

            pages[i] = page;

            MapPage(vaddr, page, 0x207);        //map as shared page

        };

                  page_count - bitmap->page_count);

        i915_gem_object_unbind(bitmap->obj);

        bitmap->obj->base.size = size;

        bitmap->obj->pages.nents = page_count;

        if (ret)

            goto err4;

        bitmap->gaddr  = bitmap->obj->gtt_offset;

    }

    else if(page_count < bitmap->page_count)

    {

        char *vaddr = bitmap->uaddr + PAGE_SIZE * page_count;

        i915_gem_object_unbind(bitmap->obj);

                bitmap->page_count, page_count, vaddr);

        {

            MapPage(vaddr, 0, 0);        //unmap

            pages[i] = 0;

    };

                  bitmap->page_count - page_count);

        bitmap->obj->pages.nents = page_count;

        if (ret)

            goto err3;

        bitmap->gaddr  = bitmap->obj->gtt_offset;

    };

    bitmap->height = height;

    bitmap->pitch  = pitch;

    pbitmap->pitch = bitmap->pitch;

    while (i-- > bitmap->page_count)

        FreePage(pages[i]);

    return -1;

};

{

    int ret;

};

{

    int ret = 0;

    {

        case 0:

            caps->opt[0] = DRIVER_CAPS_0;

            caps->opt[1] = DRIVER_CAPS_1;

            break;

            caps->cap1.max_tex_width  = 4096;

            caps->cap1.max_tex_height = 4096;

            break;

        default:

            ret = 1;

    };

    caps->idx = 1;

    return ret;

}

{

    DRM_DEBUG("destroy context %x\n", context);

    drm_gem_object_unreference(&context->obj->base);

    mutex_unlock(&main_device->struct_mutex);

};

{

    struct context *context;

    struct io_call_10 io_10;

    int    slot = *((u8*)CURRENT_TASK);

    int    ret;

        return context;

    {

        drm_i915_private_t *dev_priv = dev->dev_private;

        struct drm_i915_gem_object *obj;

        i915_gem_object_pin(obj, 4096, true, true);

        context->cmd_buffer = MapIoMem((addr_t)obj->pages.page[0], 4096, PG_SW|PG_NOCACHE);

        context->cmd_offset = obj->gtt_offset;

        context->mask  = NULL;

        context->seqno = 0;

        context->slot  = slot;

    };

    return context;

};