2005-11-16 04:53:48 +08:00
|
|
|
/*
|
|
|
|
* SPU file system -- SPU context management
|
|
|
|
*
|
|
|
|
* (C) Copyright IBM Deutschland Entwicklung GmbH 2005
|
|
|
|
*
|
|
|
|
* Author: Arnd Bergmann <arndb@de.ibm.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
* any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
2005-11-16 04:53:52 +08:00
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/mm.h>
|
2005-11-16 04:53:48 +08:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <asm/spu.h>
|
2005-11-16 04:53:49 +08:00
|
|
|
#include <asm/spu_csa.h>
|
2005-11-16 04:53:48 +08:00
|
|
|
#include "spufs.h"
|
|
|
|
|
2006-03-23 07:00:12 +08:00
|
|
|
struct spu_context *alloc_spu_context(void)
|
2005-11-16 04:53:48 +08:00
|
|
|
{
|
|
|
|
struct spu_context *ctx;
|
2006-04-28 16:37:47 +08:00
|
|
|
ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
|
2005-11-16 04:53:48 +08:00
|
|
|
if (!ctx)
|
|
|
|
goto out;
|
2005-11-16 04:53:52 +08:00
|
|
|
/* Binding to physical processor deferred
|
|
|
|
* until spu_activate().
|
2005-11-16 04:53:49 +08:00
|
|
|
*/
|
|
|
|
spu_init_csa(&ctx->csa);
|
|
|
|
if (!ctx->csa.lscsa) {
|
|
|
|
goto out_free;
|
|
|
|
}
|
2005-11-16 04:53:48 +08:00
|
|
|
spin_lock_init(&ctx->mmio_lock);
|
|
|
|
kref_init(&ctx->kref);
|
2005-11-16 04:53:52 +08:00
|
|
|
init_rwsem(&ctx->state_sema);
|
2006-01-05 03:31:24 +08:00
|
|
|
init_MUTEX(&ctx->run_sema);
|
2005-11-16 04:53:52 +08:00
|
|
|
init_waitqueue_head(&ctx->ibox_wq);
|
|
|
|
init_waitqueue_head(&ctx->wbox_wq);
|
2005-12-06 11:52:25 +08:00
|
|
|
init_waitqueue_head(&ctx->stop_wq);
|
2006-03-23 07:00:11 +08:00
|
|
|
init_waitqueue_head(&ctx->mfc_wq);
|
2005-11-16 04:53:52 +08:00
|
|
|
ctx->state = SPU_STATE_SAVED;
|
|
|
|
ctx->ops = &spu_backing_ops;
|
|
|
|
ctx->owner = get_task_mm(current);
|
2005-11-16 04:53:48 +08:00
|
|
|
goto out;
|
|
|
|
out_free:
|
|
|
|
kfree(ctx);
|
|
|
|
ctx = NULL;
|
|
|
|
out:
|
|
|
|
return ctx;
|
|
|
|
}
|
|
|
|
|
|
|
|
void destroy_spu_context(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct spu_context *ctx;
|
|
|
|
ctx = container_of(kref, struct spu_context, kref);
|
2005-11-16 04:53:52 +08:00
|
|
|
down_write(&ctx->state_sema);
|
|
|
|
spu_deactivate(ctx);
|
|
|
|
up_write(&ctx->state_sema);
|
2005-11-16 04:53:49 +08:00
|
|
|
spu_fini_csa(&ctx->csa);
|
2005-11-16 04:53:48 +08:00
|
|
|
kfree(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct spu_context * get_spu_context(struct spu_context *ctx)
|
|
|
|
{
|
|
|
|
kref_get(&ctx->kref);
|
|
|
|
return ctx;
|
|
|
|
}
|
|
|
|
|
|
|
|
int put_spu_context(struct spu_context *ctx)
|
|
|
|
{
|
|
|
|
return kref_put(&ctx->kref, &destroy_spu_context);
|
|
|
|
}
|
|
|
|
|
2005-11-16 04:53:52 +08:00
|
|
|
/* give up the mm reference when the context is about to be destroyed */
|
|
|
|
void spu_forget(struct spu_context *ctx)
|
|
|
|
{
|
|
|
|
struct mm_struct *mm;
|
|
|
|
spu_acquire_saved(ctx);
|
|
|
|
mm = ctx->owner;
|
|
|
|
ctx->owner = NULL;
|
|
|
|
mmput(mm);
|
|
|
|
spu_release(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
void spu_acquire(struct spu_context *ctx)
|
|
|
|
{
|
|
|
|
down_read(&ctx->state_sema);
|
|
|
|
}
|
|
|
|
|
|
|
|
void spu_release(struct spu_context *ctx)
|
|
|
|
{
|
|
|
|
up_read(&ctx->state_sema);
|
|
|
|
}
|
|
|
|
|
2005-12-06 11:52:25 +08:00
|
|
|
void spu_unmap_mappings(struct spu_context *ctx)
|
2005-11-16 04:53:52 +08:00
|
|
|
{
|
2006-03-23 07:00:12 +08:00
|
|
|
if (ctx->local_store)
|
|
|
|
unmap_mapping_range(ctx->local_store, 0, LS_SIZE, 1);
|
|
|
|
if (ctx->mfc)
|
|
|
|
unmap_mapping_range(ctx->mfc, 0, 0x4000, 1);
|
|
|
|
if (ctx->cntl)
|
|
|
|
unmap_mapping_range(ctx->cntl, 0, 0x4000, 1);
|
|
|
|
if (ctx->signal1)
|
|
|
|
unmap_mapping_range(ctx->signal1, 0, 0x4000, 1);
|
|
|
|
if (ctx->signal2)
|
|
|
|
unmap_mapping_range(ctx->signal2, 0, 0x4000, 1);
|
2005-11-16 04:53:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int spu_acquire_runnable(struct spu_context *ctx)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2005-11-16 04:53:48 +08:00
|
|
|
|
2005-11-16 04:53:52 +08:00
|
|
|
down_read(&ctx->state_sema);
|
2005-12-06 11:52:26 +08:00
|
|
|
if (ctx->state == SPU_STATE_RUNNABLE) {
|
|
|
|
ctx->spu->prio = current->prio;
|
2005-11-16 04:53:52 +08:00
|
|
|
return 0;
|
2005-12-06 11:52:26 +08:00
|
|
|
}
|
2006-01-05 03:31:21 +08:00
|
|
|
up_read(&ctx->state_sema);
|
|
|
|
|
|
|
|
down_write(&ctx->state_sema);
|
2005-11-16 04:53:52 +08:00
|
|
|
/* ctx is about to be freed, can't acquire any more */
|
|
|
|
if (!ctx->owner) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->state == SPU_STATE_SAVED) {
|
|
|
|
ret = spu_activate(ctx, 0);
|
2006-01-05 03:31:25 +08:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2005-11-16 04:53:52 +08:00
|
|
|
ctx->state = SPU_STATE_RUNNABLE;
|
|
|
|
}
|
|
|
|
|
2006-01-05 03:31:21 +08:00
|
|
|
downgrade_write(&ctx->state_sema);
|
2005-11-16 04:53:52 +08:00
|
|
|
/* On success, we return holding the lock */
|
2006-01-05 03:31:21 +08:00
|
|
|
|
2005-11-16 04:53:52 +08:00
|
|
|
return ret;
|
|
|
|
out:
|
|
|
|
/* Release here, to simplify calling code. */
|
2006-01-05 03:31:21 +08:00
|
|
|
up_write(&ctx->state_sema);
|
2005-11-16 04:53:52 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void spu_acquire_saved(struct spu_context *ctx)
|
|
|
|
{
|
|
|
|
down_read(&ctx->state_sema);
|
|
|
|
|
|
|
|
if (ctx->state == SPU_STATE_SAVED)
|
|
|
|
return;
|
|
|
|
|
|
|
|
up_read(&ctx->state_sema);
|
|
|
|
down_write(&ctx->state_sema);
|
|
|
|
|
|
|
|
if (ctx->state == SPU_STATE_RUNNABLE) {
|
|
|
|
spu_deactivate(ctx);
|
|
|
|
ctx->state = SPU_STATE_SAVED;
|
|
|
|
}
|
|
|
|
|
|
|
|
downgrade_write(&ctx->state_sema);
|
|
|
|
}
|