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