of: unify phandle name in struct device_node
[linux-2.6.git] / arch / powerpc / platforms / cell / spu_manage.c
1 /*
2  * spu management operations for of based platforms
3  *
4  * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
5  * Copyright 2006 Sony Corp.
6  * (C) Copyright 2007 TOSHIBA CORPORATION
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; version 2 of the License.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with this program; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21
22 #include <linux/interrupt.h>
23 #include <linux/list.h>
24 #include <linux/module.h>
25 #include <linux/ptrace.h>
26 #include <linux/slab.h>
27 #include <linux/wait.h>
28 #include <linux/mm.h>
29 #include <linux/io.h>
30 #include <linux/mutex.h>
31 #include <linux/device.h>
32
33 #include <asm/spu.h>
34 #include <asm/spu_priv1.h>
35 #include <asm/firmware.h>
36 #include <asm/prom.h>
37
38 #include "spufs/spufs.h"
39 #include "interrupt.h"
40
41 struct device_node *spu_devnode(struct spu *spu)
42 {
43         return spu->devnode;
44 }
45
46 EXPORT_SYMBOL_GPL(spu_devnode);
47
48 static u64 __init find_spu_unit_number(struct device_node *spe)
49 {
50         const unsigned int *prop;
51         int proplen;
52
53         /* new device trees should provide the physical-id attribute */
54         prop = of_get_property(spe, "physical-id", &proplen);
55         if (proplen == 4)
56                 return (u64)*prop;
57
58         /* celleb device tree provides the unit-id */
59         prop = of_get_property(spe, "unit-id", &proplen);
60         if (proplen == 4)
61                 return (u64)*prop;
62
63         /* legacy device trees provide the id in the reg attribute */
64         prop = of_get_property(spe, "reg", &proplen);
65         if (proplen == 4)
66                 return (u64)*prop;
67
68         return 0;
69 }
70
71 static void spu_unmap(struct spu *spu)
72 {
73         if (!firmware_has_feature(FW_FEATURE_LPAR))
74                 iounmap(spu->priv1);
75         iounmap(spu->priv2);
76         iounmap(spu->problem);
77         iounmap((__force u8 __iomem *)spu->local_store);
78 }
79
80 static int __init spu_map_interrupts_old(struct spu *spu,
81         struct device_node *np)
82 {
83         unsigned int isrc;
84         const u32 *tmp;
85         int nid;
86
87         /* Get the interrupt source unit from the device-tree */
88         tmp = of_get_property(np, "isrc", NULL);
89         if (!tmp)
90                 return -ENODEV;
91         isrc = tmp[0];
92
93         tmp = of_get_property(np->parent->parent, "node-id", NULL);
94         if (!tmp) {
95                 printk(KERN_WARNING "%s: can't find node-id\n", __func__);
96                 nid = spu->node;
97         } else
98                 nid = tmp[0];
99
100         /* Add the node number */
101         isrc |= nid << IIC_IRQ_NODE_SHIFT;
102
103         /* Now map interrupts of all 3 classes */
104         spu->irqs[0] = irq_create_mapping(NULL, IIC_IRQ_CLASS_0 | isrc);
105         spu->irqs[1] = irq_create_mapping(NULL, IIC_IRQ_CLASS_1 | isrc);
106         spu->irqs[2] = irq_create_mapping(NULL, IIC_IRQ_CLASS_2 | isrc);
107
108         /* Right now, we only fail if class 2 failed */
109         return spu->irqs[2] == NO_IRQ ? -EINVAL : 0;
110 }
111
112 static void __iomem * __init spu_map_prop_old(struct spu *spu,
113                                               struct device_node *n,
114                                               const char *name)
115 {
116         const struct address_prop {
117                 unsigned long address;
118                 unsigned int len;
119         } __attribute__((packed)) *prop;
120         int proplen;
121
122         prop = of_get_property(n, name, &proplen);
123         if (prop == NULL || proplen != sizeof (struct address_prop))
124                 return NULL;
125
126         return ioremap(prop->address, prop->len);
127 }
128
129 static int __init spu_map_device_old(struct spu *spu)
130 {
131         struct device_node *node = spu->devnode;
132         const char *prop;
133         int ret;
134
135         ret = -ENODEV;
136         spu->name = of_get_property(node, "name", NULL);
137         if (!spu->name)
138                 goto out;
139
140         prop = of_get_property(node, "local-store", NULL);
141         if (!prop)
142                 goto out;
143         spu->local_store_phys = *(unsigned long *)prop;
144
145         /* we use local store as ram, not io memory */
146         spu->local_store = (void __force *)
147                 spu_map_prop_old(spu, node, "local-store");
148         if (!spu->local_store)
149                 goto out;
150
151         prop = of_get_property(node, "problem", NULL);
152         if (!prop)
153                 goto out_unmap;
154         spu->problem_phys = *(unsigned long *)prop;
155
156         spu->problem = spu_map_prop_old(spu, node, "problem");
157         if (!spu->problem)
158                 goto out_unmap;
159
160         spu->priv2 = spu_map_prop_old(spu, node, "priv2");
161         if (!spu->priv2)
162                 goto out_unmap;
163
164         if (!firmware_has_feature(FW_FEATURE_LPAR)) {
165                 spu->priv1 = spu_map_prop_old(spu, node, "priv1");
166                 if (!spu->priv1)
167                         goto out_unmap;
168         }
169
170         ret = 0;
171         goto out;
172
173 out_unmap:
174         spu_unmap(spu);
175 out:
176         return ret;
177 }
178
179 static int __init spu_map_interrupts(struct spu *spu, struct device_node *np)
180 {
181         struct of_irq oirq;
182         int ret;
183         int i;
184
185         for (i=0; i < 3; i++) {
186                 ret = of_irq_map_one(np, i, &oirq);
187                 if (ret) {
188                         pr_debug("spu_new: failed to get irq %d\n", i);
189                         goto err;
190                 }
191                 ret = -EINVAL;
192                 pr_debug("  irq %d no 0x%x on %s\n", i, oirq.specifier[0],
193                          oirq.controller->full_name);
194                 spu->irqs[i] = irq_create_of_mapping(oirq.controller,
195                                         oirq.specifier, oirq.size);
196                 if (spu->irqs[i] == NO_IRQ) {
197                         pr_debug("spu_new: failed to map it !\n");
198                         goto err;
199                 }
200         }
201         return 0;
202
203 err:
204         pr_debug("failed to map irq %x for spu %s\n", *oirq.specifier,
205                 spu->name);
206         for (; i >= 0; i--) {
207                 if (spu->irqs[i] != NO_IRQ)
208                         irq_dispose_mapping(spu->irqs[i]);
209         }
210         return ret;
211 }
212
213 static int spu_map_resource(struct spu *spu, int nr,
214                             void __iomem** virt, unsigned long *phys)
215 {
216         struct device_node *np = spu->devnode;
217         struct resource resource = { };
218         unsigned long len;
219         int ret;
220
221         ret = of_address_to_resource(np, nr, &resource);
222         if (ret)
223                 return ret;
224         if (phys)
225                 *phys = resource.start;
226         len = resource.end - resource.start + 1;
227         *virt = ioremap(resource.start, len);
228         if (!*virt)
229                 return -EINVAL;
230         return 0;
231 }
232
233 static int __init spu_map_device(struct spu *spu)
234 {
235         struct device_node *np = spu->devnode;
236         int ret = -ENODEV;
237
238         spu->name = of_get_property(np, "name", NULL);
239         if (!spu->name)
240                 goto out;
241
242         ret = spu_map_resource(spu, 0, (void __iomem**)&spu->local_store,
243                                &spu->local_store_phys);
244         if (ret) {
245                 pr_debug("spu_new: failed to map %s resource 0\n",
246                          np->full_name);
247                 goto out;
248         }
249         ret = spu_map_resource(spu, 1, (void __iomem**)&spu->problem,
250                                &spu->problem_phys);
251         if (ret) {
252                 pr_debug("spu_new: failed to map %s resource 1\n",
253                          np->full_name);
254                 goto out_unmap;
255         }
256         ret = spu_map_resource(spu, 2, (void __iomem**)&spu->priv2, NULL);
257         if (ret) {
258                 pr_debug("spu_new: failed to map %s resource 2\n",
259                          np->full_name);
260                 goto out_unmap;
261         }
262         if (!firmware_has_feature(FW_FEATURE_LPAR))
263                 ret = spu_map_resource(spu, 3,
264                                (void __iomem**)&spu->priv1, NULL);
265         if (ret) {
266                 pr_debug("spu_new: failed to map %s resource 3\n",
267                          np->full_name);
268                 goto out_unmap;
269         }
270         pr_debug("spu_new: %s maps:\n", np->full_name);
271         pr_debug("  local store   : 0x%016lx -> 0x%p\n",
272                  spu->local_store_phys, spu->local_store);
273         pr_debug("  problem state : 0x%016lx -> 0x%p\n",
274                  spu->problem_phys, spu->problem);
275         pr_debug("  priv2         :                       0x%p\n", spu->priv2);
276         pr_debug("  priv1         :                       0x%p\n", spu->priv1);
277
278         return 0;
279
280 out_unmap:
281         spu_unmap(spu);
282 out:
283         pr_debug("failed to map spe %s: %d\n", spu->name, ret);
284         return ret;
285 }
286
287 static int __init of_enumerate_spus(int (*fn)(void *data))
288 {
289         int ret;
290         struct device_node *node;
291         unsigned int n = 0;
292
293         ret = -ENODEV;
294         for (node = of_find_node_by_type(NULL, "spe");
295                         node; node = of_find_node_by_type(node, "spe")) {
296                 ret = fn(node);
297                 if (ret) {
298                         printk(KERN_WARNING "%s: Error initializing %s\n",
299                                 __func__, node->name);
300                         break;
301                 }
302                 n++;
303         }
304         return ret ? ret : n;
305 }
306
307 static int __init of_create_spu(struct spu *spu, void *data)
308 {
309         int ret;
310         struct device_node *spe = (struct device_node *)data;
311         static int legacy_map = 0, legacy_irq = 0;
312
313         spu->devnode = of_node_get(spe);
314         spu->spe_id = find_spu_unit_number(spe);
315
316         spu->node = of_node_to_nid(spe);
317         if (spu->node >= MAX_NUMNODES) {
318                 printk(KERN_WARNING "SPE %s on node %d ignored,"
319                        " node number too big\n", spe->full_name, spu->node);
320                 printk(KERN_WARNING "Check if CONFIG_NUMA is enabled.\n");
321                 ret = -ENODEV;
322                 goto out;
323         }
324
325         ret = spu_map_device(spu);
326         if (ret) {
327                 if (!legacy_map) {
328                         legacy_map = 1;
329                         printk(KERN_WARNING "%s: Legacy device tree found, "
330                                 "trying to map old style\n", __func__);
331                 }
332                 ret = spu_map_device_old(spu);
333                 if (ret) {
334                         printk(KERN_ERR "Unable to map %s\n",
335                                 spu->name);
336                         goto out;
337                 }
338         }
339
340         ret = spu_map_interrupts(spu, spe);
341         if (ret) {
342                 if (!legacy_irq) {
343                         legacy_irq = 1;
344                         printk(KERN_WARNING "%s: Legacy device tree found, "
345                                 "trying old style irq\n", __func__);
346                 }
347                 ret = spu_map_interrupts_old(spu, spe);
348                 if (ret) {
349                         printk(KERN_ERR "%s: could not map interrupts\n",
350                                 spu->name);
351                         goto out_unmap;
352                 }
353         }
354
355         pr_debug("Using SPE %s %p %p %p %p %d\n", spu->name,
356                 spu->local_store, spu->problem, spu->priv1,
357                 spu->priv2, spu->number);
358         goto out;
359
360 out_unmap:
361         spu_unmap(spu);
362 out:
363         return ret;
364 }
365
366 static int of_destroy_spu(struct spu *spu)
367 {
368         spu_unmap(spu);
369         of_node_put(spu->devnode);
370         return 0;
371 }
372
373 static void enable_spu_by_master_run(struct spu_context *ctx)
374 {
375         ctx->ops->master_start(ctx);
376 }
377
378 static void disable_spu_by_master_run(struct spu_context *ctx)
379 {
380         ctx->ops->master_stop(ctx);
381 }
382
383 /* Hardcoded affinity idxs for qs20 */
384 #define QS20_SPES_PER_BE 8
385 static int qs20_reg_idxs[QS20_SPES_PER_BE] =   { 0, 2, 4, 6, 7, 5, 3, 1 };
386 static int qs20_reg_memory[QS20_SPES_PER_BE] = { 1, 1, 0, 0, 0, 0, 0, 0 };
387
388 static struct spu *spu_lookup_reg(int node, u32 reg)
389 {
390         struct spu *spu;
391         const u32 *spu_reg;
392
393         list_for_each_entry(spu, &cbe_spu_info[node].spus, cbe_list) {
394                 spu_reg = of_get_property(spu_devnode(spu), "reg", NULL);
395                 if (*spu_reg == reg)
396                         return spu;
397         }
398         return NULL;
399 }
400
401 static void init_affinity_qs20_harcoded(void)
402 {
403         int node, i;
404         struct spu *last_spu, *spu;
405         u32 reg;
406
407         for (node = 0; node < MAX_NUMNODES; node++) {
408                 last_spu = NULL;
409                 for (i = 0; i < QS20_SPES_PER_BE; i++) {
410                         reg = qs20_reg_idxs[i];
411                         spu = spu_lookup_reg(node, reg);
412                         if (!spu)
413                                 continue;
414                         spu->has_mem_affinity = qs20_reg_memory[reg];
415                         if (last_spu)
416                                 list_add_tail(&spu->aff_list,
417                                                 &last_spu->aff_list);
418                         last_spu = spu;
419                 }
420         }
421 }
422
423 static int of_has_vicinity(void)
424 {
425         struct device_node *dn;
426
427         for_each_node_by_type(dn, "spe") {
428                 if (of_find_property(dn, "vicinity", NULL))  {
429                         of_node_put(dn);
430                         return 1;
431                 }
432         }
433         return 0;
434 }
435
436 static struct spu *devnode_spu(int cbe, struct device_node *dn)
437 {
438         struct spu *spu;
439
440         list_for_each_entry(spu, &cbe_spu_info[cbe].spus, cbe_list)
441                 if (spu_devnode(spu) == dn)
442                         return spu;
443         return NULL;
444 }
445
446 static struct spu *
447 neighbour_spu(int cbe, struct device_node *target, struct device_node *avoid)
448 {
449         struct spu *spu;
450         struct device_node *spu_dn;
451         const phandle *vic_handles;
452         int lenp, i;
453
454         list_for_each_entry(spu, &cbe_spu_info[cbe].spus, cbe_list) {
455                 spu_dn = spu_devnode(spu);
456                 if (spu_dn == avoid)
457                         continue;
458                 vic_handles = of_get_property(spu_dn, "vicinity", &lenp);
459                 for (i=0; i < (lenp / sizeof(phandle)); i++) {
460                         if (vic_handles[i] == target->phandle)
461                                 return spu;
462                 }
463         }
464         return NULL;
465 }
466
467 static void init_affinity_node(int cbe)
468 {
469         struct spu *spu, *last_spu;
470         struct device_node *vic_dn, *last_spu_dn;
471         phandle avoid_ph;
472         const phandle *vic_handles;
473         const char *name;
474         int lenp, i, added;
475
476         last_spu = list_first_entry(&cbe_spu_info[cbe].spus, struct spu,
477                                                                 cbe_list);
478         avoid_ph = 0;
479         for (added = 1; added < cbe_spu_info[cbe].n_spus; added++) {
480                 last_spu_dn = spu_devnode(last_spu);
481                 vic_handles = of_get_property(last_spu_dn, "vicinity", &lenp);
482
483                 /*
484                  * Walk through each phandle in vicinity property of the spu
485                  * (tipically two vicinity phandles per spe node)
486                  */
487                 for (i = 0; i < (lenp / sizeof(phandle)); i++) {
488                         if (vic_handles[i] == avoid_ph)
489                                 continue;
490
491                         vic_dn = of_find_node_by_phandle(vic_handles[i]);
492                         if (!vic_dn)
493                                 continue;
494
495                         /* a neighbour might be spe, mic-tm, or bif0 */
496                         name = of_get_property(vic_dn, "name", NULL);
497                         if (!name)
498                                 continue;
499
500                         if (strcmp(name, "spe") == 0) {
501                                 spu = devnode_spu(cbe, vic_dn);
502                                 avoid_ph = last_spu_dn->phandle;
503                         } else {
504                                 /*
505                                  * "mic-tm" and "bif0" nodes do not have
506                                  * vicinity property. So we need to find the
507                                  * spe which has vic_dn as neighbour, but
508                                  * skipping the one we came from (last_spu_dn)
509                                  */
510                                 spu = neighbour_spu(cbe, vic_dn, last_spu_dn);
511                                 if (!spu)
512                                         continue;
513                                 if (!strcmp(name, "mic-tm")) {
514                                         last_spu->has_mem_affinity = 1;
515                                         spu->has_mem_affinity = 1;
516                                 }
517                                 avoid_ph = vic_dn->phandle;
518                         }
519
520                         list_add_tail(&spu->aff_list, &last_spu->aff_list);
521                         last_spu = spu;
522                         break;
523                 }
524         }
525 }
526
527 static void init_affinity_fw(void)
528 {
529         int cbe;
530
531         for (cbe = 0; cbe < MAX_NUMNODES; cbe++)
532                 init_affinity_node(cbe);
533 }
534
535 static int __init init_affinity(void)
536 {
537         if (of_has_vicinity()) {
538                 init_affinity_fw();
539         } else {
540                 long root = of_get_flat_dt_root();
541                 if (of_flat_dt_is_compatible(root, "IBM,CPBW-1.0"))
542                         init_affinity_qs20_harcoded();
543                 else
544                         printk("No affinity configuration found\n");
545         }
546
547         return 0;
548 }
549
550 const struct spu_management_ops spu_management_of_ops = {
551         .enumerate_spus = of_enumerate_spus,
552         .create_spu = of_create_spu,
553         .destroy_spu = of_destroy_spu,
554         .enable_spu = enable_spu_by_master_run,
555         .disable_spu = disable_spu_by_master_run,
556         .init_affinity = init_affinity,
557 };