Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: 98b5307e51
Fetching contributors…

Cannot retrieve contributors at this time

201 lines (169 sloc) 5.396 kb
/**************************************************************************
* Copyright (c) 2007 Tungsten Graphics, Inc., Cedar Park, TX., 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.
*
**************************************************************************/
/*
* An allocate-fence manager implementation intended for sets of base-registers
* or tiling-registers.
*/
#include "drmP.h"
/*
* Allocate a compatible register and put it on the unfenced list.
*/
int drm_regs_alloc(struct drm_reg_manager *manager,
const void *data,
uint32_t fence_class,
uint32_t fence_type,
int interruptible, int no_wait, struct drm_reg **reg)
{
struct drm_reg *entry, *next_entry;
int ret;
*reg = NULL;
/*
* Search the unfenced list.
*/
list_for_each_entry(entry, &manager->unfenced, head) {
if (manager->reg_reusable(entry, data)) {
entry->new_fence_type |= fence_type;
goto out;
}
}
/*
* Search the lru list.
*/
list_for_each_entry_safe(entry, next_entry, &manager->lru, head) {
struct drm_fence_object *fence = entry->fence;
if (fence->fence_class == fence_class &&
(entry->fence_type & fence_type) == entry->fence_type &&
manager->reg_reusable(entry, data)) {
list_del(&entry->head);
entry->new_fence_type = fence_type;
list_add_tail(&entry->head, &manager->unfenced);
goto out;
}
}
/*
* Search the free list.
*/
list_for_each_entry(entry, &manager->free, head) {
list_del(&entry->head);
entry->new_fence_type = fence_type;
list_add_tail(&entry->head, &manager->unfenced);
goto out;
}
if (no_wait)
return -EBUSY;
/*
* Go back to the lru list and try to expire fences.
*/
list_for_each_entry_safe(entry, next_entry, &manager->lru, head) {
BUG_ON(!entry->fence);
ret = drm_fence_object_wait(entry->fence, 0, !interruptible,
entry->fence_type);
if (ret)
return ret;
drm_fence_usage_deref_unlocked(&entry->fence);
list_del(&entry->head);
entry->new_fence_type = fence_type;
list_add_tail(&entry->head, &manager->unfenced);
goto out;
}
/*
* Oops. All registers are used up :(.
*/
return -EBUSY;
out:
*reg = entry;
return 0;
}
EXPORT_SYMBOL(drm_regs_alloc);
void drm_regs_fence(struct drm_reg_manager *manager,
struct drm_fence_object *fence)
{
struct drm_reg *entry;
struct drm_reg *next_entry;
if (!fence) {
/*
* Old fence (if any) is still valid.
* Put back on free and lru lists.
*/
list_for_each_entry_safe_reverse(entry, next_entry,
&manager->unfenced, head) {
list_del(&entry->head);
list_add(&entry->head, (entry->fence) ?
&manager->lru : &manager->free);
}
} else {
/*
* Fence with a new fence and put on lru list.
*/
list_for_each_entry_safe(entry, next_entry, &manager->unfenced,
head) {
list_del(&entry->head);
if (entry->fence)
drm_fence_usage_deref_unlocked(&entry->fence);
drm_fence_reference_unlocked(&entry->fence, fence);
entry->fence_type = entry->new_fence_type;
BUG_ON((entry->fence_type & fence->type) !=
entry->fence_type);
list_add_tail(&entry->head, &manager->lru);
}
}
}
EXPORT_SYMBOL(drm_regs_fence);
void drm_regs_free(struct drm_reg_manager *manager)
{
struct drm_reg *entry;
struct drm_reg *next_entry;
drm_regs_fence(manager, NULL);
list_for_each_entry_safe(entry, next_entry, &manager->free, head) {
list_del(&entry->head);
manager->reg_destroy(entry);
}
list_for_each_entry_safe(entry, next_entry, &manager->lru, head) {
(void)drm_fence_object_wait(entry->fence, 1, 1,
entry->fence_type);
list_del(&entry->head);
drm_fence_usage_deref_unlocked(&entry->fence);
manager->reg_destroy(entry);
}
}
EXPORT_SYMBOL(drm_regs_free);
void drm_regs_add(struct drm_reg_manager *manager, struct drm_reg *reg)
{
reg->fence = NULL;
list_add_tail(&reg->head, &manager->free);
}
EXPORT_SYMBOL(drm_regs_add);
void drm_regs_init(struct drm_reg_manager *manager,
int (*reg_reusable) (const struct drm_reg *, const void *),
void (*reg_destroy) (struct drm_reg *))
{
INIT_LIST_HEAD(&manager->free);
INIT_LIST_HEAD(&manager->lru);
INIT_LIST_HEAD(&manager->unfenced);
manager->reg_reusable = reg_reusable;
manager->reg_destroy = reg_destroy;
}
EXPORT_SYMBOL(drm_regs_init);
Jump to Line
Something went wrong with that request. Please try again.