Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc

* 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc:
  [POWERPC] Fix building of COFF zImages
  [POWERPC] spufs: Fix error handling in spufs_fill_dir()
  [POWERPC] Add table of contents to booting-without-of.txt
  [POWERPC] spufs: Don't yield nosched context
  [POWERPC] Fix typo in booting-without-of-txt section numbering
  [POWERPC] scc_sio: Fix link failure
  [POWERPC] cbe_cpufreq: Limit frequency via cpufreq notifier chain
  [POWERPC] Fix pci_setup_phb_io_dynamic for pci_iomap
  [POWERPC] spufs scheduler: Fix wakeup races
  [POWERPC] spufs: Synchronize pte invalidation vs ps close
  [POWERPC] spufs: Free mm if spufs_fill_dir() failed
  [POWERPC] spufs: Fix gang destroy leaks
  [POWERPC] spufs: Hook up spufs_release_mem
  [POWERPC] spufs: Refuse to load the module when not running on cell
  [POWERPC] pasemi: Fix iommu + 64K PAGE_SIZE bug

10 files changed, 167 insertions, 165 deletions

diff --git a/arch/powerpc/boot/crt0.S b/arch/powerpc/boot/crt0.S
index 5a4215c4b01..f1c4dfc635b 100644
--- a/arch/powerpc/boot/crt0.S
+++ b/arch/powerpc/boot/crt0.S
@@ -13,6 +13,7 @@
 
         .text
         /* a procedure descriptor used when booting this as a COFF file */
+        .globl  _zimage_start_opd
 _zimage_start_opd:
         .long   _zimage_start, 0, 0, 0
 
diff --git a/arch/powerpc/kernel/of_platform.c b/arch/powerpc/kernel/of_platform.c
index d501c23e515..d454f61c9c7 100644
--- a/arch/powerpc/kernel/of_platform.c
+++ b/arch/powerpc/kernel/of_platform.c
@@ -433,7 +433,7 @@ static int __devinit of_pci_phb_probe(struct of_device *dev,
          * Note also that we don't do ISA, this will also be fixed with a
          * more massive rework.
          */
-        pci_setup_phb_io(phb, 0);
+        pci_setup_phb_io(phb, pci_io_base == 0);
 
         /* Init pci_dn data structures */
         pci_devs_phb_init_dynamic(phb);
diff --git a/arch/powerpc/platforms/cell/cbe_cpufreq.c b/arch/powerpc/platforms/cell/cbe_cpufreq.c
index f9ac3fe3be9..ac445998d83 100644
--- a/arch/powerpc/platforms/cell/cbe_cpufreq.c
+++ b/arch/powerpc/platforms/cell/cbe_cpufreq.c
@@ -67,6 +67,7 @@ static u64 MIC_Slow_Next_Timer_table[] = {
         0x00003FC000000000ull,
 };
 
+static unsigned int pmi_frequency_limit = 0;
 /*
  * hardware specific functions
  */
@@ -164,7 +165,6 @@ static int set_pmode(int cpu, unsigned int slow_mode) {
 
 static void cbe_cpufreq_handle_pmi(struct of_device *dev, pmi_message_t pmi_msg)
 {
-        struct cpufreq_policy policy;
         u8 cpu;
         u8 cbe_pmode_new;
 
@@ -173,15 +173,27 @@ static void cbe_cpufreq_handle_pmi(struct of_device *dev, pmi_message_t pmi_msg)
         cpu = cbe_node_to_cpu(pmi_msg.data1);
         cbe_pmode_new = pmi_msg.data2;
 
-        cpufreq_get_policy(&policy, cpu);
+        pmi_frequency_limit = cbe_freqs[cbe_pmode_new].frequency;
 
-        policy.max = min(policy.max, cbe_freqs[cbe_pmode_new].frequency);
-        policy.min = min(policy.min, policy.max);
+        pr_debug("cbe_handle_pmi: max freq=%d\n", pmi_frequency_limit);
+}
+
+static int pmi_notifier(struct notifier_block *nb,
+                                       unsigned long event, void *data)
+{
+        struct cpufreq_policy *policy = data;
 
-        pr_debug("cbe_handle_pmi: new policy.min=%d policy.max=%d\n", policy.min, policy.max);
-        cpufreq_set_policy(&policy);
+        if (event != CPUFREQ_INCOMPATIBLE)
+                return 0;
+
+        cpufreq_verify_within_limits(policy, 0, pmi_frequency_limit);
+        return 0;
 }
 
+static struct notifier_block pmi_notifier_block = {
+        .notifier_call = pmi_notifier,
+};
+
 static struct pmi_handler cbe_pmi_handler = {
         .type                   = PMI_TYPE_FREQ_CHANGE,
         .handle_pmi_message     = cbe_cpufreq_handle_pmi,
@@ -238,12 +250,21 @@ static int cbe_cpufreq_cpu_init(struct cpufreq_policy *policy)
 
         cpufreq_frequency_table_get_attr(cbe_freqs, policy->cpu);
 
+        if (pmi_dev) {
+                /* frequency might get limited later, initialize limit with max_freq */
+                pmi_frequency_limit = max_freq;
+                cpufreq_register_notifier(&pmi_notifier_block, CPUFREQ_POLICY_NOTIFIER);
+        }
+
         /* this ensures that policy->cpuinfo_min and policy->cpuinfo_max are set correctly */
         return cpufreq_frequency_table_cpuinfo(policy, cbe_freqs);
 }
 
 static int cbe_cpufreq_cpu_exit(struct cpufreq_policy *policy)
 {
+        if (pmi_dev)
+                cpufreq_unregister_notifier(&pmi_notifier_block, CPUFREQ_POLICY_NOTIFIER);
+
         cpufreq_frequency_table_put_attr(policy->cpu);
         return 0;
 }
diff --git a/arch/powerpc/platforms/cell/spufs/context.c b/arch/powerpc/platforms/cell/spufs/context.c
index 8654749e317..7c51cb54bca 100644
--- a/arch/powerpc/platforms/cell/spufs/context.c
+++ b/arch/powerpc/platforms/cell/spufs/context.c
@@ -39,7 +39,7 @@ struct spu_context *alloc_spu_context(struct spu_gang *gang)
         if (spu_init_csa(&ctx->csa))
                 goto out_free;
         spin_lock_init(&ctx->mmio_lock);
-        spin_lock_init(&ctx->mapping_lock);
+        mutex_init(&ctx->mapping_lock);
         kref_init(&ctx->kref);
         mutex_init(&ctx->state_mutex);
         mutex_init(&ctx->run_mutex);
@@ -103,6 +103,7 @@ void spu_forget(struct spu_context *ctx)
 
 void spu_unmap_mappings(struct spu_context *ctx)
 {
+        mutex_lock(&ctx->mapping_lock);
         if (ctx->local_store)
                 unmap_mapping_range(ctx->local_store, 0, LS_SIZE, 1);
         if (ctx->mfc)
@@ -117,6 +118,7 @@ void spu_unmap_mappings(struct spu_context *ctx)
                 unmap_mapping_range(ctx->mss, 0, 0x1000, 1);
         if (ctx->psmap)
                 unmap_mapping_range(ctx->psmap, 0, 0x20000, 1);
+        mutex_unlock(&ctx->mapping_lock);
 }
 
 /**
diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index 45614c73c78..b1e7e2f8a2e 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -45,11 +45,11 @@ spufs_mem_open(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         file->private_data = ctx;
         if (!i->i_openers++)
                 ctx->local_store = inode->i_mapping;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return 0;
 }
 
@@ -59,10 +59,10 @@ spufs_mem_release(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         if (!--i->i_openers)
                 ctx->local_store = NULL;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return 0;
 }
 
@@ -217,6 +217,7 @@ unsigned long spufs_get_unmapped_area(struct file *file, unsigned long addr,
 
 static const struct file_operations spufs_mem_fops = {
         .open                   = spufs_mem_open,
+        .release                = spufs_mem_release,
         .read                   = spufs_mem_read,
         .write                  = spufs_mem_write,
         .llseek                 = generic_file_llseek,
@@ -309,11 +310,11 @@ static int spufs_cntl_open(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         file->private_data = ctx;
         if (!i->i_openers++)
                 ctx->cntl = inode->i_mapping;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return simple_attr_open(inode, file, spufs_cntl_get,
                                         spufs_cntl_set, "0x%08lx");
 }
@@ -326,10 +327,10 @@ spufs_cntl_release(struct inode *inode, struct file *file)
 
         simple_attr_close(inode, file);
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         if (!--i->i_openers)
                 ctx->cntl = NULL;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return 0;
 }
 
@@ -812,11 +813,11 @@ static int spufs_signal1_open(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         file->private_data = ctx;
         if (!i->i_openers++)
                 ctx->signal1 = inode->i_mapping;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return nonseekable_open(inode, file);
 }
 
@@ -826,10 +827,10 @@ spufs_signal1_release(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         if (!--i->i_openers)
                 ctx->signal1 = NULL;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return 0;
 }
 
@@ -936,11 +937,11 @@ static int spufs_signal2_open(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         file->private_data = ctx;
         if (!i->i_openers++)
                 ctx->signal2 = inode->i_mapping;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return nonseekable_open(inode, file);
 }
 
@@ -950,10 +951,10 @@ spufs_signal2_release(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         if (!--i->i_openers)
                 ctx->signal2 = NULL;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return 0;
 }
 
@@ -1154,10 +1155,10 @@ static int spufs_mss_open(struct inode *inode, struct file *file)
 
         file->private_data = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         if (!i->i_openers++)
                 ctx->mss = inode->i_mapping;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return nonseekable_open(inode, file);
 }
 
@@ -1167,10 +1168,10 @@ spufs_mss_release(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         if (!--i->i_openers)
                 ctx->mss = NULL;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return 0;
 }
 
@@ -1211,11 +1212,11 @@ static int spufs_psmap_open(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         file->private_data = i->i_ctx;
         if (!i->i_openers++)
                 ctx->psmap = inode->i_mapping;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return nonseekable_open(inode, file);
 }
 
@@ -1225,10 +1226,10 @@ spufs_psmap_release(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         if (!--i->i_openers)
                 ctx->psmap = NULL;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return 0;
 }
 
@@ -1281,11 +1282,11 @@ static int spufs_mfc_open(struct inode *inode, struct file *file)
         if (atomic_read(&inode->i_count) != 1)
                 return -EBUSY;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         file->private_data = ctx;
         if (!i->i_openers++)
                 ctx->mfc = inode->i_mapping;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return nonseekable_open(inode, file);
 }
 
@@ -1295,10 +1296,10 @@ spufs_mfc_release(struct inode *inode, struct file *file)
         struct spufs_inode_info *i = SPUFS_I(inode);
         struct spu_context *ctx = i->i_ctx;
 
-        spin_lock(&ctx->mapping_lock);
+        mutex_lock(&ctx->mapping_lock);
         if (!--i->i_openers)
                 ctx->mfc = NULL;
-        spin_unlock(&ctx->mapping_lock);
+        mutex_unlock(&ctx->mapping_lock);
         return 0;
 }
 
diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index 7150730e2ff..9807206e021 100644
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -177,7 +177,7 @@ static int spufs_rmdir(struct inode *parent, struct dentry *dir)
 static int spufs_fill_dir(struct dentry *dir, struct tree_descr *files,
                           int mode, struct spu_context *ctx)
 {
-        struct dentry *dentry;
+        struct dentry *dentry, *tmp;
         int ret;
 
         while (files->name && files->name[0]) {
@@ -193,7 +193,20 @@ static int spufs_fill_dir(struct dentry *dir, struct tree_descr *files,
         }
         return 0;
 out:
-        spufs_prune_dir(dir);
+        /*
+         * remove all children from dir. dir->inode is not set so don't
+         * just simply use spufs_prune_dir() and panic afterwards :)
+         * dput() looks like it will do the right thing:
+         * - dec parent's ref counter
+         * - remove child from parent's child list
+         * - free child's inode if possible
+         * - free child
+         */
+        list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_u.d_child) {
+                dput(dentry);
+        }
+
+        shrink_dcache_parent(dir);
         return ret;
 }
 
@@ -274,6 +287,7 @@ spufs_mkdir(struct inode *dir, struct dentry *dentry, unsigned int flags,
         goto out;
 
 out_free_ctx:
+        spu_forget(ctx);
         put_spu_context(ctx);
 out_iput:
         iput(inode);
@@ -349,37 +363,6 @@ out:
         return ret;
 }
 
-static int spufs_rmgang(struct inode *root, struct dentry *dir)
-{
-        /* FIXME: this fails if the dir is not empty,
-                  which causes a leak of gangs. */
-        return simple_rmdir(root, dir);
-}
-
-static int spufs_gang_close(struct inode *inode, struct file *file)
-{
-        struct inode *parent;
-        struct dentry *dir;
-        int ret;
-
-        dir = file->f_path.dentry;
-        parent = dir->d_parent->d_inode;
-
-        ret = spufs_rmgang(parent, dir);
-        WARN_ON(ret);
-
-        return dcache_dir_close(inode, file);
-}
-
-const struct file_operations spufs_gang_fops = {
-        .open           = dcache_dir_open,
-        .release        = spufs_gang_close,
-        .llseek         = dcache_dir_lseek,
-        .read           = generic_read_dir,
-        .readdir        = dcache_readdir,
-        .fsync          = simple_sync_file,
-};
-
 static int
 spufs_mkgang(struct inode *dir, struct dentry *dentry, int mode)
 {
@@ -407,7 +390,6 @@ spufs_mkgang(struct inode *dir, struct dentry *dentry, int mode)
         inode->i_fop = &simple_dir_operations;
 
         d_instantiate(dentry, inode);
-        dget(dentry);
         dir->i_nlink++;
         dentry->d_inode->i_nlink++;
         return ret;
@@ -437,7 +419,7 @@ static int spufs_gang_open(struct dentry *dentry, struct vfsmount *mnt)
                 goto out;
         }
 
-        filp->f_op = &spufs_gang_fops;
+        filp->f_op = &simple_dir_operations;
         fd_install(ret, filp);
 out:
         return ret;
@@ -458,8 +440,10 @@ static int spufs_create_gang(struct inode *inode,
          * in error path of *_open().
          */
         ret = spufs_gang_open(dget(dentry), mntget(mnt));
-        if (ret < 0)
-                WARN_ON(spufs_rmgang(inode, dentry));
+        if (ret < 0) {
+                int err = simple_rmdir(inode, dentry);
+                WARN_ON(err);
+        }
 
 out:
         mutex_unlock(&inode->i_mutex);
@@ -600,6 +584,10 @@ spufs_create_root(struct super_block *sb, void *data)
         struct inode *inode;
         int ret;
 
+        ret = -ENODEV;
+        if (!spu_management_ops)
+                goto out;
+
         ret = -ENOMEM;
         inode = spufs_new_inode(sb, S_IFDIR | 0775);
         if (!inode)
diff --git a/arch/powerpc/platforms/cell/spufs/sched.c b/arch/powerpc/platforms/cell/spufs/sched.c
index b6ecb30e7d5..3b831e07f1e 100644
--- a/arch/powerpc/platforms/cell/spufs/sched.c
+++ b/arch/powerpc/platforms/cell/spufs/sched.c
@@ -93,43 +93,6 @@ void spu_stop_tick(struct spu_context *ctx)
         }
 }
 
-void spu_sched_tick(struct work_struct *work)
-{
-        struct spu_context *ctx =
-                container_of(work, struct spu_context, sched_work.work);
-        struct spu *spu;
-        int preempted = 0;
-
-        /*
-         * If this context is being stopped avoid rescheduling from the
-         * scheduler tick because we would block on the state_mutex.
-         * The caller will yield the spu later on anyway.
-         */
-        if (test_bit(SPU_SCHED_EXITING, &ctx->sched_flags))
-                return;
-
-        mutex_lock(&ctx->state_mutex);
-        spu = ctx->spu;
-        if (spu) {
-                int best = sched_find_first_bit(spu_prio->bitmap);
-                if (best <= ctx->prio) {
-                        spu_deactivate(ctx);
-                        preempted = 1;
-                }
-        }
-        mutex_unlock(&ctx->state_mutex);
-
-        if (preempted) {
-                /*
-                 * We need to break out of the wait loop in spu_run manually
-                 * to ensure this context gets put on the runqueue again
-                 * ASAP.
-                 */
-                wake_up(&ctx->stop_wq);
-        } else
-                spu_start_tick(ctx);
-}
-
 /**
  * spu_add_to_active_list - add spu to active list
  * @spu:        spu to add to the active list
@@ -273,34 +236,6 @@ static void spu_prio_wait(struct spu_context *ctx)
         remove_wait_queue(&ctx->stop_wq, &wait);
 }
 
-/**
- * spu_reschedule - try to find a runnable context for a spu
- * @spu:       spu available
- *
- * This function is called whenever a spu becomes idle.  It looks for the
- * most suitable runnable spu context and schedules it for execution.
- */
-static void spu_reschedule(struct spu *spu)
-{
-        int best;
-
-        spu_free(spu);
-
-        spin_lock(&spu_prio->runq_lock);
-        best = sched_find_first_bit(spu_prio->bitmap);
-        if (best < MAX_PRIO) {
-                struct list_head *rq = &spu_prio->runq[best];
-                struct spu_context *ctx;
-
-                BUG_ON(list_empty(rq));
-
-                ctx = list_entry(rq->next, struct spu_context, rq);
-                __spu_del_from_rq(ctx);
-                wake_up(&ctx->stop_wq);
-        }
-        spin_unlock(&spu_prio->runq_lock);
-}
-
 static struct spu *spu_get_idle(struct spu_context *ctx)
 {
         struct spu *spu = NULL;
@@ -429,6 +364,51 @@ int spu_activate(struct spu_context *ctx, unsigned long flags)
 }
 
 /**
+ * grab_runnable_context - try to find a runnable context
+ *
+ * Remove the highest priority context on the runqueue and return it
+ * to the caller.  Returns %NULL if no runnable context was found.
+ */
+static struct spu_context *grab_runnable_context(int prio)
+{
+        struct spu_context *ctx = NULL;
+        int best;
+
+        spin_lock(&spu_prio->runq_lock);
+        best = sched_find_first_bit(spu_prio->bitmap);
+        if (best < prio) {
+                struct list_head *rq = &spu_prio->runq[best];
+
+                BUG_ON(list_empty(rq));
+
+                ctx = list_entry(rq->next, struct spu_context, rq);
+                __spu_del_from_rq(ctx);
+        }
+        spin_unlock(&spu_prio->runq_lock);
+
+        return ctx;
+}
+
+static int __spu_deactivate(struct spu_context *ctx, int force, int max_prio)
+{
+        struct spu *spu = ctx->spu;
+        struct spu_context *new = NULL;
+
+        if (spu) {
+                new = grab_runnable_context(max_prio);
+                if (new || force) {
+                        spu_unbind_context(spu, ctx);
+                        spu_free(spu);
+                        if (new)
+                                wake_up(&new->stop_wq);
+                }
+
+        }
+
+        return new != NULL;
+}
+
+/**
  * spu_deactivate - unbind a context from it's physical spu
  * @ctx:        spu context to unbind
  *
@@ -437,12 +417,7 @@ int spu_activate(struct spu_context *ctx, unsigned long flags)
  */
 void spu_deactivate(struct spu_context *ctx)
 {
-        struct spu *spu = ctx->spu;
-
-        if (spu) {
-                spu_unbind_context(spu, ctx);
-                spu_reschedule(spu);
-        }
+        __spu_deactivate(ctx, 1, MAX_PRIO);
 }
 
 /**
@@ -455,21 +430,43 @@ void spu_deactivate(struct spu_context *ctx)
  */
 void spu_yield(struct spu_context *ctx)
 {
-        struct spu *spu;
-
-        if (mutex_trylock(&ctx->state_mutex)) {
-                if ((spu = ctx->spu) != NULL) {
-                        int best = sched_find_first_bit(spu_prio->bitmap);
-                        if (best < MAX_PRIO) {
-                                pr_debug("%s: yielding SPU %d NODE %d\n",
-                                         __FUNCTION__, spu->number, spu->node);
-                                spu_deactivate(ctx);
-                        }
-                }
+        if (!(ctx->flags & SPU_CREATE_NOSCHED)) {
+                mutex_lock(&ctx->state_mutex);
+                __spu_deactivate(ctx, 0, MAX_PRIO);
                 mutex_unlock(&ctx->state_mutex);
         }
 }
 
+void spu_sched_tick(struct work_struct *work)
+{
+        struct spu_context *ctx =
+                container_of(work, struct spu_context, sched_work.work);
+        int preempted;
+
+        /*
+         * If this context is being stopped avoid rescheduling from the
+         * scheduler tick because we would block on the state_mutex.
+         * The caller will yield the spu later on anyway.
+         */
+        if (test_bit(SPU_SCHED_EXITING, &ctx->sched_flags))
+                return;
+
+        mutex_lock(&ctx->state_mutex);
+        preempted = __spu_deactivate(ctx, 0, ctx->prio + 1);
+        mutex_unlock(&ctx->state_mutex);
+
+        if (preempted) {
+                /*
+                 * We need to break out of the wait loop in spu_run manually
+                 * to ensure this context gets put on the runqueue again
+                 * ASAP.
+                 */
+                wake_up(&ctx->stop_wq);
+        } else {
+                spu_start_tick(ctx);
+        }
+}
+
 int __init spu_sched_init(void)
 {
         int i;
diff --git a/arch/powerpc/platforms/cell/spufs/spufs.h b/arch/powerpc/platforms/cell/spufs/spufs.h
index 0a947fd7de5..47617e8014a 100644
--- a/arch/powerpc/platforms/cell/spufs/spufs.h
+++ b/arch/powerpc/platforms/cell/spufs/spufs.h
@@ -55,7 +55,7 @@ struct spu_context {
         struct address_space *signal2;     /* 'signal2' area mappings. */
         struct address_space *mss;         /* 'mss' area mappings. */
         struct address_space *psmap;       /* 'psmap' area mappings. */
-        spinlock_t mapping_lock;
+        struct mutex mapping_lock;
         u64 object_id;             /* user space pointer for oprofile */
 
         enum { SPU_STATE_RUNNABLE, SPU_STATE_SAVED } state;
diff --git a/arch/powerpc/platforms/celleb/Makefile b/arch/powerpc/platforms/celleb/Makefile
index f4f82520dc4..5240046d867 100644
--- a/arch/powerpc/platforms/celleb/Makefile
+++ b/arch/powerpc/platforms/celleb/Makefile
@@ -4,5 +4,5 @@ obj-y				+= interrupt.o iommu.o setup.o \
 
 obj-$(CONFIG_SMP)               += smp.o
 obj-$(CONFIG_PPC_UDBG_BEAT)     += udbg_beat.o
-obj-$(CONFIG_HAS_TXX9_SERIAL)   += scc_sio.o
+obj-$(CONFIG_SERIAL_TXX9)       += scc_sio.o
 obj-$(CONFIG_SPU_BASE)          += spu_priv1.o
diff --git a/arch/powerpc/platforms/pasemi/iommu.c b/arch/powerpc/platforms/pasemi/iommu.c
index 95fa6a7d15e..f33b21b9f5d 100644
--- a/arch/powerpc/platforms/pasemi/iommu.c
+++ b/arch/powerpc/platforms/pasemi/iommu.c
@@ -31,8 +31,6 @@
 #define IOBMAP_PAGE_SIZE        (1 << IOBMAP_PAGE_SHIFT)
 #define IOBMAP_PAGE_MASK        (IOBMAP_PAGE_SIZE - 1)
 
-#define IOBMAP_PAGE_FACTOR      (PAGE_SHIFT - IOBMAP_PAGE_SHIFT)
-
 #define IOB_BASE                0xe0000000
 #define IOB_SIZE                0x3000
 /* Configuration registers */
@@ -97,9 +95,6 @@ static void iobmap_build(struct iommu_table *tbl, long index,
 
         bus_addr = (tbl->it_offset + index) << PAGE_SHIFT;
 
-        npages <<= IOBMAP_PAGE_FACTOR;
-        index <<= IOBMAP_PAGE_FACTOR;
-
         ip = ((u32 *)tbl->it_base) + index;
 
         while (npages--) {
@@ -125,9 +120,6 @@ static void iobmap_free(struct iommu_table *tbl, long index,
 
         bus_addr = (tbl->it_offset + index) << PAGE_SHIFT;
 
-        npages <<= IOBMAP_PAGE_FACTOR;
-        index <<= IOBMAP_PAGE_FACTOR;
-
         ip = ((u32 *)tbl->it_base) + index;
 
         while (npages--) {