kolibrios/drivers/video/drm/ttm/ttm_bo.c

/**************************************************************************
 *
 * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 **************************************************************************/
/*
 * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
 */
/* Notes:
 *
 * We store bo pointer in drm_mm_node struct so we know which bo own a
 * specific node. There is no protection on the pointer, thus to make
 * sure things don't go berserk you have to access this pointer while
 * holding the global lru lock and make sure anytime you free a node you
 * reset the pointer to NULL.
 */

#include "ttm/ttm_module.h"
#include "ttm/ttm_bo_driver.h"
#include "ttm/ttm_placement.h"
#include <linux/module.h>



int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
            unsigned long p_size)
{
    int ret = -EINVAL;
    struct ttm_mem_type_manager *man;

    if (type >= TTM_NUM_MEM_TYPES) {
        printk(KERN_ERR TTM_PFX "Illegal memory type %d\n", type);
        return ret;
    }

    man = &bdev->man[type];
    if (man->has_type) {
        printk(KERN_ERR TTM_PFX
               "Memory manager already initialized for type %d\n",
               type);
        return ret;
    }

    ret = bdev->driver->init_mem_type(bdev, type, man);
    if (ret)
        return ret;

    ret = 0;
    if (type != TTM_PL_SYSTEM) {
        if (!p_size) {
            printk(KERN_ERR TTM_PFX
                   "Zero size memory manager type %d\n",
                   type);
            return ret;
        }
        ret = drm_mm_init(&man->manager, 0, p_size);
        if (ret)
            return ret;
    }
    man->has_type = true;
    man->use_type = true;
    man->size = p_size;

    INIT_LIST_HEAD(&man->lru);

    return 0;
}
EXPORT_SYMBOL(ttm_bo_init_mm);

int ttm_bo_global_init(struct ttm_global_reference *ref)
{
    struct ttm_bo_global_ref *bo_ref =
        container_of(ref, struct ttm_bo_global_ref, ref);
    struct ttm_bo_global *glob = ref->object;
    int ret;

//    mutex_init(&glob->device_list_mutex);
//    spin_lock_init(&glob->lru_lock);
    glob->mem_glob = bo_ref->mem_glob;
//    glob->dummy_read_page = alloc_page(__GFP_ZERO | GFP_DMA32);

    if (unlikely(glob->dummy_read_page == NULL)) {
        ret = -ENOMEM;
        goto out_no_drp;
    }

    INIT_LIST_HEAD(&glob->swap_lru);
    INIT_LIST_HEAD(&glob->device_list);

//    ttm_mem_init_shrink(&glob->shrink, ttm_bo_swapout);
    ret = ttm_mem_register_shrink(glob->mem_glob, &glob->shrink);
    if (unlikely(ret != 0)) {
        printk(KERN_ERR TTM_PFX
               "Could not register buffer object swapout.\n");
        goto out_no_shrink;
    }

    glob->ttm_bo_extra_size =
        ttm_round_pot(sizeof(struct ttm_tt)) +
        ttm_round_pot(sizeof(struct ttm_backend));

    glob->ttm_bo_size = glob->ttm_bo_extra_size +
        ttm_round_pot(sizeof(struct ttm_buffer_object));

    atomic_set(&glob->bo_count, 0);

//    kobject_init(&glob->kobj, &ttm_bo_glob_kobj_type);
//    ret = kobject_add(&glob->kobj, ttm_get_kobj(), "buffer_objects");
//    if (unlikely(ret != 0))
//        kobject_put(&glob->kobj);
    return ret;
out_no_shrink:
    __free_page(glob->dummy_read_page);
out_no_drp:
    kfree(glob);
    return ret;
}
EXPORT_SYMBOL(ttm_bo_global_init);