Pull bugzilla-8709 into release branch
[linux-2.6] / arch / powerpc / platforms / ps3 / spu.c
1 /*
2  *  PS3 Platform spu routines.
3  *
4  *  Copyright (C) 2006 Sony Computer Entertainment Inc.
5  *  Copyright 2006 Sony Corp.
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; version 2 of the License.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/mmzone.h>
24 #include <linux/io.h>
25 #include <linux/mm.h>
26
27 #include <asm/spu.h>
28 #include <asm/spu_priv1.h>
29 #include <asm/lv1call.h>
30
31 #include "platform.h"
32
33 /* spu_management_ops */
34
35 /**
36  * enum spe_type - Type of spe to create.
37  * @spe_type_logical: Standard logical spe.
38  *
39  * For use with lv1_construct_logical_spe().  The current HV does not support
40  * any types other than those listed.
41  */
42
43 enum spe_type {
44         SPE_TYPE_LOGICAL = 0,
45 };
46
47 /**
48  * struct spe_shadow - logical spe shadow register area.
49  *
50  * Read-only shadow of spe registers.
51  */
52
53 struct spe_shadow {
54         u8 padding_0140[0x0140];
55         u64 int_status_class0_RW;       /* 0x0140 */
56         u64 int_status_class1_RW;       /* 0x0148 */
57         u64 int_status_class2_RW;       /* 0x0150 */
58         u8 padding_0158[0x0610-0x0158];
59         u64 mfc_dsisr_RW;               /* 0x0610 */
60         u8 padding_0618[0x0620-0x0618];
61         u64 mfc_dar_RW;                 /* 0x0620 */
62         u8 padding_0628[0x0800-0x0628];
63         u64 mfc_dsipr_R;                /* 0x0800 */
64         u8 padding_0808[0x0810-0x0808];
65         u64 mfc_lscrr_R;                /* 0x0810 */
66         u8 padding_0818[0x0c00-0x0818];
67         u64 mfc_cer_R;                  /* 0x0c00 */
68         u8 padding_0c08[0x0f00-0x0c08];
69         u64 spe_execution_status;       /* 0x0f00 */
70         u8 padding_0f08[0x1000-0x0f08];
71 };
72
73 /**
74  * enum spe_ex_state - Logical spe execution state.
75  * @spe_ex_state_unexecutable: Uninitialized.
76  * @spe_ex_state_executable: Enabled, not ready.
77  * @spe_ex_state_executed: Ready for use.
78  *
79  * The execution state (status) of the logical spe as reported in
80  * struct spe_shadow:spe_execution_status.
81  */
82
83 enum spe_ex_state {
84         SPE_EX_STATE_UNEXECUTABLE = 0,
85         SPE_EX_STATE_EXECUTABLE = 2,
86         SPE_EX_STATE_EXECUTED = 3,
87 };
88
89 /**
90  * struct priv1_cache - Cached values of priv1 registers.
91  * @masks[]: Array of cached spe interrupt masks, indexed by class.
92  * @sr1: Cached mfc_sr1 register.
93  * @tclass_id: Cached mfc_tclass_id register.
94  */
95
96 struct priv1_cache {
97         u64 masks[3];
98         u64 sr1;
99         u64 tclass_id;
100 };
101
102 /**
103  * struct spu_pdata - Platform state variables.
104  * @spe_id: HV spe id returned by lv1_construct_logical_spe().
105  * @resource_id: HV spe resource id returned by
106  *      ps3_repository_read_spe_resource_id().
107  * @priv2_addr: lpar address of spe priv2 area returned by
108  *      lv1_construct_logical_spe().
109  * @shadow_addr: lpar address of spe register shadow area returned by
110  *      lv1_construct_logical_spe().
111  * @shadow: Virtual (ioremap) address of spe register shadow area.
112  * @cache: Cached values of priv1 registers.
113  */
114
115 struct spu_pdata {
116         u64 spe_id;
117         u64 resource_id;
118         u64 priv2_addr;
119         u64 shadow_addr;
120         struct spe_shadow __iomem *shadow;
121         struct priv1_cache cache;
122 };
123
124 static struct spu_pdata *spu_pdata(struct spu *spu)
125 {
126         return spu->pdata;
127 }
128
129 #define dump_areas(_a, _b, _c, _d, _e) \
130         _dump_areas(_a, _b, _c, _d, _e, __func__, __LINE__)
131 static void _dump_areas(unsigned int spe_id, unsigned long priv2,
132         unsigned long problem, unsigned long ls, unsigned long shadow,
133         const char* func, int line)
134 {
135         pr_debug("%s:%d: spe_id:  %xh (%u)\n", func, line, spe_id, spe_id);
136         pr_debug("%s:%d: priv2:   %lxh\n", func, line, priv2);
137         pr_debug("%s:%d: problem: %lxh\n", func, line, problem);
138         pr_debug("%s:%d: ls:      %lxh\n", func, line, ls);
139         pr_debug("%s:%d: shadow:  %lxh\n", func, line, shadow);
140 }
141
142 static unsigned long get_vas_id(void)
143 {
144         unsigned long id;
145
146         lv1_get_logical_ppe_id(&id);
147         lv1_get_virtual_address_space_id_of_ppe(id, &id);
148
149         return id;
150 }
151
152 static int __init construct_spu(struct spu *spu)
153 {
154         int result;
155         unsigned long unused;
156
157         result = lv1_construct_logical_spe(PAGE_SHIFT, PAGE_SHIFT, PAGE_SHIFT,
158                 PAGE_SHIFT, PAGE_SHIFT, get_vas_id(), SPE_TYPE_LOGICAL,
159                 &spu_pdata(spu)->priv2_addr, &spu->problem_phys,
160                 &spu->local_store_phys, &unused,
161                 &spu_pdata(spu)->shadow_addr,
162                 &spu_pdata(spu)->spe_id);
163
164         if (result) {
165                 pr_debug("%s:%d: lv1_construct_logical_spe failed: %s\n",
166                         __func__, __LINE__, ps3_result(result));
167                 return result;
168         }
169
170         return result;
171 }
172
173 static void spu_unmap(struct spu *spu)
174 {
175         iounmap(spu->priv2);
176         iounmap(spu->problem);
177         iounmap((__force u8 __iomem *)spu->local_store);
178         iounmap(spu_pdata(spu)->shadow);
179 }
180
181 static int __init setup_areas(struct spu *spu)
182 {
183         struct table {char* name; unsigned long addr; unsigned long size;};
184
185         spu_pdata(spu)->shadow = ioremap_flags(spu_pdata(spu)->shadow_addr,
186                                                sizeof(struct spe_shadow),
187                                                pgprot_val(PAGE_READONLY) |
188                                                _PAGE_NO_CACHE);
189         if (!spu_pdata(spu)->shadow) {
190                 pr_debug("%s:%d: ioremap shadow failed\n", __func__, __LINE__);
191                 goto fail_ioremap;
192         }
193
194         spu->local_store = (__force void *)ioremap_flags(spu->local_store_phys,
195                 LS_SIZE, _PAGE_NO_CACHE);
196
197         if (!spu->local_store) {
198                 pr_debug("%s:%d: ioremap local_store failed\n",
199                         __func__, __LINE__);
200                 goto fail_ioremap;
201         }
202
203         spu->problem = ioremap(spu->problem_phys,
204                 sizeof(struct spu_problem));
205
206         if (!spu->problem) {
207                 pr_debug("%s:%d: ioremap problem failed\n", __func__, __LINE__);
208                 goto fail_ioremap;
209         }
210
211         spu->priv2 = ioremap(spu_pdata(spu)->priv2_addr,
212                 sizeof(struct spu_priv2));
213
214         if (!spu->priv2) {
215                 pr_debug("%s:%d: ioremap priv2 failed\n", __func__, __LINE__);
216                 goto fail_ioremap;
217         }
218
219         dump_areas(spu_pdata(spu)->spe_id, spu_pdata(spu)->priv2_addr,
220                 spu->problem_phys, spu->local_store_phys,
221                 spu_pdata(spu)->shadow_addr);
222         dump_areas(spu_pdata(spu)->spe_id, (unsigned long)spu->priv2,
223                 (unsigned long)spu->problem, (unsigned long)spu->local_store,
224                 (unsigned long)spu_pdata(spu)->shadow);
225
226         return 0;
227
228 fail_ioremap:
229         spu_unmap(spu);
230
231         return -ENOMEM;
232 }
233
234 static int __init setup_interrupts(struct spu *spu)
235 {
236         int result;
237
238         result = ps3_spe_irq_setup(PS3_BINDING_CPU_ANY, spu_pdata(spu)->spe_id,
239                 0, &spu->irqs[0]);
240
241         if (result)
242                 goto fail_alloc_0;
243
244         result = ps3_spe_irq_setup(PS3_BINDING_CPU_ANY, spu_pdata(spu)->spe_id,
245                 1, &spu->irqs[1]);
246
247         if (result)
248                 goto fail_alloc_1;
249
250         result = ps3_spe_irq_setup(PS3_BINDING_CPU_ANY, spu_pdata(spu)->spe_id,
251                 2, &spu->irqs[2]);
252
253         if (result)
254                 goto fail_alloc_2;
255
256         return result;
257
258 fail_alloc_2:
259         ps3_spe_irq_destroy(spu->irqs[1]);
260 fail_alloc_1:
261         ps3_spe_irq_destroy(spu->irqs[0]);
262 fail_alloc_0:
263         spu->irqs[0] = spu->irqs[1] = spu->irqs[2] = NO_IRQ;
264         return result;
265 }
266
267 static int __init enable_spu(struct spu *spu)
268 {
269         int result;
270
271         result = lv1_enable_logical_spe(spu_pdata(spu)->spe_id,
272                 spu_pdata(spu)->resource_id);
273
274         if (result) {
275                 pr_debug("%s:%d: lv1_enable_logical_spe failed: %s\n",
276                         __func__, __LINE__, ps3_result(result));
277                 goto fail_enable;
278         }
279
280         result = setup_areas(spu);
281
282         if (result)
283                 goto fail_areas;
284
285         result = setup_interrupts(spu);
286
287         if (result)
288                 goto fail_interrupts;
289
290         return 0;
291
292 fail_interrupts:
293         spu_unmap(spu);
294 fail_areas:
295         lv1_disable_logical_spe(spu_pdata(spu)->spe_id, 0);
296 fail_enable:
297         return result;
298 }
299
300 static int ps3_destroy_spu(struct spu *spu)
301 {
302         int result;
303
304         pr_debug("%s:%d spu_%d\n", __func__, __LINE__, spu->number);
305
306         result = lv1_disable_logical_spe(spu_pdata(spu)->spe_id, 0);
307         BUG_ON(result);
308
309         ps3_spe_irq_destroy(spu->irqs[2]);
310         ps3_spe_irq_destroy(spu->irqs[1]);
311         ps3_spe_irq_destroy(spu->irqs[0]);
312
313         spu->irqs[0] = spu->irqs[1] = spu->irqs[2] = NO_IRQ;
314
315         spu_unmap(spu);
316
317         result = lv1_destruct_logical_spe(spu_pdata(spu)->spe_id);
318         BUG_ON(result);
319
320         kfree(spu->pdata);
321         spu->pdata = NULL;
322
323         return 0;
324 }
325
326 static int __init ps3_create_spu(struct spu *spu, void *data)
327 {
328         int result;
329
330         pr_debug("%s:%d spu_%d\n", __func__, __LINE__, spu->number);
331
332         spu->pdata = kzalloc(sizeof(struct spu_pdata),
333                 GFP_KERNEL);
334
335         if (!spu->pdata) {
336                 result = -ENOMEM;
337                 goto fail_malloc;
338         }
339
340         spu_pdata(spu)->resource_id = (unsigned long)data;
341
342         /* Init cached reg values to HV defaults. */
343
344         spu_pdata(spu)->cache.sr1 = 0x33;
345
346         result = construct_spu(spu);
347
348         if (result)
349                 goto fail_construct;
350
351         /* For now, just go ahead and enable it. */
352
353         result = enable_spu(spu);
354
355         if (result)
356                 goto fail_enable;
357
358         /* Make sure the spu is in SPE_EX_STATE_EXECUTED. */
359
360         /* need something better here!!! */
361         while (in_be64(&spu_pdata(spu)->shadow->spe_execution_status)
362                 != SPE_EX_STATE_EXECUTED)
363                 (void)0;
364
365         return result;
366
367 fail_enable:
368 fail_construct:
369         ps3_destroy_spu(spu);
370 fail_malloc:
371         return result;
372 }
373
374 static int __init ps3_enumerate_spus(int (*fn)(void *data))
375 {
376         int result;
377         unsigned int num_resource_id;
378         unsigned int i;
379
380         result = ps3_repository_read_num_spu_resource_id(&num_resource_id);
381
382         pr_debug("%s:%d: num_resource_id %u\n", __func__, __LINE__,
383                 num_resource_id);
384
385         /*
386          * For now, just create logical spus equal to the number
387          * of physical spus reserved for the partition.
388          */
389
390         for (i = 0; i < num_resource_id; i++) {
391                 enum ps3_spu_resource_type resource_type;
392                 unsigned int resource_id;
393
394                 result = ps3_repository_read_spu_resource_id(i,
395                         &resource_type, &resource_id);
396
397                 if (result)
398                         break;
399
400                 if (resource_type == PS3_SPU_RESOURCE_TYPE_EXCLUSIVE) {
401                         result = fn((void*)(unsigned long)resource_id);
402
403                         if (result)
404                                 break;
405                 }
406         }
407
408         if (result) {
409                 printk(KERN_WARNING "%s:%d: Error initializing spus\n",
410                         __func__, __LINE__);
411                 return result;
412         }
413
414         return num_resource_id;
415 }
416
417 static int ps3_init_affinity(void)
418 {
419         return 0;
420 }
421
422 const struct spu_management_ops spu_management_ps3_ops = {
423         .enumerate_spus = ps3_enumerate_spus,
424         .create_spu = ps3_create_spu,
425         .destroy_spu = ps3_destroy_spu,
426         .init_affinity = ps3_init_affinity,
427 };
428
429 /* spu_priv1_ops */
430
431 static void int_mask_and(struct spu *spu, int class, u64 mask)
432 {
433         u64 old_mask;
434
435         /* are these serialized by caller??? */
436         old_mask = spu_int_mask_get(spu, class);
437         spu_int_mask_set(spu, class, old_mask & mask);
438 }
439
440 static void int_mask_or(struct spu *spu, int class, u64 mask)
441 {
442         u64 old_mask;
443
444         old_mask = spu_int_mask_get(spu, class);
445         spu_int_mask_set(spu, class, old_mask | mask);
446 }
447
448 static void int_mask_set(struct spu *spu, int class, u64 mask)
449 {
450         spu_pdata(spu)->cache.masks[class] = mask;
451         lv1_set_spe_interrupt_mask(spu_pdata(spu)->spe_id, class,
452                 spu_pdata(spu)->cache.masks[class]);
453 }
454
455 static u64 int_mask_get(struct spu *spu, int class)
456 {
457         return spu_pdata(spu)->cache.masks[class];
458 }
459
460 static void int_stat_clear(struct spu *spu, int class, u64 stat)
461 {
462         /* Note that MFC_DSISR will be cleared when class1[MF] is set. */
463
464         lv1_clear_spe_interrupt_status(spu_pdata(spu)->spe_id, class,
465                 stat, 0);
466 }
467
468 static u64 int_stat_get(struct spu *spu, int class)
469 {
470         u64 stat;
471
472         lv1_get_spe_interrupt_status(spu_pdata(spu)->spe_id, class, &stat);
473         return stat;
474 }
475
476 static void cpu_affinity_set(struct spu *spu, int cpu)
477 {
478         /* No support. */
479 }
480
481 static u64 mfc_dar_get(struct spu *spu)
482 {
483         return in_be64(&spu_pdata(spu)->shadow->mfc_dar_RW);
484 }
485
486 static void mfc_dsisr_set(struct spu *spu, u64 dsisr)
487 {
488         /* Nothing to do, cleared in int_stat_clear(). */
489 }
490
491 static u64 mfc_dsisr_get(struct spu *spu)
492 {
493         return in_be64(&spu_pdata(spu)->shadow->mfc_dsisr_RW);
494 }
495
496 static void mfc_sdr_setup(struct spu *spu)
497 {
498         /* Nothing to do. */
499 }
500
501 static void mfc_sr1_set(struct spu *spu, u64 sr1)
502 {
503         /* Check bits allowed by HV. */
504
505         static const u64 allowed = ~(MFC_STATE1_LOCAL_STORAGE_DECODE_MASK
506                 | MFC_STATE1_PROBLEM_STATE_MASK);
507
508         sr1 |= MFC_STATE1_MASTER_RUN_CONTROL_MASK;
509
510         BUG_ON((sr1 & allowed) != (spu_pdata(spu)->cache.sr1 & allowed));
511
512         spu_pdata(spu)->cache.sr1 = sr1;
513         lv1_set_spe_privilege_state_area_1_register(
514                 spu_pdata(spu)->spe_id,
515                 offsetof(struct spu_priv1, mfc_sr1_RW),
516                 spu_pdata(spu)->cache.sr1);
517 }
518
519 static u64 mfc_sr1_get(struct spu *spu)
520 {
521         return spu_pdata(spu)->cache.sr1;
522 }
523
524 static void mfc_tclass_id_set(struct spu *spu, u64 tclass_id)
525 {
526         spu_pdata(spu)->cache.tclass_id = tclass_id;
527         lv1_set_spe_privilege_state_area_1_register(
528                 spu_pdata(spu)->spe_id,
529                 offsetof(struct spu_priv1, mfc_tclass_id_RW),
530                 spu_pdata(spu)->cache.tclass_id);
531 }
532
533 static u64 mfc_tclass_id_get(struct spu *spu)
534 {
535         return spu_pdata(spu)->cache.tclass_id;
536 }
537
538 static void tlb_invalidate(struct spu *spu)
539 {
540         /* Nothing to do. */
541 }
542
543 static void resource_allocation_groupID_set(struct spu *spu, u64 id)
544 {
545         /* No support. */
546 }
547
548 static u64 resource_allocation_groupID_get(struct spu *spu)
549 {
550         return 0; /* No support. */
551 }
552
553 static void resource_allocation_enable_set(struct spu *spu, u64 enable)
554 {
555         /* No support. */
556 }
557
558 static u64 resource_allocation_enable_get(struct spu *spu)
559 {
560         return 0; /* No support. */
561 }
562
563 const struct spu_priv1_ops spu_priv1_ps3_ops = {
564         .int_mask_and = int_mask_and,
565         .int_mask_or = int_mask_or,
566         .int_mask_set = int_mask_set,
567         .int_mask_get = int_mask_get,
568         .int_stat_clear = int_stat_clear,
569         .int_stat_get = int_stat_get,
570         .cpu_affinity_set = cpu_affinity_set,
571         .mfc_dar_get = mfc_dar_get,
572         .mfc_dsisr_set = mfc_dsisr_set,
573         .mfc_dsisr_get = mfc_dsisr_get,
574         .mfc_sdr_setup = mfc_sdr_setup,
575         .mfc_sr1_set = mfc_sr1_set,
576         .mfc_sr1_get = mfc_sr1_get,
577         .mfc_tclass_id_set = mfc_tclass_id_set,
578         .mfc_tclass_id_get = mfc_tclass_id_get,
579         .tlb_invalidate = tlb_invalidate,
580         .resource_allocation_groupID_set = resource_allocation_groupID_set,
581         .resource_allocation_groupID_get = resource_allocation_groupID_get,
582         .resource_allocation_enable_set = resource_allocation_enable_set,
583         .resource_allocation_enable_get = resource_allocation_enable_get,
584 };
585
586 void ps3_spu_set_platform(void)
587 {
588         spu_priv1_ops = &spu_priv1_ps3_ops;
589         spu_management_ops = &spu_management_ps3_ops;
590 }