projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[CELL] spufs: add spu stats in sysfs and ctx stat file in spufs
[deliverable/linux.git] / arch / powerpc / platforms / cell / spufs / spufs.h
CommitLineData
67207b96
AB		 1/*
2 * SPU file system
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#ifndef SPUFS_H
23#define SPUFS_H
24
25#include <linux/kref.h>
650f8b02 26#include <linux/mutex.h>
67207b96
AB		 27#include <linux/spinlock.h>
28#include <linux/fs.h>
ea1ae594 29#include <linux/cpumask.h>
67207b96
AB		 30
31#include <asm/spu.h>
5473af04 32#include <asm/spu_csa.h>
b9e3bd77 33#include <asm/spu_info.h>
67207b96
AB		 34
35/* The magic number for our file system */
36enum {
37 SPUFS_MAGIC = 0x23c9b64e,
38};
39
8b3d6663 40struct spu_context_ops;
6263203e
AB		 41struct spu_gang;
42
67207b96
AB		 43struct spu_context {
44 struct spu *spu; /* pointer to a physical SPU */
5473af04 45 struct spu_state csa; /* SPU context save area. */
67207b96 46 spinlock_t mmio_lock; /* protects mmio access */
6df10a82
MN		 47 struct address_space *local_store; /* local store mapping. */
48 struct address_space *mfc; /* 'mfc' area mappings. */
43c2bbd9
CH		 49 struct address_space *cntl; /* 'control' area mappings. */
50 struct address_space *signal1; /* 'signal1' area mappings. */
51 struct address_space *signal2; /* 'signal2' area mappings. */
52 struct address_space *mss; /* 'mss' area mappings. */
53 struct address_space *psmap; /* 'psmap' area mappings. */
47d3a5fa 54 struct mutex mapping_lock;
86767277 55 u64 object_id; /* user space pointer for oprofile */
8b3d6663
AB		 56
57 enum { SPU_STATE_RUNNABLE, SPU_STATE_SAVED } state;
650f8b02 58 struct mutex state_mutex;
e45d48a3 59 struct mutex run_mutex;
8b3d6663
AB		 60
61 struct mm_struct *owner;
67207b96
AB		 62
63 struct kref kref;
8b3d6663
AB		 64 wait_queue_head_t ibox_wq;
65 wait_queue_head_t wbox_wq;
5110459f 66 wait_queue_head_t stop_wq;
a33a7d73 67 wait_queue_head_t mfc_wq;
8b3d6663
AB		 68 struct fasync_struct *ibox_fasync;
69 struct fasync_struct *wbox_fasync;
a33a7d73
AB		 70 struct fasync_struct *mfc_fasync;
71 u32 tagwait;
8b3d6663 72 struct spu_context_ops *ops;
2a911f0b 73 struct work_struct reap_work;
9add11da
AB		 74 unsigned long flags;
75 unsigned long event_return;
6263203e
AB		 76
77 struct list_head gang_list;
78 struct spu_gang *gang;
8389998a 79
476273ad
CH		 80 /* owner thread */
81 pid_t tid;
82
8389998a 83 /* scheduler fields */
7022543e 84 struct list_head rq;
37901802 85 unsigned int time_slice;
26bec673 86 unsigned long sched_flags;
ea1ae594 87 cpumask_t cpus_allowed;
2eb1b120 88 int policy;
8389998a 89 int prio;
e9f8a0b6
CH		 90
91 /* statistics */
92 struct {
93 /* updates protected by ctx->state_mutex */
27ec41d3
AD		 94 enum spu_utilization_state util_state;
95 unsigned long long tstamp; /* time of last state switch */
96 unsigned long long times[SPU_UTIL_MAX];
e9f8a0b6
CH		 97 unsigned long long vol_ctx_switch;
98 unsigned long long invol_ctx_switch;
99 unsigned long long min_flt;
100 unsigned long long maj_flt;
101 unsigned long long hash_flt;
102 unsigned long long slb_flt;
103 unsigned long long slb_flt_base; /* # at last ctx switch */
104 unsigned long long class2_intr;
105 unsigned long long class2_intr_base; /* # at last ctx switch */
106 unsigned long long libassist;
107 } stats;
6263203e
AB		 108};
109
110struct spu_gang {
111 struct list_head list;
112 struct mutex mutex;
113 struct kref kref;
114 int contexts;
8b3d6663
AB		 115};
116
a33a7d73
AB		 117struct mfc_dma_command {
118 int32_t pad; /* reserved */
119 uint32_t lsa; /* local storage address */
120 uint64_t ea; /* effective address */
121 uint16_t size; /* transfer size */
122 uint16_t tag; /* command tag */
123 uint16_t class; /* class ID */
124 uint16_t cmd; /* command opcode */
125};
126
127
8b3d6663
AB		 128/* SPU context query/set operations. */
129struct spu_context_ops {
130 int (*mbox_read) (struct spu_context * ctx, u32 * data);
131 u32(*mbox_stat_read) (struct spu_context * ctx);
3a843d7c
AB		 132 unsigned int (*mbox_stat_poll)(struct spu_context *ctx,
133 unsigned int events);
8b3d6663
AB		 134 int (*ibox_read) (struct spu_context * ctx, u32 * data);
135 int (*wbox_write) (struct spu_context * ctx, u32 data);
136 u32(*signal1_read) (struct spu_context * ctx);
137 void (*signal1_write) (struct spu_context * ctx, u32 data);
138 u32(*signal2_read) (struct spu_context * ctx);
139 void (*signal2_write) (struct spu_context * ctx, u32 data);
140 void (*signal1_type_set) (struct spu_context * ctx, u64 val);
141 u64(*signal1_type_get) (struct spu_context * ctx);
142 void (*signal2_type_set) (struct spu_context * ctx, u64 val);
143 u64(*signal2_type_get) (struct spu_context * ctx);
144 u32(*npc_read) (struct spu_context * ctx);
145 void (*npc_write) (struct spu_context * ctx, u32 data);
146 u32(*status_read) (struct spu_context * ctx);
147 char*(*get_ls) (struct spu_context * ctx);
3960c260 148 u32 (*runcntl_read) (struct spu_context * ctx);
5110459f 149 void (*runcntl_write) (struct spu_context * ctx, u32 data);
ee2d7340
AB		 150 void (*master_start) (struct spu_context * ctx);
151 void (*master_stop) (struct spu_context * ctx);
a33a7d73
AB		 152 int (*set_mfc_query)(struct spu_context * ctx, u32 mask, u32 mode);
153 u32 (*read_mfc_tagstatus)(struct spu_context * ctx);
154 u32 (*get_mfc_free_elements)(struct spu_context *ctx);
b9e3bd77
DGM		 155 int (*send_mfc_command)(struct spu_context * ctx,
156 struct mfc_dma_command * cmd);
157 void (*dma_info_read) (struct spu_context * ctx,
158 struct spu_dma_info * info);
159 void (*proxydma_info_read) (struct spu_context * ctx,
160 struct spu_proxydma_info * info);
57dace23 161 void (*restart_dma)(struct spu_context *ctx);
67207b96
AB		 162};
163
8b3d6663
AB		 164extern struct spu_context_ops spu_hw_ops;
165extern struct spu_context_ops spu_backing_ops;
166
67207b96
AB		 167struct spufs_inode_info {
168 struct spu_context *i_ctx;
6263203e 169 struct spu_gang *i_gang;
67207b96 170 struct inode vfs_inode;
43c2bbd9 171 int i_openers;
67207b96
AB		 172};
173#define SPUFS_I(inode) \
174 container_of(inode, struct spufs_inode_info, vfs_inode)
175
176extern struct tree_descr spufs_dir_contents[];
5737edd1 177extern struct tree_descr spufs_dir_nosched_contents[];
67207b96
AB		 178
179/* system call implementation */
180long spufs_run_spu(struct file *file,
181 struct spu_context *ctx, u32 *npc, u32 *status);
6263203e 182long spufs_create(struct nameidata *nd,
67207b96 183 unsigned int flags, mode_t mode);
9c2e08c5 184extern const struct file_operations spufs_context_fops;
67207b96 185
6263203e
AB		 186/* gang management */
187struct spu_gang *alloc_spu_gang(void);
188struct spu_gang *get_spu_gang(struct spu_gang *gang);
189int put_spu_gang(struct spu_gang *gang);
190void spu_gang_remove_ctx(struct spu_gang *gang, struct spu_context *ctx);
191void spu_gang_add_ctx(struct spu_gang *gang, struct spu_context *ctx);
192
57dace23
AB		 193/* fault handling */
194int spufs_handle_class1(struct spu_context *ctx);
195
67207b96 196/* context management */
65de66f0 197extern atomic_t nr_spu_contexts;
6a0641e5
CH		 198static inline void spu_acquire(struct spu_context *ctx)
199{
200 mutex_lock(&ctx->state_mutex);
201}
202
203static inline void spu_release(struct spu_context *ctx)
204{
205 mutex_unlock(&ctx->state_mutex);
206}
207
6263203e 208struct spu_context * alloc_spu_context(struct spu_gang *gang);
67207b96
AB		 209void destroy_spu_context(struct kref *kref);
210struct spu_context * get_spu_context(struct spu_context *ctx);
211int put_spu_context(struct spu_context *ctx);
5110459f 212void spu_unmap_mappings(struct spu_context *ctx);
67207b96 213
8b3d6663 214void spu_forget(struct spu_context *ctx);
26bec673 215int spu_acquire_runnable(struct spu_context *ctx, unsigned long flags);
67207b96 216void spu_acquire_saved(struct spu_context *ctx);
50b520d4 217
26bec673 218int spu_activate(struct spu_context *ctx, unsigned long flags);
8b3d6663
AB		 219void spu_deactivate(struct spu_context *ctx);
220void spu_yield(struct spu_context *ctx);
fe443ef2 221void spu_set_timeslice(struct spu_context *ctx);
2cf2b3b4
CH		 222void spu_update_sched_info(struct spu_context *ctx);
223void __spu_update_sched_info(struct spu_context *ctx);
8b3d6663 224int __init spu_sched_init(void);
d1450317 225void spu_sched_exit(void);
8b3d6663 226
c6730ed4
JK		 227extern char *isolated_loader;
228
ce8ab854
AB		 229/*
230 * spufs_wait
7022543e 231 * Same as wait_event_interruptible(), except that here
ce8ab854
AB		 232 * we need to call spu_release(ctx) before sleeping, and
233 * then spu_acquire(ctx) when awoken.
234 */
235
236#define spufs_wait(wq, condition) \
237({ \
238 int __ret = 0; \
239 DEFINE_WAIT(__wait); \
240 for (;;) { \
241 prepare_to_wait(&(wq), &__wait, TASK_INTERRUPTIBLE); \
242 if (condition) \
243 break; \
d3764397
JK		 244 if (signal_pending(current)) { \
245 __ret = -ERESTARTSYS; \
246 break; \
ce8ab854 247 } \
d3764397
JK		 248 spu_release(ctx); \
249 schedule(); \
250 spu_acquire(ctx); \
ce8ab854
AB		 251 } \
252 finish_wait(&(wq), &__wait); \
253 __ret; \
254})
255
8b3d6663
AB		 256size_t spu_wbox_write(struct spu_context *ctx, u32 data);
257size_t spu_ibox_read(struct spu_context *ctx, u32 *data);
258
259/* irq callback funcs. */
260void spufs_ibox_callback(struct spu *spu);
261void spufs_wbox_callback(struct spu *spu);
5110459f 262void spufs_stop_callback(struct spu *spu);
a33a7d73 263void spufs_mfc_callback(struct spu *spu);
9add11da 264void spufs_dma_callback(struct spu *spu, int type);
8b3d6663 265
bf1ab978
DGM		 266extern struct spu_coredump_calls spufs_coredump_calls;
267struct spufs_coredump_reader {
268 char *name;
269 ssize_t (*read)(struct spu_context *ctx,
270 char __user *buffer, size_t size, loff_t *pos);
271 u64 (*get)(void *data);
272 size_t size;
273};
274extern struct spufs_coredump_reader spufs_coredump_read[];
275extern int spufs_coredump_num_notes;
276
e9f8a0b6
CH		 277/*
278 * This function is a little bit too large for an inline, but
279 * as fault.c is built into the kernel we can't move it out of
280 * line.
281 */
282static inline void spuctx_switch_state(struct spu_context *ctx,
27ec41d3 283 enum spu_utilization_state new_state)
e9f8a0b6 284{
27ec41d3
AD		 285 unsigned long long curtime;
286 signed long long delta;
287 struct timespec ts;
288 struct spu *spu;
289 enum spu_utilization_state old_state;
e9f8a0b6 290
27ec41d3
AD		 291 ktime_get_ts(&ts);
292 curtime = timespec_to_ns(&ts);
293 delta = curtime - ctx->stats.tstamp;
e9f8a0b6 294
27ec41d3
AD		 295 WARN_ON(!mutex_is_locked(&ctx->state_mutex));
296 WARN_ON(delta < 0);
297
298 spu = ctx->spu;
299 old_state = ctx->stats.util_state;
300 ctx->stats.util_state = new_state;
301 ctx->stats.tstamp = curtime;
302
303 /*
304 * Update the physical SPU utilization statistics.
305 */
306 if (spu) {
307 ctx->stats.times[old_state] += delta;
308 spu->stats.times[old_state] += delta;
309 spu->stats.util_state = new_state;
fe2f896d 310 spu->stats.tstamp = curtime;
fe2f896d
CH		 311 }
312}
313
67207b96 314#endif
Linux kernel - Deliverables
This page took 0.19321 seconds and 5 git commands to generate.