spusched: fix mismerge in spufs.h
[linux-2.6] / arch / powerpc / platforms / cell / spu_base.c
1 /*
2  * Low-level SPU handling
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 #undef DEBUG
24
25 #include <linux/interrupt.h>
26 #include <linux/list.h>
27 #include <linux/module.h>
28 #include <linux/ptrace.h>
29 #include <linux/slab.h>
30 #include <linux/wait.h>
31 #include <linux/mm.h>
32 #include <linux/io.h>
33 #include <linux/mutex.h>
34 #include <linux/linux_logo.h>
35 #include <asm/spu.h>
36 #include <asm/spu_priv1.h>
37 #include <asm/xmon.h>
38 #include <asm/prom.h>
39 #include "spu_priv1_mmio.h"
40
41 const struct spu_management_ops *spu_management_ops;
42 EXPORT_SYMBOL_GPL(spu_management_ops);
43
44 const struct spu_priv1_ops *spu_priv1_ops;
45 EXPORT_SYMBOL_GPL(spu_priv1_ops);
46
47 struct cbe_spu_info cbe_spu_info[MAX_NUMNODES];
48 EXPORT_SYMBOL_GPL(cbe_spu_info);
49
50 /*
51  * Protects cbe_spu_info and spu->number.
52  */
53 static DEFINE_SPINLOCK(spu_lock);
54
55 /*
56  * List of all spus in the system.
57  *
58  * This list is iterated by callers from irq context and callers that
59  * want to sleep.  Thus modifications need to be done with both
60  * spu_full_list_lock and spu_full_list_mutex held, while iterating
61  * through it requires either of these locks.
62  *
63  * In addition spu_full_list_lock protects all assignmens to
64  * spu->mm.
65  */
66 static LIST_HEAD(spu_full_list);
67 static DEFINE_SPINLOCK(spu_full_list_lock);
68 static DEFINE_MUTEX(spu_full_list_mutex);
69
70 void spu_invalidate_slbs(struct spu *spu)
71 {
72         struct spu_priv2 __iomem *priv2 = spu->priv2;
73
74         if (spu_mfc_sr1_get(spu) & MFC_STATE1_RELOCATE_MASK)
75                 out_be64(&priv2->slb_invalidate_all_W, 0UL);
76 }
77 EXPORT_SYMBOL_GPL(spu_invalidate_slbs);
78
79 /* This is called by the MM core when a segment size is changed, to
80  * request a flush of all the SPEs using a given mm
81  */
82 void spu_flush_all_slbs(struct mm_struct *mm)
83 {
84         struct spu *spu;
85         unsigned long flags;
86
87         spin_lock_irqsave(&spu_full_list_lock, flags);
88         list_for_each_entry(spu, &spu_full_list, full_list) {
89                 if (spu->mm == mm)
90                         spu_invalidate_slbs(spu);
91         }
92         spin_unlock_irqrestore(&spu_full_list_lock, flags);
93 }
94
95 /* The hack below stinks... try to do something better one of
96  * these days... Does it even work properly with NR_CPUS == 1 ?
97  */
98 static inline void mm_needs_global_tlbie(struct mm_struct *mm)
99 {
100         int nr = (NR_CPUS > 1) ? NR_CPUS : NR_CPUS + 1;
101
102         /* Global TLBIE broadcast required with SPEs. */
103         __cpus_setall(&mm->cpu_vm_mask, nr);
104 }
105
106 void spu_associate_mm(struct spu *spu, struct mm_struct *mm)
107 {
108         unsigned long flags;
109
110         spin_lock_irqsave(&spu_full_list_lock, flags);
111         spu->mm = mm;
112         spin_unlock_irqrestore(&spu_full_list_lock, flags);
113         if (mm)
114                 mm_needs_global_tlbie(mm);
115 }
116 EXPORT_SYMBOL_GPL(spu_associate_mm);
117
118 static int __spu_trap_invalid_dma(struct spu *spu)
119 {
120         pr_debug("%s\n", __FUNCTION__);
121         spu->dma_callback(spu, SPE_EVENT_INVALID_DMA);
122         return 0;
123 }
124
125 static int __spu_trap_dma_align(struct spu *spu)
126 {
127         pr_debug("%s\n", __FUNCTION__);
128         spu->dma_callback(spu, SPE_EVENT_DMA_ALIGNMENT);
129         return 0;
130 }
131
132 static int __spu_trap_error(struct spu *spu)
133 {
134         pr_debug("%s\n", __FUNCTION__);
135         spu->dma_callback(spu, SPE_EVENT_SPE_ERROR);
136         return 0;
137 }
138
139 static void spu_restart_dma(struct spu *spu)
140 {
141         struct spu_priv2 __iomem *priv2 = spu->priv2;
142
143         if (!test_bit(SPU_CONTEXT_SWITCH_PENDING, &spu->flags))
144                 out_be64(&priv2->mfc_control_RW, MFC_CNTL_RESTART_DMA_COMMAND);
145 }
146
147 static int __spu_trap_data_seg(struct spu *spu, unsigned long ea)
148 {
149         struct spu_priv2 __iomem *priv2 = spu->priv2;
150         struct mm_struct *mm = spu->mm;
151         u64 esid, vsid, llp;
152         int psize;
153
154         pr_debug("%s\n", __FUNCTION__);
155
156         if (test_bit(SPU_CONTEXT_SWITCH_ACTIVE, &spu->flags)) {
157                 /* SLBs are pre-loaded for context switch, so
158                  * we should never get here!
159                  */
160                 printk("%s: invalid access during switch!\n", __func__);
161                 return 1;
162         }
163         esid = (ea & ESID_MASK) | SLB_ESID_V;
164
165         switch(REGION_ID(ea)) {
166         case USER_REGION_ID:
167 #ifdef CONFIG_PPC_MM_SLICES
168                 psize = get_slice_psize(mm, ea);
169 #else
170                 psize = mm->context.user_psize;
171 #endif
172                 vsid = (get_vsid(mm->context.id, ea) << SLB_VSID_SHIFT) |
173                                 SLB_VSID_USER;
174                 break;
175         case VMALLOC_REGION_ID:
176                 if (ea < VMALLOC_END)
177                         psize = mmu_vmalloc_psize;
178                 else
179                         psize = mmu_io_psize;
180                 vsid = (get_kernel_vsid(ea) << SLB_VSID_SHIFT) |
181                         SLB_VSID_KERNEL;
182                 break;
183         case KERNEL_REGION_ID:
184                 psize = mmu_linear_psize;
185                 vsid = (get_kernel_vsid(ea) << SLB_VSID_SHIFT) |
186                         SLB_VSID_KERNEL;
187                 break;
188         default:
189                 /* Future: support kernel segments so that drivers
190                  * can use SPUs.
191                  */
192                 pr_debug("invalid region access at %016lx\n", ea);
193                 return 1;
194         }
195         llp = mmu_psize_defs[psize].sllp;
196
197         out_be64(&priv2->slb_index_W, spu->slb_replace);
198         out_be64(&priv2->slb_vsid_RW, vsid | llp);
199         out_be64(&priv2->slb_esid_RW, esid);
200
201         spu->slb_replace++;
202         if (spu->slb_replace >= 8)
203                 spu->slb_replace = 0;
204
205         spu_restart_dma(spu);
206         spu->stats.slb_flt++;
207         return 0;
208 }
209
210 extern int hash_page(unsigned long ea, unsigned long access, unsigned long trap); //XXX
211 static int __spu_trap_data_map(struct spu *spu, unsigned long ea, u64 dsisr)
212 {
213         pr_debug("%s, %lx, %lx\n", __FUNCTION__, dsisr, ea);
214
215         /* Handle kernel space hash faults immediately.
216            User hash faults need to be deferred to process context. */
217         if ((dsisr & MFC_DSISR_PTE_NOT_FOUND)
218             && REGION_ID(ea) != USER_REGION_ID
219             && hash_page(ea, _PAGE_PRESENT, 0x300) == 0) {
220                 spu_restart_dma(spu);
221                 return 0;
222         }
223
224         if (test_bit(SPU_CONTEXT_SWITCH_ACTIVE, &spu->flags)) {
225                 printk("%s: invalid access during switch!\n", __func__);
226                 return 1;
227         }
228
229         spu->dar = ea;
230         spu->dsisr = dsisr;
231         mb();
232         spu->stop_callback(spu);
233         return 0;
234 }
235
236 static irqreturn_t
237 spu_irq_class_0(int irq, void *data)
238 {
239         struct spu *spu;
240
241         spu = data;
242         spu->class_0_pending = 1;
243         spu->stop_callback(spu);
244
245         return IRQ_HANDLED;
246 }
247
248 int
249 spu_irq_class_0_bottom(struct spu *spu)
250 {
251         unsigned long stat, mask;
252         unsigned long flags;
253
254         spu->class_0_pending = 0;
255
256         spin_lock_irqsave(&spu->register_lock, flags);
257         mask = spu_int_mask_get(spu, 0);
258         stat = spu_int_stat_get(spu, 0);
259
260         stat &= mask;
261
262         if (stat & 1) /* invalid DMA alignment */
263                 __spu_trap_dma_align(spu);
264
265         if (stat & 2) /* invalid MFC DMA */
266                 __spu_trap_invalid_dma(spu);
267
268         if (stat & 4) /* error on SPU */
269                 __spu_trap_error(spu);
270
271         spu_int_stat_clear(spu, 0, stat);
272         spin_unlock_irqrestore(&spu->register_lock, flags);
273
274         return (stat & 0x7) ? -EIO : 0;
275 }
276 EXPORT_SYMBOL_GPL(spu_irq_class_0_bottom);
277
278 static irqreturn_t
279 spu_irq_class_1(int irq, void *data)
280 {
281         struct spu *spu;
282         unsigned long stat, mask, dar, dsisr;
283
284         spu = data;
285
286         /* atomically read & clear class1 status. */
287         spin_lock(&spu->register_lock);
288         mask  = spu_int_mask_get(spu, 1);
289         stat  = spu_int_stat_get(spu, 1) & mask;
290         dar   = spu_mfc_dar_get(spu);
291         dsisr = spu_mfc_dsisr_get(spu);
292         if (stat & 2) /* mapping fault */
293                 spu_mfc_dsisr_set(spu, 0ul);
294         spu_int_stat_clear(spu, 1, stat);
295         spin_unlock(&spu->register_lock);
296         pr_debug("%s: %lx %lx %lx %lx\n", __FUNCTION__, mask, stat,
297                         dar, dsisr);
298
299         if (stat & 1) /* segment fault */
300                 __spu_trap_data_seg(spu, dar);
301
302         if (stat & 2) { /* mapping fault */
303                 __spu_trap_data_map(spu, dar, dsisr);
304         }
305
306         if (stat & 4) /* ls compare & suspend on get */
307                 ;
308
309         if (stat & 8) /* ls compare & suspend on put */
310                 ;
311
312         return stat ? IRQ_HANDLED : IRQ_NONE;
313 }
314
315 static irqreturn_t
316 spu_irq_class_2(int irq, void *data)
317 {
318         struct spu *spu;
319         unsigned long stat;
320         unsigned long mask;
321
322         spu = data;
323         spin_lock(&spu->register_lock);
324         stat = spu_int_stat_get(spu, 2);
325         mask = spu_int_mask_get(spu, 2);
326         /* ignore interrupts we're not waiting for */
327         stat &= mask;
328         /*
329          * mailbox interrupts (0x1 and 0x10) are level triggered.
330          * mask them now before acknowledging.
331          */
332         if (stat & 0x11)
333                 spu_int_mask_and(spu, 2, ~(stat & 0x11));
334         /* acknowledge all interrupts before the callbacks */
335         spu_int_stat_clear(spu, 2, stat);
336         spin_unlock(&spu->register_lock);
337
338         pr_debug("class 2 interrupt %d, %lx, %lx\n", irq, stat, mask);
339
340         if (stat & 1)  /* PPC core mailbox */
341                 spu->ibox_callback(spu);
342
343         if (stat & 2) /* SPU stop-and-signal */
344                 spu->stop_callback(spu);
345
346         if (stat & 4) /* SPU halted */
347                 spu->stop_callback(spu);
348
349         if (stat & 8) /* DMA tag group complete */
350                 spu->mfc_callback(spu);
351
352         if (stat & 0x10) /* SPU mailbox threshold */
353                 spu->wbox_callback(spu);
354
355         spu->stats.class2_intr++;
356         return stat ? IRQ_HANDLED : IRQ_NONE;
357 }
358
359 static int spu_request_irqs(struct spu *spu)
360 {
361         int ret = 0;
362
363         if (spu->irqs[0] != NO_IRQ) {
364                 snprintf(spu->irq_c0, sizeof (spu->irq_c0), "spe%02d.0",
365                          spu->number);
366                 ret = request_irq(spu->irqs[0], spu_irq_class_0,
367                                   IRQF_DISABLED,
368                                   spu->irq_c0, spu);
369                 if (ret)
370                         goto bail0;
371         }
372         if (spu->irqs[1] != NO_IRQ) {
373                 snprintf(spu->irq_c1, sizeof (spu->irq_c1), "spe%02d.1",
374                          spu->number);
375                 ret = request_irq(spu->irqs[1], spu_irq_class_1,
376                                   IRQF_DISABLED,
377                                   spu->irq_c1, spu);
378                 if (ret)
379                         goto bail1;
380         }
381         if (spu->irqs[2] != NO_IRQ) {
382                 snprintf(spu->irq_c2, sizeof (spu->irq_c2), "spe%02d.2",
383                          spu->number);
384                 ret = request_irq(spu->irqs[2], spu_irq_class_2,
385                                   IRQF_DISABLED,
386                                   spu->irq_c2, spu);
387                 if (ret)
388                         goto bail2;
389         }
390         return 0;
391
392 bail2:
393         if (spu->irqs[1] != NO_IRQ)
394                 free_irq(spu->irqs[1], spu);
395 bail1:
396         if (spu->irqs[0] != NO_IRQ)
397                 free_irq(spu->irqs[0], spu);
398 bail0:
399         return ret;
400 }
401
402 static void spu_free_irqs(struct spu *spu)
403 {
404         if (spu->irqs[0] != NO_IRQ)
405                 free_irq(spu->irqs[0], spu);
406         if (spu->irqs[1] != NO_IRQ)
407                 free_irq(spu->irqs[1], spu);
408         if (spu->irqs[2] != NO_IRQ)
409                 free_irq(spu->irqs[2], spu);
410 }
411
412 void spu_init_channels(struct spu *spu)
413 {
414         static const struct {
415                  unsigned channel;
416                  unsigned count;
417         } zero_list[] = {
418                 { 0x00, 1, }, { 0x01, 1, }, { 0x03, 1, }, { 0x04, 1, },
419                 { 0x18, 1, }, { 0x19, 1, }, { 0x1b, 1, }, { 0x1d, 1, },
420         }, count_list[] = {
421                 { 0x00, 0, }, { 0x03, 0, }, { 0x04, 0, }, { 0x15, 16, },
422                 { 0x17, 1, }, { 0x18, 0, }, { 0x19, 0, }, { 0x1b, 0, },
423                 { 0x1c, 1, }, { 0x1d, 0, }, { 0x1e, 1, },
424         };
425         struct spu_priv2 __iomem *priv2;
426         int i;
427
428         priv2 = spu->priv2;
429
430         /* initialize all channel data to zero */
431         for (i = 0; i < ARRAY_SIZE(zero_list); i++) {
432                 int count;
433
434                 out_be64(&priv2->spu_chnlcntptr_RW, zero_list[i].channel);
435                 for (count = 0; count < zero_list[i].count; count++)
436                         out_be64(&priv2->spu_chnldata_RW, 0);
437         }
438
439         /* initialize channel counts to meaningful values */
440         for (i = 0; i < ARRAY_SIZE(count_list); i++) {
441                 out_be64(&priv2->spu_chnlcntptr_RW, count_list[i].channel);
442                 out_be64(&priv2->spu_chnlcnt_RW, count_list[i].count);
443         }
444 }
445 EXPORT_SYMBOL_GPL(spu_init_channels);
446
447 static int spu_shutdown(struct sys_device *sysdev)
448 {
449         struct spu *spu = container_of(sysdev, struct spu, sysdev);
450
451         spu_free_irqs(spu);
452         spu_destroy_spu(spu);
453         return 0;
454 }
455
456 struct sysdev_class spu_sysdev_class = {
457         set_kset_name("spu"),
458         .shutdown = spu_shutdown,
459 };
460
461 int spu_add_sysdev_attr(struct sysdev_attribute *attr)
462 {
463         struct spu *spu;
464
465         mutex_lock(&spu_full_list_mutex);
466         list_for_each_entry(spu, &spu_full_list, full_list)
467                 sysdev_create_file(&spu->sysdev, attr);
468         mutex_unlock(&spu_full_list_mutex);
469
470         return 0;
471 }
472 EXPORT_SYMBOL_GPL(spu_add_sysdev_attr);
473
474 int spu_add_sysdev_attr_group(struct attribute_group *attrs)
475 {
476         struct spu *spu;
477
478         mutex_lock(&spu_full_list_mutex);
479         list_for_each_entry(spu, &spu_full_list, full_list)
480                 sysfs_create_group(&spu->sysdev.kobj, attrs);
481         mutex_unlock(&spu_full_list_mutex);
482
483         return 0;
484 }
485 EXPORT_SYMBOL_GPL(spu_add_sysdev_attr_group);
486
487
488 void spu_remove_sysdev_attr(struct sysdev_attribute *attr)
489 {
490         struct spu *spu;
491
492         mutex_lock(&spu_full_list_mutex);
493         list_for_each_entry(spu, &spu_full_list, full_list)
494                 sysdev_remove_file(&spu->sysdev, attr);
495         mutex_unlock(&spu_full_list_mutex);
496 }
497 EXPORT_SYMBOL_GPL(spu_remove_sysdev_attr);
498
499 void spu_remove_sysdev_attr_group(struct attribute_group *attrs)
500 {
501         struct spu *spu;
502
503         mutex_lock(&spu_full_list_mutex);
504         list_for_each_entry(spu, &spu_full_list, full_list)
505                 sysfs_remove_group(&spu->sysdev.kobj, attrs);
506         mutex_unlock(&spu_full_list_mutex);
507 }
508 EXPORT_SYMBOL_GPL(spu_remove_sysdev_attr_group);
509
510 static int spu_create_sysdev(struct spu *spu)
511 {
512         int ret;
513
514         spu->sysdev.id = spu->number;
515         spu->sysdev.cls = &spu_sysdev_class;
516         ret = sysdev_register(&spu->sysdev);
517         if (ret) {
518                 printk(KERN_ERR "Can't register SPU %d with sysfs\n",
519                                 spu->number);
520                 return ret;
521         }
522
523         sysfs_add_device_to_node(&spu->sysdev, spu->node);
524
525         return 0;
526 }
527
528 static int __init create_spu(void *data)
529 {
530         struct spu *spu;
531         int ret;
532         static int number;
533         unsigned long flags;
534         struct timespec ts;
535
536         ret = -ENOMEM;
537         spu = kzalloc(sizeof (*spu), GFP_KERNEL);
538         if (!spu)
539                 goto out;
540
541         spu->alloc_state = SPU_FREE;
542
543         spin_lock_init(&spu->register_lock);
544         spin_lock(&spu_lock);
545         spu->number = number++;
546         spin_unlock(&spu_lock);
547
548         ret = spu_create_spu(spu, data);
549
550         if (ret)
551                 goto out_free;
552
553         spu_mfc_sdr_setup(spu);
554         spu_mfc_sr1_set(spu, 0x33);
555         ret = spu_request_irqs(spu);
556         if (ret)
557                 goto out_destroy;
558
559         ret = spu_create_sysdev(spu);
560         if (ret)
561                 goto out_free_irqs;
562
563         mutex_lock(&cbe_spu_info[spu->node].list_mutex);
564         list_add(&spu->cbe_list, &cbe_spu_info[spu->node].spus);
565         cbe_spu_info[spu->node].n_spus++;
566         mutex_unlock(&cbe_spu_info[spu->node].list_mutex);
567
568         mutex_lock(&spu_full_list_mutex);
569         spin_lock_irqsave(&spu_full_list_lock, flags);
570         list_add(&spu->full_list, &spu_full_list);
571         spin_unlock_irqrestore(&spu_full_list_lock, flags);
572         mutex_unlock(&spu_full_list_mutex);
573
574         spu->stats.util_state = SPU_UTIL_IDLE_LOADED;
575         ktime_get_ts(&ts);
576         spu->stats.tstamp = timespec_to_ns(&ts);
577
578         INIT_LIST_HEAD(&spu->aff_list);
579
580         goto out;
581
582 out_free_irqs:
583         spu_free_irqs(spu);
584 out_destroy:
585         spu_destroy_spu(spu);
586 out_free:
587         kfree(spu);
588 out:
589         return ret;
590 }
591
592 static const char *spu_state_names[] = {
593         "user", "system", "iowait", "idle"
594 };
595
596 static unsigned long long spu_acct_time(struct spu *spu,
597                 enum spu_utilization_state state)
598 {
599         struct timespec ts;
600         unsigned long long time = spu->stats.times[state];
601
602         /*
603          * If the spu is idle or the context is stopped, utilization
604          * statistics are not updated.  Apply the time delta from the
605          * last recorded state of the spu.
606          */
607         if (spu->stats.util_state == state) {
608                 ktime_get_ts(&ts);
609                 time += timespec_to_ns(&ts) - spu->stats.tstamp;
610         }
611
612         return time / NSEC_PER_MSEC;
613 }
614
615
616 static ssize_t spu_stat_show(struct sys_device *sysdev, char *buf)
617 {
618         struct spu *spu = container_of(sysdev, struct spu, sysdev);
619
620         return sprintf(buf, "%s %llu %llu %llu %llu "
621                       "%llu %llu %llu %llu %llu %llu %llu %llu\n",
622                 spu_state_names[spu->stats.util_state],
623                 spu_acct_time(spu, SPU_UTIL_USER),
624                 spu_acct_time(spu, SPU_UTIL_SYSTEM),
625                 spu_acct_time(spu, SPU_UTIL_IOWAIT),
626                 spu_acct_time(spu, SPU_UTIL_IDLE_LOADED),
627                 spu->stats.vol_ctx_switch,
628                 spu->stats.invol_ctx_switch,
629                 spu->stats.slb_flt,
630                 spu->stats.hash_flt,
631                 spu->stats.min_flt,
632                 spu->stats.maj_flt,
633                 spu->stats.class2_intr,
634                 spu->stats.libassist);
635 }
636
637 static SYSDEV_ATTR(stat, 0644, spu_stat_show, NULL);
638
639 /* Hardcoded affinity idxs for QS20 */
640 #define SPES_PER_BE 8
641 static int QS20_reg_idxs[SPES_PER_BE] =   { 0, 2, 4, 6, 7, 5, 3, 1 };
642 static int QS20_reg_memory[SPES_PER_BE] = { 1, 1, 0, 0, 0, 0, 0, 0 };
643
644 static struct spu *spu_lookup_reg(int node, u32 reg)
645 {
646         struct spu *spu;
647
648         list_for_each_entry(spu, &cbe_spu_info[node].spus, cbe_list) {
649                 if (*(u32 *)get_property(spu_devnode(spu), "reg", NULL) == reg)
650                         return spu;
651         }
652         return NULL;
653 }
654
655 static void init_aff_QS20_harcoded(void)
656 {
657         int node, i;
658         struct spu *last_spu, *spu;
659         u32 reg;
660
661         for (node = 0; node < MAX_NUMNODES; node++) {
662                 last_spu = NULL;
663                 for (i = 0; i < SPES_PER_BE; i++) {
664                         reg = QS20_reg_idxs[i];
665                         spu = spu_lookup_reg(node, reg);
666                         if (!spu)
667                                 continue;
668                         spu->has_mem_affinity = QS20_reg_memory[reg];
669                         if (last_spu)
670                                 list_add_tail(&spu->aff_list,
671                                                 &last_spu->aff_list);
672                         last_spu = spu;
673                 }
674         }
675 }
676
677 static int of_has_vicinity(void)
678 {
679         struct spu* spu;
680
681         spu = list_entry(cbe_spu_info[0].spus.next, struct spu, cbe_list);
682         return of_find_property(spu_devnode(spu), "vicinity", NULL) != NULL;
683 }
684
685 static struct spu *aff_devnode_spu(int cbe, struct device_node *dn)
686 {
687         struct spu *spu;
688
689         list_for_each_entry(spu, &cbe_spu_info[cbe].spus, cbe_list)
690                 if (spu_devnode(spu) == dn)
691                         return spu;
692         return NULL;
693 }
694
695 static struct spu *
696 aff_node_next_to(int cbe, struct device_node *target, struct device_node *avoid)
697 {
698         struct spu *spu;
699         const phandle *vic_handles;
700         int lenp, i;
701
702         list_for_each_entry(spu, &cbe_spu_info[cbe].spus, cbe_list) {
703                 if (spu_devnode(spu) == avoid)
704                         continue;
705                 vic_handles = get_property(spu_devnode(spu), "vicinity", &lenp);
706                 for (i=0; i < (lenp / sizeof(phandle)); i++) {
707                         if (vic_handles[i] == target->linux_phandle)
708                                 return spu;
709                 }
710         }
711         return NULL;
712 }
713
714 static void init_aff_fw_vicinity_node(int cbe)
715 {
716         struct spu *spu, *last_spu;
717         struct device_node *vic_dn, *last_spu_dn;
718         phandle avoid_ph;
719         const phandle *vic_handles;
720         const char *name;
721         int lenp, i, added, mem_aff;
722
723         last_spu = list_entry(cbe_spu_info[cbe].spus.next, struct spu, cbe_list);
724         avoid_ph = 0;
725         for (added = 1; added < cbe_spu_info[cbe].n_spus; added++) {
726                 last_spu_dn = spu_devnode(last_spu);
727                 vic_handles = get_property(last_spu_dn, "vicinity", &lenp);
728
729                 for (i = 0; i < (lenp / sizeof(phandle)); i++) {
730                         if (vic_handles[i] == avoid_ph)
731                                 continue;
732
733                         vic_dn = of_find_node_by_phandle(vic_handles[i]);
734                         if (!vic_dn)
735                                 continue;
736
737                         name = get_property(vic_dn, "name", NULL);
738                         if (strcmp(name, "spe") == 0) {
739                                 spu = aff_devnode_spu(cbe, vic_dn);
740                                 avoid_ph = last_spu_dn->linux_phandle;
741                         }
742                         else {
743                                 mem_aff = strcmp(name, "mic-tm") == 0;
744                                 spu = aff_node_next_to(cbe, vic_dn, last_spu_dn);
745                                 if (!spu)
746                                         continue;
747                                 if (mem_aff) {
748                                         last_spu->has_mem_affinity = 1;
749                                         spu->has_mem_affinity = 1;
750                                 }
751                                 avoid_ph = vic_dn->linux_phandle;
752                         }
753                         list_add_tail(&spu->aff_list, &last_spu->aff_list);
754                         last_spu = spu;
755                         break;
756                 }
757         }
758 }
759
760 static void init_aff_fw_vicinity(void)
761 {
762         int cbe;
763
764         /* sets has_mem_affinity for each spu, as long as the
765          * spu->aff_list list, linking each spu to its neighbors
766          */
767         for (cbe = 0; cbe < MAX_NUMNODES; cbe++)
768                 init_aff_fw_vicinity_node(cbe);
769 }
770
771 static int __init init_spu_base(void)
772 {
773         int i, ret = 0;
774
775         for (i = 0; i < MAX_NUMNODES; i++) {
776                 mutex_init(&cbe_spu_info[i].list_mutex);
777                 INIT_LIST_HEAD(&cbe_spu_info[i].spus);
778         }
779
780         if (!spu_management_ops)
781                 goto out;
782
783         /* create sysdev class for spus */
784         ret = sysdev_class_register(&spu_sysdev_class);
785         if (ret)
786                 goto out;
787
788         ret = spu_enumerate_spus(create_spu);
789
790         if (ret < 0) {
791                 printk(KERN_WARNING "%s: Error initializing spus\n",
792                         __FUNCTION__);
793                 goto out_unregister_sysdev_class;
794         }
795
796         if (ret > 0) {
797                 /*
798                  * We cannot put the forward declaration in
799                  * <linux/linux_logo.h> because of conflicting session type
800                  * conflicts for const and __initdata with different compiler
801                  * versions
802                  */
803                 extern const struct linux_logo logo_spe_clut224;
804
805                 fb_append_extra_logo(&logo_spe_clut224, ret);
806         }
807
808         mutex_lock(&spu_full_list_mutex);
809         xmon_register_spus(&spu_full_list);
810         crash_register_spus(&spu_full_list);
811         mutex_unlock(&spu_full_list_mutex);
812         spu_add_sysdev_attr(&attr_stat);
813
814         if (of_has_vicinity()) {
815                 init_aff_fw_vicinity();
816         } else {
817                 long root = of_get_flat_dt_root();
818                 if (of_flat_dt_is_compatible(root, "IBM,CPBW-1.0"))
819                         init_aff_QS20_harcoded();
820         }
821
822         return 0;
823
824  out_unregister_sysdev_class:
825         sysdev_class_unregister(&spu_sysdev_class);
826  out:
827         return ret;
828 }
829 module_init(init_spu_base);
830
831 MODULE_LICENSE("GPL");
832 MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");