]>
Commit | Line | Data |
---|---|---|
67207b96 AB |
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 | ||
8b3d6663 AB |
23 | #include <linux/fs.h> |
24 | #include <linux/mm.h> | |
67207b96 | 25 | #include <linux/slab.h> |
65de66f0 | 26 | #include <asm/atomic.h> |
67207b96 | 27 | #include <asm/spu.h> |
5473af04 | 28 | #include <asm/spu_csa.h> |
67207b96 AB |
29 | #include "spufs.h" |
30 | ||
65de66f0 CH |
31 | |
32 | atomic_t nr_spu_contexts = ATOMIC_INIT(0); | |
33 | ||
6263203e | 34 | struct spu_context *alloc_spu_context(struct spu_gang *gang) |
67207b96 AB |
35 | { |
36 | struct spu_context *ctx; | |
c5c45913 | 37 | ctx = kzalloc(sizeof *ctx, GFP_KERNEL); |
67207b96 AB |
38 | if (!ctx) |
39 | goto out; | |
8b3d6663 AB |
40 | /* Binding to physical processor deferred |
41 | * until spu_activate(). | |
5473af04 | 42 | */ |
f1fa74f4 | 43 | if (spu_init_csa(&ctx->csa)) |
5473af04 | 44 | goto out_free; |
67207b96 | 45 | spin_lock_init(&ctx->mmio_lock); |
47d3a5fa | 46 | mutex_init(&ctx->mapping_lock); |
67207b96 | 47 | kref_init(&ctx->kref); |
650f8b02 | 48 | mutex_init(&ctx->state_mutex); |
e45d48a3 | 49 | mutex_init(&ctx->run_mutex); |
8b3d6663 AB |
50 | init_waitqueue_head(&ctx->ibox_wq); |
51 | init_waitqueue_head(&ctx->wbox_wq); | |
5110459f | 52 | init_waitqueue_head(&ctx->stop_wq); |
a33a7d73 | 53 | init_waitqueue_head(&ctx->mfc_wq); |
8b3d6663 | 54 | ctx->state = SPU_STATE_SAVED; |
8b3d6663 AB |
55 | ctx->ops = &spu_backing_ops; |
56 | ctx->owner = get_task_mm(current); | |
a475c2f4 | 57 | INIT_LIST_HEAD(&ctx->rq); |
6263203e AB |
58 | if (gang) |
59 | spu_gang_add_ctx(gang, ctx); | |
ea1ae594 | 60 | ctx->cpus_allowed = current->cpus_allowed; |
fe443ef2 | 61 | spu_set_timeslice(ctx); |
65de66f0 CH |
62 | |
63 | atomic_inc(&nr_spu_contexts); | |
67207b96 AB |
64 | goto out; |
65 | out_free: | |
66 | kfree(ctx); | |
67 | ctx = NULL; | |
68 | out: | |
69 | return ctx; | |
70 | } | |
71 | ||
72 | void destroy_spu_context(struct kref *kref) | |
73 | { | |
74 | struct spu_context *ctx; | |
75 | ctx = container_of(kref, struct spu_context, kref); | |
650f8b02 | 76 | mutex_lock(&ctx->state_mutex); |
8b3d6663 | 77 | spu_deactivate(ctx); |
650f8b02 | 78 | mutex_unlock(&ctx->state_mutex); |
5473af04 | 79 | spu_fini_csa(&ctx->csa); |
6263203e AB |
80 | if (ctx->gang) |
81 | spu_gang_remove_ctx(ctx->gang, ctx); | |
a475c2f4 | 82 | BUG_ON(!list_empty(&ctx->rq)); |
65de66f0 | 83 | atomic_dec(&nr_spu_contexts); |
67207b96 AB |
84 | kfree(ctx); |
85 | } | |
86 | ||
87 | struct spu_context * get_spu_context(struct spu_context *ctx) | |
88 | { | |
89 | kref_get(&ctx->kref); | |
90 | return ctx; | |
91 | } | |
92 | ||
93 | int put_spu_context(struct spu_context *ctx) | |
94 | { | |
95 | return kref_put(&ctx->kref, &destroy_spu_context); | |
96 | } | |
97 | ||
8b3d6663 AB |
98 | /* give up the mm reference when the context is about to be destroyed */ |
99 | void spu_forget(struct spu_context *ctx) | |
100 | { | |
101 | struct mm_struct *mm; | |
102 | spu_acquire_saved(ctx); | |
103 | mm = ctx->owner; | |
104 | ctx->owner = NULL; | |
105 | mmput(mm); | |
106 | spu_release(ctx); | |
107 | } | |
108 | ||
5110459f | 109 | void spu_unmap_mappings(struct spu_context *ctx) |
8b3d6663 | 110 | { |
47d3a5fa | 111 | mutex_lock(&ctx->mapping_lock); |
6df10a82 MN |
112 | if (ctx->local_store) |
113 | unmap_mapping_range(ctx->local_store, 0, LS_SIZE, 1); | |
114 | if (ctx->mfc) | |
17e0e270 | 115 | unmap_mapping_range(ctx->mfc, 0, 0x1000, 1); |
6df10a82 | 116 | if (ctx->cntl) |
17e0e270 | 117 | unmap_mapping_range(ctx->cntl, 0, 0x1000, 1); |
6df10a82 | 118 | if (ctx->signal1) |
17e0e270 | 119 | unmap_mapping_range(ctx->signal1, 0, PAGE_SIZE, 1); |
6df10a82 | 120 | if (ctx->signal2) |
17e0e270 BH |
121 | unmap_mapping_range(ctx->signal2, 0, PAGE_SIZE, 1); |
122 | if (ctx->mss) | |
123 | unmap_mapping_range(ctx->mss, 0, 0x1000, 1); | |
124 | if (ctx->psmap) | |
125 | unmap_mapping_range(ctx->psmap, 0, 0x20000, 1); | |
47d3a5fa | 126 | mutex_unlock(&ctx->mapping_lock); |
8b3d6663 AB |
127 | } |
128 | ||
6a0641e5 CH |
129 | /** |
130 | * spu_acquire_runnable - lock spu contex and make sure it is in runnable state | |
131 | * @ctx: spu contex to lock | |
132 | * | |
133 | * Note: | |
134 | * Returns 0 and with the context locked on success | |
135 | * Returns negative error and with the context _unlocked_ on failure. | |
136 | */ | |
26bec673 | 137 | int spu_acquire_runnable(struct spu_context *ctx, unsigned long flags) |
8b3d6663 | 138 | { |
6a0641e5 | 139 | int ret = -EINVAL; |
8b3d6663 | 140 | |
6a0641e5 | 141 | spu_acquire(ctx); |
8b3d6663 | 142 | if (ctx->state == SPU_STATE_SAVED) { |
6a0641e5 CH |
143 | /* |
144 | * Context is about to be freed, so we can't acquire it anymore. | |
145 | */ | |
146 | if (!ctx->owner) | |
147 | goto out_unlock; | |
26bec673 | 148 | ret = spu_activate(ctx, flags); |
01062465 | 149 | if (ret) |
6a0641e5 | 150 | goto out_unlock; |
8389998a | 151 | } |
8b3d6663 | 152 | |
6a0641e5 | 153 | return 0; |
8b3d6663 | 154 | |
6a0641e5 CH |
155 | out_unlock: |
156 | spu_release(ctx); | |
8b3d6663 AB |
157 | return ret; |
158 | } | |
159 | ||
6a0641e5 CH |
160 | /** |
161 | * spu_acquire_saved - lock spu contex and make sure it is in saved state | |
162 | * @ctx: spu contex to lock | |
163 | */ | |
8b3d6663 AB |
164 | void spu_acquire_saved(struct spu_context *ctx) |
165 | { | |
6a0641e5 CH |
166 | spu_acquire(ctx); |
167 | if (ctx->state != SPU_STATE_SAVED) | |
8b3d6663 | 168 | spu_deactivate(ctx); |
8b3d6663 | 169 | } |