[POWERPC] spufs: simplify state_mutex
[linux-2.6.git] / arch / powerpc / platforms / cell / spufs / context.c
1 /*
2  * SPU file system -- SPU context management
3  *
4  * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
5  *
6  * Author: Arnd Bergmann <arndb@de.ibm.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2, or (at your option)
11  * any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22
23 #include <linux/fs.h>
24 #include <linux/mm.h>
25 #include <linux/slab.h>
26 #include <asm/spu.h>
27 #include <asm/spu_csa.h>
28 #include "spufs.h"
29
30 struct spu_context *alloc_spu_context(struct spu_gang *gang)
31 {
32         struct spu_context *ctx;
33         ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
34         if (!ctx)
35                 goto out;
36         /* Binding to physical processor deferred
37          * until spu_activate().
38          */
39         spu_init_csa(&ctx->csa);
40         if (!ctx->csa.lscsa) {
41                 goto out_free;
42         }
43         spin_lock_init(&ctx->mmio_lock);
44         kref_init(&ctx->kref);
45         mutex_init(&ctx->state_mutex);
46         init_MUTEX(&ctx->run_sema);
47         init_waitqueue_head(&ctx->ibox_wq);
48         init_waitqueue_head(&ctx->wbox_wq);
49         init_waitqueue_head(&ctx->stop_wq);
50         init_waitqueue_head(&ctx->mfc_wq);
51         ctx->state = SPU_STATE_SAVED;
52         ctx->ops = &spu_backing_ops;
53         ctx->owner = get_task_mm(current);
54         if (gang)
55                 spu_gang_add_ctx(gang, ctx);
56         goto out;
57 out_free:
58         kfree(ctx);
59         ctx = NULL;
60 out:
61         return ctx;
62 }
63
64 void destroy_spu_context(struct kref *kref)
65 {
66         struct spu_context *ctx;
67         ctx = container_of(kref, struct spu_context, kref);
68         mutex_lock(&ctx->state_mutex);
69         spu_deactivate(ctx);
70         mutex_unlock(&ctx->state_mutex);
71         spu_fini_csa(&ctx->csa);
72         if (ctx->gang)
73                 spu_gang_remove_ctx(ctx->gang, ctx);
74         kfree(ctx);
75 }
76
77 struct spu_context * get_spu_context(struct spu_context *ctx)
78 {
79         kref_get(&ctx->kref);
80         return ctx;
81 }
82
83 int put_spu_context(struct spu_context *ctx)
84 {
85         return kref_put(&ctx->kref, &destroy_spu_context);
86 }
87
88 /* give up the mm reference when the context is about to be destroyed */
89 void spu_forget(struct spu_context *ctx)
90 {
91         struct mm_struct *mm;
92         spu_acquire_saved(ctx);
93         mm = ctx->owner;
94         ctx->owner = NULL;
95         mmput(mm);
96         spu_release(ctx);
97 }
98
99 void spu_acquire(struct spu_context *ctx)
100 {
101         mutex_lock(&ctx->state_mutex);
102 }
103
104 void spu_release(struct spu_context *ctx)
105 {
106         mutex_unlock(&ctx->state_mutex);
107 }
108
109 void spu_unmap_mappings(struct spu_context *ctx)
110 {
111         if (ctx->local_store)
112                 unmap_mapping_range(ctx->local_store, 0, LS_SIZE, 1);
113         if (ctx->mfc)
114                 unmap_mapping_range(ctx->mfc, 0, 0x1000, 1);
115         if (ctx->cntl)
116                 unmap_mapping_range(ctx->cntl, 0, 0x1000, 1);
117         if (ctx->signal1)
118                 unmap_mapping_range(ctx->signal1, 0, PAGE_SIZE, 1);
119         if (ctx->signal2)
120                 unmap_mapping_range(ctx->signal2, 0, PAGE_SIZE, 1);
121         if (ctx->mss)
122                 unmap_mapping_range(ctx->mss, 0, 0x1000, 1);
123         if (ctx->psmap)
124                 unmap_mapping_range(ctx->psmap, 0, 0x20000, 1);
125 }
126
127 int spu_acquire_exclusive(struct spu_context *ctx)
128 {
129         int ret = 0;
130
131         mutex_lock(&ctx->state_mutex);
132         /* ctx is about to be freed, can't acquire any more */
133         if (!ctx->owner) {
134                 ret = -EINVAL;
135                 goto out;
136         }
137
138         if (ctx->state == SPU_STATE_SAVED) {
139                 ret = spu_activate(ctx, 0);
140                 if (ret)
141                         goto out;
142         } else {
143                 /* We need to exclude userspace access to the context. */
144                 spu_unmap_mappings(ctx);
145         }
146
147 out:
148         if (ret)
149                 mutex_unlock(&ctx->state_mutex);
150         return ret;
151 }
152
153 int spu_acquire_runnable(struct spu_context *ctx)
154 {
155         int ret = 0;
156
157         mutex_lock(&ctx->state_mutex);
158         if (ctx->state == SPU_STATE_RUNNABLE) {
159                 ctx->spu->prio = current->prio;
160                 return 0;
161         }
162
163         /* ctx is about to be freed, can't acquire any more */
164         if (!ctx->owner) {
165                 ret = -EINVAL;
166                 goto out;
167         }
168
169         if (ctx->state == SPU_STATE_SAVED) {
170                 ret = spu_activate(ctx, 0);
171                 if (ret)
172                         goto out;
173         }
174
175         /* On success, we return holding the lock */
176         return ret;
177 out:
178         /* Release here, to simplify calling code. */
179         mutex_unlock(&ctx->state_mutex);
180
181         return ret;
182 }
183
184 void spu_acquire_saved(struct spu_context *ctx)
185 {
186         mutex_lock(&ctx->state_mutex);
187         if (ctx->state == SPU_STATE_RUNNABLE)
188                 spu_deactivate(ctx);
189 }