Subversion Repositories Kolibri OS

#include 

#include "radeon_drm.h"

#include "radeon.h"

static struct drm_mm   mm_vram;

                 struct drm_mm_node **node)

{

    struct drm_mm_node *vm_node;

    int    r;

       return r;

        r = -ENOMEM;

        return r;

    }

            goto retry_pre_get;

    }

};

{

    u32 c = 0;

    rbo->placement.lpfn = 0;

    rbo->placement.placement = rbo->placements;

    rbo->placement.busy_placement = rbo->placements;

    if (domain & RADEON_GEM_DOMAIN_VRAM)

        rbo->placements[c++] = TTM_PL_FLAG_WC | TTM_PL_FLAG_UNCACHED |

                    TTM_PL_FLAG_VRAM;

    if (domain & RADEON_GEM_DOMAIN_GTT)

        rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_TT;

    if (domain & RADEON_GEM_DOMAIN_CPU)

        rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;

    if (!c)

        rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;

    rbo->placement.num_placement = c;

    rbo->placement.num_busy_placement = c;

}

{

    int r;

        rdev->mc.mc_vram_size >> 20,

        (unsigned long long)rdev->mc.aper_size >> 20);

    DRM_INFO("RAM width %dbits %cDR\n",

            rdev->mc.vram_width, rdev->mc.vram_is_ddr ? 'D' : 'S');

               ((rdev->mc.real_vram_size - 0xC00000) >> PAGE_SHIFT));

    if (r) {

        DRM_ERROR("Failed initializing VRAM heap.\n");

        return r;

    };

    if (r) {

        DRM_ERROR("Failed initializing GTT heap.\n");

        return r;

    }

}

{

    int r;

}

{

    bo->reserved.counter = 1;

}

                unsigned long size, int byte_align, bool kernel, u32 domain,

                struct sg_table *sg, struct radeon_bo **bo_ptr)

{

	struct radeon_bo *bo;

    enum ttm_bo_type type;

    struct drm_mm      *mman;

    u32                 bo_domain;

    int r;

        dbgprintf("Illegal buffer object size.\n");

        return -EINVAL;

    }

    {

        mman = &mm_vram;

        bo_domain = RADEON_GEM_DOMAIN_VRAM;

    }

    else if(domain & RADEON_GEM_DOMAIN_GTT)

    {

        mman = &mm_gtt;

        bo_domain = RADEON_GEM_DOMAIN_GTT;

    }

    else return -EINVAL;

        type = ttm_bo_type_kernel;

    } else {

        type = ttm_bo_type_device;

    }

    *bo_ptr = NULL;

    bo = kzalloc(sizeof(struct radeon_bo), GFP_KERNEL);

    if (bo == NULL)

        return -ENOMEM;

    if (unlikely(r)) {

		kfree(bo);

		return r;

	}

    bo->rdev = rdev;

	bo->gem_base.driver_private = NULL;

    bo->surface_reg = -1;

    bo->tbo.num_pages = num_pages;

    bo->domain = domain;

    /* Kernel allocation are uninterruptible */

    if (unlikely(r != 0))

        return r;

}

{

    int r=0, i;

        bo->pin_count++;

        if (gpu_addr)

            *gpu_addr = radeon_bo_gpu_offset(bo);

        return 0;

    }

    {

        bo->tbo.offset += (u64)bo->rdev->mc.vram_start;

    }

    else if (bo->domain & RADEON_GEM_DOMAIN_GTT)

    {

        u32_t *pagelist;

        bo->kptr  = KernelAlloc( bo->tbo.num_pages << PAGE_SHIFT );

//        dbgprintf("kernel alloc %x\n", bo->kptr );

//        dbgprintf("pagelist %x\n", pagelist);

        radeon_gart_bind(bo->rdev, bo->tbo.offset,

                         bo->tbo.vm_node->size,  pagelist, NULL);

        bo->tbo.offset += (u64)bo->rdev->mc.gtt_start;

    }

    else

    {

        DRM_ERROR("Unknown placement %x\n", bo->domain);

        bo->tbo.offset = -1;

        r = -1;

    };

        DRM_ERROR("radeon: failed to pin object.\n");

    }

        bo->pin_count = 1;

        if (gpu_addr != NULL)

            *gpu_addr = radeon_bo_gpu_offset(bo);

    }

        dev_err(bo->rdev->dev, "%p pin failed\n", bo);

    return r;

};

                 u64 *gpu_addr)

{

    int r, i;

        bo->pin_count++;

        if (gpu_addr)

            *gpu_addr = radeon_bo_gpu_offset(bo);

            u64 domain_start;

                domain_start = bo->rdev->mc.vram_start;

            else

                domain_start = bo->rdev->mc.gtt_start;

            WARN_ON_ONCE(max_offset <

                     (radeon_bo_gpu_offset(bo) - domain_start));

        }

    }

 //   radeon_ttm_placement_from_domain(bo, domain);

    if (domain == RADEON_GEM_DOMAIN_VRAM) {

        /* force to pin into visible video ram */

//        bo->placement.lpfn = bo->rdev->mc.visible_vram_size >> PAGE_SHIFT;

        bo->tbo.offset += (u64)bo->rdev->mc.vram_start;

    else if (bo->domain & RADEON_GEM_DOMAIN_GTT)

    {

        u32_t *pagelist;

        bo->kptr  = KernelAlloc( bo->tbo.num_pages << PAGE_SHIFT );

        dbgprintf("kernel alloc %x\n", bo->kptr );

        dbgprintf("pagelist %x\n", pagelist);

        radeon_gart_bind(bo->rdev, bo->tbo.offset,

                         bo->tbo.vm_node->size,  pagelist, NULL);

        bo->tbo.offset += (u64)bo->rdev->mc.gtt_start;

    }

    else

    {

        DRM_ERROR("Unknown placement %x\n", bo->domain);

        bo->tbo.offset = -1;

        r = -1;

    };

        bo->pin_count = 1;

        if (gpu_addr != NULL)

            *gpu_addr = radeon_bo_gpu_offset(bo);

    }

        dev_err(bo->rdev->dev, "%p pin failed\n", bo);

    return r;

}

{

    int r = 0;

        dev_warn(bo->rdev->dev, "%p unpin not necessary\n", bo);

        return 0;

    }

    bo->pin_count--;

    if (bo->pin_count)

        return 0;

    {

        drm_mm_put_block(bo->tbo.vm_node);

        bo->tbo.vm_node = NULL;

    };

}

{

    bool is_iomem;

        if (ptr) {

            *ptr = bo->kptr;

        }

        return 0;

    }

    {

        bo->cpu_addr = bo->rdev->mc.aper_base +

                       (bo->tbo.vm_node->start << PAGE_SHIFT);

        bo->kptr = (void*)MapIoMem(bo->cpu_addr,

                        bo->tbo.vm_node->size << 12, PG_SW);

    }

    else

    {

        return -1;

    }

        *ptr = bo->kptr;

    }

}

{

    bool is_iomem;

        if (ptr) {

            *ptr = bo->uptr;

        }

        return 0;

    }

    {

        return -1;

    }

    else

    {

        bo->uptr = UserAlloc(bo->tbo.num_pages << PAGE_SHIFT);

        if(bo->uptr)

        {

            u32_t *src, *dst;

            int count;

            src =  &((u32_t*)page_tabs)[(u32_t)bo->kptr >> 12];

            dst =  &((u32_t*)page_tabs)[(u32_t)bo->uptr >> 12];

            count = bo->tbo.num_pages;

            {

              *dst++ = (0xFFFFF000 & *src++) | 0x207 ; // map as shared page

            };

        }

        else

            return -1;

    }

        *ptr = bo->uptr;

    }

}

{

    if (bo->kptr == NULL)

        return;

    {

        FreeKernelSpace(bo->kptr);

    }

{

    struct ttm_buffer_object *tbo;

        return;

}

                uint32_t *tiling_flags,

                uint32_t *pitch)

{

//    BUG_ON(!atomic_read(&bo->tbo.reserved));

    if (tiling_flags)

        *tiling_flags = bo->tiling_flags;

    if (pitch)

        *pitch = bo->pitch;

}

            unsigned long size, bool kernel, u32 domain,

            struct radeon_bo **bo_ptr)

{

    enum ttm_bo_type    type;

    struct drm_mm       *mman;

    struct drm_mm_node  *vm_node;

    u32     bo_domain;

    int     r;

        dbgprintf("Illegal buffer object size.\n");

        return -EINVAL;

    }

        RADEON_GEM_DOMAIN_VRAM )

    {

        return -EINVAL;

    };

        type = ttm_bo_type_kernel;

    } else {

        type = ttm_bo_type_device;

    }

    *bo_ptr = NULL;

    bo = kzalloc(sizeof(struct radeon_bo), GFP_KERNEL);

    if (bo == NULL)

        return -ENOMEM;

//    bo->gobj = gobj;

    bo->surface_reg = -1;

    bo->tbo.num_pages = num_pages;

    bo->domain = domain;

    /* Kernel allocation are uninterruptible */

    vm_node->start = 0;

    vm_node->mm = NULL;

    bo->tbo.offset  = bo->tbo.vm_node->start << PAGE_SHIFT;

    bo->tbo.offset += (u64)bo->rdev->mc.vram_start;

    bo->kptr        = (void*)0xFE000000;

    bo->pin_count   = 1;

}

>