cell/spufs: new experimental features
cover cell/spufs: new experimental features
These three patches implement features that are
desired by many of the cell/spufs users in order
to improve performance and functionality of cell
specific applications.
Since they all touch very sensitive parts of the kernel (memory management and system calls), I would at least like a thorough review before declaring the interfaces stable and submitting the patches for inclusion.
Arnd <><
-
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 1/3 spufs: allow SPU code to do syscalls
An SPU does not have a way to implement system calls itself, but it can create intercepts to the kernel.
This patch uses the method defined by the JSRE interface for C99 host library calls from an SPU to implement Linux system calls. It uses the reserved SPU stop code 0x2104 for this, using the structure layout and syscall numbers for ppc64-linux.
I'm still undecided wether it is better to have a list of allowed syscalls or a list of forbidden syscalls, since we can't allow an SPU to call all syscalls that are defined for ppc64-linux.
This patch implements the easier choice of them, with a blacklist that only prevents an SPU from calling anything that interacts with its own execution, namely fork, execve, clone, vfork, exit, spu_run and spu_create.
The current implementation works by including systbl.S from another file and redefining a few symbols there. This is anything but nice, and I'm still looking for better alternatives here.
arch/powerpc/platforms/cell/Makefile +8 -2
@@ -6,5 +6,11 @@ obj-$(CONFIG_SPU_FS) += spufs/ spu-base. spu-base-y += spu_base.o spu_priv1.o -builtin-spufs-$(CONFIG_SPU_FS) += spu_syscalls.o -obj-y += $(builtin-spufs-m) +# needed only when building loadable spufs.ko +spufs-modular-$(CONFIG_SPU_FS) += spu_syscalls.o +obj-y += $(spufs-modular-m) + +# always needed in kernel +spufs-builtin-$(CONFIG_SPU_FS) += spu_callbacks.o +obj-y += $(spufs-builtin-y) $(spufs-builtin-m) +
arch/powerpc/platforms/cell/spufs/run.c +91 -0
103 lines not on this page · raw message
include/asm-powerpc/spu.h +8 -1
@@ -149,6 +149,14 @@ int spu_irq_class_0_bottom(struct spu *sint spu_irq_class_1_bottom (struct spu *spu);void spu_irq_setaffinity (struct spu *spu,int cpu); +/* system callbacks from the SPU */ +struct spu_syscall_block { +u64 nr_ret; +u64 parm[6 ]; +}; +extern long spu_sys_callback (struct spu_syscall_block *s); + +/* syscalls implemented in spufs */ extern struct spufs_calls { asmlinkage long (*create_thread)(const char __user *name, unsigned int flags, mode_t mode);
@@ -399,7 +407,6 @@ struct spu_priv1 {#define SPU_GET_REVISION_BITS (vr) (vr & SPU_REVISION_BITS)u8 pad_0x28_0x100[0x100 -0x28 ];/* 0x28 */ -/* Interrupt Area */ u64 int_mask_RW[3 ];/* 0x100 */ #define CLASS0_ENABLE_DMA_ALIGNMENT_INTR 0x1L
arch/powerpc/platforms/cell/spu_callbacks.c new file +342 -0
342 lines not on this page · raw message
--
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 2/3 spufs: implement mfc access for PPE-side DMA
In reply to Arnd BergmannThis patch adds a new file called 'mfc' to each spufs directory. The file accepts DMA commands that are a subset of what would be legal DMA commands for problem state register access. Upon reading the file, a bitmask is returned with the completed tag groups set.
The file is meant to be used from an abstraction in libspe that is added by a different patch.
Quoted 1 line
From the kernel perspective, this means a process can now
offload a memory copy from or into an SPE local store without having to run code on the SPE itself.
The transfer will only be performed while the SPE is owned by one thread that is waiting in the spu_run system call and the data will be transferred into that thread's address space, independent of which thread started the transfer.
arch/powerpc/platforms/cell/spufs/file.c +294 -0
@@ -20,6 +20,8 @@* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +#undef DEBUG +#include <linux/fs.h> #include <linux/ioctl.h> #include <linux/module.h>
@@ -641,6 +643,297 @@ static u64 spufs_signal2_type_get(void *DEFINE_SIMPLE_ATTRIBUTE (spufs_signal2_type, spufs_signal2_type_get, spufs_signal2_type_set,"%llu" ); + +static int spufs_mfc_open (struct inode *inode,struct file *file) +{ +struct spufs_inode_info *i =SPUFS_I (inode); +struct spu_context *ctx = i->i_ctx; + +/* we don't want to deal with DMA into other processes */ +if (ctx->owner != current->mm) +return -EINVAL ; + +if (atomic_read (&inode->i_count) !=1 ) +return -EBUSY ; + + file->private_data = ctx; +return nonseekable_open (inode, file); +} + +/* interrupt-level mfc callback function. */ +void spufs_mfc_callback (struct spu *spu) +{ +struct spu_context *ctx = spu->ctx; + +wake_up_all (&ctx->mfc_wq); + +pr_debug ("%s %s\n" , __FUNCTION__, spu->name); +if (ctx->mfc_fasync) { +u32 free_elements, tagstatus; +unsigned int mask; + +/* no need for spu_acquire in interrupt context */ + free_elements = ctx->ops->get_mfc_free_elements (ctx); + tagstatus = ctx->ops->read_mfc_tagstatus (ctx); + + mask =0 ; +if (free_elements &0xffff ) + mask |=POLLOUT ; +if (tagstatus & ctx->tagwait) + mask |=POLLIN ; + +kill_fasync (&ctx->mfc_fasync,SIGIO , mask); + } +} + +static int spufs_read_mfc_tagstatus (struct spu_context *ctx,u32 *status) +{ +/* See if there is one tag group is complete */ +/* FIXME we need locking around tagwait */ + *status = ctx->ops->read_mfc_tagstatus (ctx) & ctx->tagwait; + ctx->tagwait &= ~*status; +if (*status) +return 1 ; + +/* enable interrupt waiting for any tag group, +may silently fail if interrupts are already enabled */ + ctx->ops->set_mfc_query (ctx, ctx->tagwait,1 ); +return 0 ; +} + +static ssize_t spufs_mfc_read (struct file *file,char __user *buffer, +size_t size,loff_t *pos) +{ +struct spu_context *ctx = file->private_data; +int ret = -EINVAL ; +u32 status; + +if (size !=4 ) + goto out; + +spu_acquire (ctx); +if (file->f_flags &O_NONBLOCK ) { + status = ctx->ops->read_mfc_tagstatus (ctx); +if (!(status & ctx->tagwait)) + ret = -EAGAIN ; +else + ctx->tagwait &= ~status; + }else { + ret =spufs_wait (ctx->mfc_wq, +spufs_read_mfc_tagstatus (ctx, &status)); + } +spu_release (ctx); + +if (ret) + goto out; + + ret =4 ; +if (copy_to_user (buffer, &status,4 )) + ret = -EFAULT ; + +out: +return ret; +} + +static int spufs_check_valid_dma (struct mfc_dma_command *cmd) +{ +pr_debug ("queueing DMA %x %lx %x %x %x\n" , cmd->lsa, + cmd->ea, cmd->size, cmd->tag, cmd->cmd); + +switch (cmd->cmd) { +case MFC_PUT_CMD : +case MFC_PUTF_CMD : +case MFC_PUTB_CMD : +case MFC_GET_CMD : +case MFC_GETF_CMD : +case MFC_GETB_CMD : +break ; +default : +pr_debug ("invalid DMA opcode %x\n" , cmd->cmd); +return -EIO ; + } + +if ((cmd->lsa &0xf ) != (cmd->ea &0xf )) { +pr_debug ("invalid DMA alignment, ea %lx lsa %x\n" , + cmd->ea, cmd->lsa); +return -EIO ; + } + +switch (cmd->size &0xf ) { +case 1 : +break ; +case 2 : +if (cmd->lsa &1 ) + goto error; +break ; +case 4 : +if (cmd->lsa &3 ) + goto error; +break ; +case 8 : +if (cmd->lsa &7 ) + goto error; +break ; +case 0 : +if (cmd->lsa &15 ) + goto error; +break ; + error: +default : +pr_debug ("invalid DMA alignment %x for size %x\n" , + cmd->lsa &0xf , cmd->size); +return -EIO ; + } + +if (cmd->size >16 *1024 ) { +pr_debug ("invalid DMA size %x\n" , cmd->size); +return -EIO ; + } + +if (cmd->tag &0xfff0 ) { +/* we reserve the higher tag numbers for kernel use */ +pr_debug ("invalid DMA tag\n" ); +return -EIO ; + } + +if (cmd->class) { +/* not supported in this version */ +pr_debug ("invalid DMA class\n" ); +return -EIO ; + } + +return 0 ; +} + +static int spu_send_mfc_command (struct spu_context *ctx, +struct mfc_dma_command cmd, +int *error) +{ + *error = ctx->ops->send_mfc_command (ctx, &cmd); +if (*error == -EAGAIN ) { +/* wait for any tag group to complete +so we have space for the new command */ + ctx->ops->set_mfc_query (ctx, ctx->tagwait,1 ); +/* try again, because the queue might be +empty again */ + *error = ctx->ops->send_mfc_command (ctx, &cmd); +if (*error == -EAGAIN ) +return 0 ; + } +return 1 ; +} + +static ssize_t spufs_mfc_write (struct file *file,const char __user *buffer, +size_t size,loff_t *pos) +{ +struct spu_context *ctx = file->private_data; +struct mfc_dma_command cmd; +int ret = -EINVAL ; + +if (size !=sizeof cmd) + goto out; + + ret = -EFAULT ; +if (copy_from_user (&cmd, buffer,sizeof cmd)) + goto out; + + ret =spufs_check_valid_dma (&cmd); +if (ret) + goto out; + +spu_acquire_runnable (ctx); +if (file->f_flags &O_NONBLOCK ) { + ret = ctx->ops->send_mfc_command (ctx, &cmd); + }else { +int status; + ret =spufs_wait (ctx->mfc_wq, +spu_send_mfc_command (ctx, cmd, &status)); +if (status) + ret = status; + } +spu_release (ctx); + +if (ret) + goto out; + + ctx->tagwait |=1 << cmd.tag; + +out: +return ret; +} + +static unsigned int spufs_mfc_poll (struct file *file,poll_table *wait) +{ +struct spu_context *ctx = file->private_data; +u32 free_elements, tagstatus; +unsigned int mask; + +spu_acquire (ctx); + ctx->ops->set_mfc_query (ctx, ctx->tagwait,2 ); + free_elements = ctx->ops->get_mfc_free_elements (ctx); + tagstatus = ctx->ops->read_mfc_tagstatus (ctx); +spu_release (ctx); + +poll_wait (file, &ctx->mfc_wq, wait); + + mask =0 ; +if (free_elements &0xffff ) + mask |=POLLOUT |POLLWRNORM ; +if (tagstatus & ctx->tagwait) + mask |=POLLIN |POLLRDNORM ; + +pr_debug ("%s: free %d tagstatus %d tagwait %d\n" , __FUNCTION__, + free_elements, tagstatus, ctx->tagwait); + +return mask; +} + +static int spufs_mfc_flush (struct file *file) +{ +struct spu_context *ctx = file->private_data; +int ret; + +spu_acquire (ctx); +#if 0 +/* this currently hangs */ + ret =spufs_wait (ctx->mfc_wq, + ctx->ops->set_mfc_query (ctx, ctx->tagwait,2 )); +if (ret) + goto out; + ret =spufs_wait (ctx->mfc_wq, + ctx->ops->read_mfc_tagstatus (ctx) == ctx->tagwait); +out: +#else + ret =0 ; +#endif +spu_release (ctx); + +return ret; +} + +static int spufs_mfc_fsync (struct file *file,struct dentry *dentry, +int datasync) +{ +return spufs_mfc_flush (file); +} + +static int spufs_mfc_fasync (int fd,struct file *file,int on) +{ +struct spu_context *ctx = file->private_data; + +return fasync_helper (fd, file, on, &ctx->mfc_fasync); +} + +static struct file_operations spufs_mfc_fops = { + .open = spufs_mfc_open, + .read = spufs_mfc_read, + .write = spufs_mfc_write, + .poll = spufs_mfc_poll, + .flush = spufs_mfc_flush, + .fsync = spufs_mfc_fsync, + .fasync = spufs_mfc_fasync, +}; +static void spufs_npc_set (void *data,u64 val) {struct spu_context *ctx = data;
@@ -783,6 +1076,7 @@ struct tree_descr spufs_dir_contents[] = { "signal2", &spufs_signal2_fops, 0666, }, { "signal1_type", &spufs_signal1_type, 0666, }, { "signal2_type", &spufs_signal2_type, 0666, }, + { "mfc", &spufs_mfc_fops, 0666, }, { "npc", &spufs_npc_ops, 0666, }, { "fpcr", &spufs_fpcr_fops, 0666, }, { "decr", &spufs_decr_ops, 0666, },
arch/powerpc/platforms/cell/spu_base.c +5 -2
@@ -111,7 +111,7 @@ static int __spu_trap_data_seg(struct spextern int hash_page (unsigned long ea,unsigned long access,unsigned long trap);//XXX static int __spu_trap_data_map (struct spu *spu,unsigned long ea,u64 dsisr) { -pr_debug ("%s\n" , __FUNCTION__); +pr_debug ("%s, %lx, %lx\n" , __FUNCTION__, dsisr, ea);/* Handle kernel space hash faults immediately. User hash faults need to be deferred to process context. */
@@ -168,7 +168,7 @@ static int __spu_trap_halt(struct spu *sstatic int __spu_trap_tag_group (struct spu *spu) {pr_debug ("%s\n" , __FUNCTION__); -/* wake_up(&spu->dma_wq); */ + spu->mfc_callback (spu);return 0 ; }
@@ -242,6 +242,8 @@ spu_irq_class_1(int irq, void *data, strspu_mfc_dsisr_set (spu,0ul );spu_int_stat_clear (spu,1 , stat);spin_unlock (&spu->register_lock); +pr_debug ("%s: %lx %lx %lx %lx\n" , __FUNCTION__, mask, stat, + dar, dsisr);if (stat &1 )/* segment fault */ __spu_trap_data_seg (spu, dar);
@@ -632,6 +634,7 @@ static int __init create_spu(struct devi spu->ibox_callback =NULL ; spu->wbox_callback =NULL ; spu->stop_callback =NULL ; + spu->mfc_callback =NULL ;down (&spu_mutex); spu->number = number++;
arch/powerpc/platforms/cell/spufs/backing_ops.c +47 -0
57 lines not on this page · raw message
arch/powerpc/platforms/cell/spufs/hw_ops.c +57 -0
67 lines not on this page · raw message
include/asm-powerpc/spu.h +1 -0
@@ -137,6 +137,7 @@ struct spu {void (* wbox_callback)(struct spu *spu);void (* ibox_callback)(struct spu *spu);void (* stop_callback)(struct spu *spu); +void (* mfc_callback)(struct spu *spu);char irq_c0[8 ];char irq_c1[8 ];
arch/powerpc/platforms/cell/spufs/context.c +3 -2
@@ -47,8 +47,11 @@ struct spu_context *alloc_spu_context(stinit_waitqueue_head (&ctx->ibox_wq);init_waitqueue_head (&ctx->wbox_wq);init_waitqueue_head (&ctx->stop_wq); +init_waitqueue_head (&ctx->mfc_wq); ctx->ibox_fasync =NULL ; ctx->wbox_fasync =NULL ; + ctx->mfc_fasync =NULL ; + ctx->tagwait =0 ; ctx->state =SPU_STATE_SAVED ; ctx->local_store = local_store; ctx->spu =NULL ;
@@ -68,8 +71,6 @@ void destroy_spu_context(struct kref *kr ctx = container_of(kref, struct spu_context, kref);down_write (&ctx->state_sema);spu_deactivate (ctx); - ctx->ibox_fasync =NULL ; - ctx->wbox_fasync =NULL ;up_write (&ctx->state_sema);spu_fini_csa (&ctx->csa);kfree (ctx);
arch/powerpc/platforms/cell/spufs/sched.c +2 -0
@@ -180,6 +180,7 @@ static inline void bind_context(struct s spu->ibox_callback = spufs_ibox_callback; spu->wbox_callback = spufs_wbox_callback; spu->stop_callback = spufs_stop_callback; + spu->mfc_callback = spufs_mfc_callback;mb ();spu_unmap_mappings (ctx);spu_restore (&ctx->csa, spu);
@@ -197,6 +198,7 @@ static inline void unbind_context(struct spu->ibox_callback =NULL ; spu->wbox_callback =NULL ; spu->stop_callback =NULL ; + spu->mfc_callback =NULL ; spu->mm =NULL ; spu->pid =0 ; spu->prio =MAX_PRIO ;
arch/powerpc/platforms/cell/spufs/spufs.h +20 -0
@@ -55,13 +55,27 @@ struct spu_context {wait_queue_head_t ibox_wq;wait_queue_head_t wbox_wq;wait_queue_head_t stop_wq; +wait_queue_head_t mfc_wq;struct fasync_struct *ibox_fasync;struct fasync_struct *wbox_fasync; +struct fasync_struct *mfc_fasync; +u32 tagwait;struct spu_context_ops *ops;struct work_struct reap_work;u64 flags; }; +struct mfc_dma_command { +int32_t pad;/* reserved */ +uint32_t lsa;/* local storage address */ +uint64_t ea;/* effective address */ +uint16_t size;/* transfer size */ +uint16_t tag;/* command tag */ +uint16_t class;/* class ID */ +uint16_t cmd;/* command opcode */ +}; + +/* SPU context query/set operations. */ struct spu_context_ops {int (*mbox_read) (struct spu_context * ctx,u32 * data);
@@ -84,6 +98,11 @@ struct spu_context_ops {char *(*get_ls) (struct spu_context * ctx);void (*runcntl_write) (struct spu_context * ctx,u32 data);void (*runcntl_stop) (struct spu_context * ctx); +int (*set_mfc_query)(struct spu_context * ctx,u32 mask,u32 mode); +u32 (*read_mfc_tagstatus)(struct spu_context * ctx); +u32 (*get_mfc_free_elements)(struct spu_context *ctx); +int (*send_mfc_command)(struct spu_context *ctx, +struct mfc_dma_command *cmd); };extern struct spu_context_ops spu_hw_ops;
@@ -159,5 +178,6 @@ size_t spu_ibox_read(struct spu_contextvoid spufs_ibox_callback (struct spu *spu);void spufs_wbox_callback (struct spu *spu);void spufs_stop_callback (struct spu *spu); +void spufs_mfc_callback (struct spu *spu);#endif
arch/powerpc/platforms/cell/spufs/switch.c +2 -1
@@ -2145,7 +2145,8 @@ static void init_priv1(struct spu_state csa->priv1.int_mask_class1_RW =CLASS1_ENABLE_SEGMENT_FAULT_INTR |CLASS1_ENABLE_STORAGE_FAULT_INTR ; csa->priv1.int_mask_class2_RW =CLASS2_ENABLE_SPU_STOP_INTR | -CLASS2_ENABLE_SPU_HALT_INTR ; +CLASS2_ENABLE_SPU_HALT_INTR | +CLASS2_ENABLE_SPU_DMA_TAG_GROUP_COMPLETE_INTR ; }static void init_priv2 (struct spu_state *csa)
--
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 3/3 spufs: enable SPE problem state MMIO access.
In reply to Arnd BergmannThis patch is layered on top of CONFIG_SPARSEMEM and is patterned after direct mapping of LS.
This patch allows mmap() of the following regions:
"mfc", which represents the area from [0x0000 - 0x0fff]; "cntl", which represents the area from [0x4000 - 0x5fff]; "signal1" which begins at offset 0x14000; "signal2" which begins at offset 0x1c000.
The signal1 & signal2 files may be mmap()'d by regular user processes. The cntl and mfc file, on the other hand, may only be accessed if the owning process has CAP_SYS_RAWIO, because they have the potential to confuse the kernel with regard to parallel access to the same files with regular file operations: the kernel always holds a spinlock when accessing registers in these areas to serialize them, which can not be guaranteed with user mmaps,
From: Mark Nutter <[email protected]>
arch/powerpc/platforms/cell/spu_base.c +5 -0
@@ -570,6 +570,11 @@ static int __init spu_map_device(structif (!spu->local_store) goto out; + prop =get_property (spe,"problem" ,NULL ); +if (!prop) + goto out_unmap; + spu->problem_phys = *(unsigned long *)prop; + spu->problem=map_spe_prop (spe,"problem" );if (!spu->problem) goto out_unmap;
arch/powerpc/platforms/cell/spufs/context.c +15 -3
@@ -27,7 +27,7 @@#include <asm/spu_csa.h> #include "spufs.h" -struct spu_context *alloc_spu_context (struct address_space *local_store) +struct spu_context *alloc_spu_context (void ) {struct spu_context *ctx; ctx =kmalloc (sizeof *ctx,GFP_KERNEL );
@@ -53,7 +53,10 @@ struct spu_context *alloc_spu_context(st ctx->mfc_fasync =NULL ; ctx->tagwait =0 ; ctx->state =SPU_STATE_SAVED ; - ctx->local_store = local_store; + ctx->local_store =NULL ; + ctx->cntl =NULL ; + ctx->signal1 =NULL ; + ctx->signal2 =NULL ; ctx->spu =NULL ; ctx->ops = &spu_backing_ops; ctx->owner =get_task_mm (current);
@@ -110,7 +113,16 @@ void spu_release(struct spu_context *ctxvoid spu_unmap_mappings (struct spu_context *ctx) { -unmap_mapping_range (ctx->local_store,0 ,LS_SIZE ,1 ); +if (ctx->local_store) +unmap_mapping_range (ctx->local_store,0 ,LS_SIZE ,1 ); +if (ctx->mfc) +unmap_mapping_range (ctx->mfc,0 ,0x1000 ,1 ); +if (ctx->cntl) +unmap_mapping_range (ctx->cntl,0 ,0x1000 ,1 ); +if (ctx->signal1) +unmap_mapping_range (ctx->signal1,0 ,0x1000 ,1 ); +if (ctx->signal2) +unmap_mapping_range (ctx->signal2,0 ,0x1000 ,1 ); }int spu_acquire_runnable (struct spu_context *ctx)
arch/powerpc/platforms/cell/spufs/file.c +223 -6
295 lines not on this page · raw message
arch/powerpc/platforms/cell/spufs/inode.c +1 -1
@@ -241,7 +241,7 @@ spufs_mkdir(struct inode *dir, struct de inode->i_gid = dir->i_gid; inode->i_mode &=S_ISGID ; } - ctx =alloc_spu_context (inode->i_mapping); + ctx =alloc_spu_context ();SPUFS_I (inode)->i_ctx = ctx;if (!ctx) goto out_iput;
arch/powerpc/platforms/cell/spufs/spufs.h +6 -2
@@ -43,7 +43,11 @@ struct spu_context {struct spu *spu;/* pointer to a physical SPU */ struct spu_state csa;/* SPU context save area. */ spinlock_t mmio_lock;/* protects mmio access */ -struct address_space *local_store;/* local store backing store */ +struct address_space *local_store;/* local store mapping. */ +struct address_space *mfc;/* 'mfc' area mappings. */ +struct address_space *cntl;/* 'control' area mappings. */ +struct address_space *signal1;/* 'signal1' area mappings. */ +struct address_space *signal2;/* 'signal2' area mappings. */ enum {SPU_STATE_RUNNABLE ,SPU_STATE_SAVED } state;struct rw_semaphore state_sema;
@@ -125,7 +129,7 @@ long spufs_create_thread(struct nameidatextern struct file_operations spufs_context_fops;/* context management */ -struct spu_context *alloc_spu_context (struct address_space *local_store); +struct spu_context *alloc_spu_context (void );void destroy_spu_context (struct kref *kref);struct spu_context *get_spu_context (struct spu_context *ctx);int put_spu_context (struct spu_context *ctx);
include/asm-powerpc/spu.h +1 -0
@@ -110,6 +110,7 @@ struct spu {char *name;unsigned long local_store_phys;u8 *local_store; +unsigned long problem_phys;struct spu_problem __iomem *problem;struct spu_priv1 __iomem *priv1;struct spu_priv2 __iomem *priv2;
arch/powerpc/platforms/cell/Kconfig +5 -0
@@ -10,4 +10,9 @@ config SPU_FS Units on machines implementing the Broadband Processor Architecture. +config SPUFS_MMAP + bool + depends on SPU_FS && SPARSEMEM && !PPC_64K_PAGES + default y + endmenu
--
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>