3bd8df8af70b43cd25a4c046c2dd0a15f542eab4
[linux-2.6.git] / arch / powerpc / platforms / pseries / dlpar.c
1 /*
2  * Support for dynamic reconfiguration for PCI, Memory, and CPU
3  * Hotplug and Dynamic Logical Partitioning on RPA platforms.
4  *
5  * Copyright (C) 2009 Nathan Fontenot
6  * Copyright (C) 2009 IBM Corporation
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License version
10  * 2 as published by the Free Software Foundation.
11  */
12
13 #include <linux/kernel.h>
14 #include <linux/kref.h>
15 #include <linux/notifier.h>
16 #include <linux/proc_fs.h>
17 #include <linux/spinlock.h>
18 #include <linux/cpu.h>
19 #include "offline_states.h"
20
21 #include <asm/prom.h>
22 #include <asm/machdep.h>
23 #include <asm/uaccess.h>
24 #include <asm/rtas.h>
25 #include <asm/pSeries_reconfig.h>
26
27 struct cc_workarea {
28         u32     drc_index;
29         u32     zero;
30         u32     name_offset;
31         u32     prop_length;
32         u32     prop_offset;
33 };
34
35 static void dlpar_free_cc_property(struct property *prop)
36 {
37         kfree(prop->name);
38         kfree(prop->value);
39         kfree(prop);
40 }
41
42 static struct property *dlpar_parse_cc_property(struct cc_workarea *ccwa)
43 {
44         struct property *prop;
45         char *name;
46         char *value;
47
48         prop = kzalloc(sizeof(*prop), GFP_KERNEL);
49         if (!prop)
50                 return NULL;
51
52         name = (char *)ccwa + ccwa->name_offset;
53         prop->name = kstrdup(name, GFP_KERNEL);
54
55         prop->length = ccwa->prop_length;
56         value = (char *)ccwa + ccwa->prop_offset;
57         prop->value = kzalloc(prop->length, GFP_KERNEL);
58         if (!prop->value) {
59                 dlpar_free_cc_property(prop);
60                 return NULL;
61         }
62
63         memcpy(prop->value, value, prop->length);
64         return prop;
65 }
66
67 static struct device_node *dlpar_parse_cc_node(struct cc_workarea *ccwa)
68 {
69         struct device_node *dn;
70         char *name;
71
72         dn = kzalloc(sizeof(*dn), GFP_KERNEL);
73         if (!dn)
74                 return NULL;
75
76         /* The configure connector reported name does not contain a
77          * preceeding '/', so we allocate a buffer large enough to
78          * prepend this to the full_name.
79          */
80         name = (char *)ccwa + ccwa->name_offset;
81         dn->full_name = kmalloc(strlen(name) + 2, GFP_KERNEL);
82         if (!dn->full_name) {
83                 kfree(dn);
84                 return NULL;
85         }
86
87         sprintf(dn->full_name, "/%s", name);
88         return dn;
89 }
90
91 static void dlpar_free_one_cc_node(struct device_node *dn)
92 {
93         struct property *prop;
94
95         while (dn->properties) {
96                 prop = dn->properties;
97                 dn->properties = prop->next;
98                 dlpar_free_cc_property(prop);
99         }
100
101         kfree(dn->full_name);
102         kfree(dn);
103 }
104
105 static void dlpar_free_cc_nodes(struct device_node *dn)
106 {
107         if (dn->child)
108                 dlpar_free_cc_nodes(dn->child);
109
110         if (dn->sibling)
111                 dlpar_free_cc_nodes(dn->sibling);
112
113         dlpar_free_one_cc_node(dn);
114 }
115
116 #define NEXT_SIBLING    1
117 #define NEXT_CHILD      2
118 #define NEXT_PROPERTY   3
119 #define PREV_PARENT     4
120 #define MORE_MEMORY     5
121 #define CALL_AGAIN      -2
122 #define ERR_CFG_USE     -9003
123
124 struct device_node *dlpar_configure_connector(u32 drc_index)
125 {
126         struct device_node *dn;
127         struct device_node *first_dn = NULL;
128         struct device_node *last_dn = NULL;
129         struct property *property;
130         struct property *last_property = NULL;
131         struct cc_workarea *ccwa;
132         int cc_token;
133         int rc;
134
135         cc_token = rtas_token("ibm,configure-connector");
136         if (cc_token == RTAS_UNKNOWN_SERVICE)
137                 return NULL;
138
139         spin_lock(&rtas_data_buf_lock);
140         ccwa = (struct cc_workarea *)&rtas_data_buf[0];
141         ccwa->drc_index = drc_index;
142         ccwa->zero = 0;
143
144         rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL);
145         while (rc) {
146                 switch (rc) {
147                 case NEXT_SIBLING:
148                         dn = dlpar_parse_cc_node(ccwa);
149                         if (!dn)
150                                 goto cc_error;
151
152                         dn->parent = last_dn->parent;
153                         last_dn->sibling = dn;
154                         last_dn = dn;
155                         break;
156
157                 case NEXT_CHILD:
158                         dn = dlpar_parse_cc_node(ccwa);
159                         if (!dn)
160                                 goto cc_error;
161
162                         if (!first_dn)
163                                 first_dn = dn;
164                         else {
165                                 dn->parent = last_dn;
166                                 if (last_dn)
167                                         last_dn->child = dn;
168                         }
169
170                         last_dn = dn;
171                         break;
172
173                 case NEXT_PROPERTY:
174                         property = dlpar_parse_cc_property(ccwa);
175                         if (!property)
176                                 goto cc_error;
177
178                         if (!last_dn->properties)
179                                 last_dn->properties = property;
180                         else
181                                 last_property->next = property;
182
183                         last_property = property;
184                         break;
185
186                 case PREV_PARENT:
187                         last_dn = last_dn->parent;
188                         break;
189
190                 case CALL_AGAIN:
191                         break;
192
193                 case MORE_MEMORY:
194                 case ERR_CFG_USE:
195                 default:
196                         printk(KERN_ERR "Unexpected Error (%d) "
197                                "returned from configure-connector\n", rc);
198                         goto cc_error;
199                 }
200
201                 rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL);
202         }
203
204         spin_unlock(&rtas_data_buf_lock);
205         return first_dn;
206
207 cc_error:
208         if (first_dn)
209                 dlpar_free_cc_nodes(first_dn);
210         spin_unlock(&rtas_data_buf_lock);
211         return NULL;
212 }
213
214 static struct device_node *derive_parent(const char *path)
215 {
216         struct device_node *parent;
217         char *last_slash;
218
219         last_slash = strrchr(path, '/');
220         if (last_slash == path) {
221                 parent = of_find_node_by_path("/");
222         } else {
223                 char *parent_path;
224                 int parent_path_len = last_slash - path + 1;
225                 parent_path = kmalloc(parent_path_len, GFP_KERNEL);
226                 if (!parent_path)
227                         return NULL;
228
229                 strlcpy(parent_path, path, parent_path_len);
230                 parent = of_find_node_by_path(parent_path);
231                 kfree(parent_path);
232         }
233
234         return parent;
235 }
236
237 int dlpar_attach_node(struct device_node *dn)
238 {
239 #ifdef CONFIG_PROC_DEVICETREE
240         struct proc_dir_entry *ent;
241 #endif
242         int rc;
243
244         of_node_set_flag(dn, OF_DYNAMIC);
245         kref_init(&dn->kref);
246         dn->parent = derive_parent(dn->full_name);
247         if (!dn->parent)
248                 return -ENOMEM;
249
250         rc = blocking_notifier_call_chain(&pSeries_reconfig_chain,
251                                           PSERIES_RECONFIG_ADD, dn);
252         if (rc == NOTIFY_BAD) {
253                 printk(KERN_ERR "Failed to add device node %s\n",
254                        dn->full_name);
255                 return -ENOMEM; /* For now, safe to assume kmalloc failure */
256         }
257
258         of_attach_node(dn);
259
260 #ifdef CONFIG_PROC_DEVICETREE
261         ent = proc_mkdir(strrchr(dn->full_name, '/') + 1, dn->parent->pde);
262         if (ent)
263                 proc_device_tree_add_node(dn, ent);
264 #endif
265
266         of_node_put(dn->parent);
267         return 0;
268 }
269
270 int dlpar_detach_node(struct device_node *dn)
271 {
272 #ifdef CONFIG_PROC_DEVICETREE
273         struct device_node *parent = dn->parent;
274         struct property *prop = dn->properties;
275
276         while (prop) {
277                 remove_proc_entry(prop->name, dn->pde);
278                 prop = prop->next;
279         }
280
281         if (dn->pde)
282                 remove_proc_entry(dn->pde->name, parent->pde);
283 #endif
284
285         blocking_notifier_call_chain(&pSeries_reconfig_chain,
286                             PSERIES_RECONFIG_REMOVE, dn);
287         of_detach_node(dn);
288         of_node_put(dn); /* Must decrement the refcount */
289
290         return 0;
291 }
292
293 #define DR_ENTITY_SENSE         9003
294 #define DR_ENTITY_PRESENT       1
295 #define DR_ENTITY_UNUSABLE      2
296 #define ALLOCATION_STATE        9003
297 #define ALLOC_UNUSABLE          0
298 #define ALLOC_USABLE            1
299 #define ISOLATION_STATE         9001
300 #define ISOLATE                 0
301 #define UNISOLATE               1
302
303 int dlpar_acquire_drc(u32 drc_index)
304 {
305         int dr_status, rc;
306
307         rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
308                        DR_ENTITY_SENSE, drc_index);
309         if (rc || dr_status != DR_ENTITY_UNUSABLE)
310                 return -1;
311
312         rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE);
313         if (rc)
314                 return rc;
315
316         rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
317         if (rc) {
318                 rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
319                 return rc;
320         }
321
322         return 0;
323 }
324
325 int dlpar_release_drc(u32 drc_index)
326 {
327         int dr_status, rc;
328
329         rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
330                        DR_ENTITY_SENSE, drc_index);
331         if (rc || dr_status != DR_ENTITY_PRESENT)
332                 return -1;
333
334         rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE);
335         if (rc)
336                 return rc;
337
338         rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
339         if (rc) {
340                 rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
341                 return rc;
342         }
343
344         return 0;
345 }
346
347 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
348
349 static DEFINE_MUTEX(pseries_cpu_hotplug_mutex);
350
351 void cpu_hotplug_driver_lock(void)
352 __acquires(pseries_cpu_hotplug_mutex)
353 {
354         mutex_lock(&pseries_cpu_hotplug_mutex);
355 }
356
357 void cpu_hotplug_driver_unlock(void)
358 __releases(pseries_cpu_hotplug_mutex)
359 {
360         mutex_unlock(&pseries_cpu_hotplug_mutex);
361 }
362
363 static int dlpar_online_cpu(struct device_node *dn)
364 {
365         int rc = 0;
366         unsigned int cpu;
367         int len, nthreads, i;
368         const u32 *intserv;
369
370         intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
371         if (!intserv)
372                 return -EINVAL;
373
374         nthreads = len / sizeof(u32);
375
376         cpu_maps_update_begin();
377         for (i = 0; i < nthreads; i++) {
378                 for_each_present_cpu(cpu) {
379                         if (get_hard_smp_processor_id(cpu) != intserv[i])
380                                 continue;
381                         BUG_ON(get_cpu_current_state(cpu)
382                                         != CPU_STATE_OFFLINE);
383                         cpu_maps_update_done();
384                         rc = cpu_up(cpu);
385                         if (rc)
386                                 goto out;
387                         cpu_maps_update_begin();
388
389                         break;
390                 }
391                 if (cpu == num_possible_cpus())
392                         printk(KERN_WARNING "Could not find cpu to online "
393                                "with physical id 0x%x\n", intserv[i]);
394         }
395         cpu_maps_update_done();
396
397 out:
398         return rc;
399
400 }
401
402 static ssize_t dlpar_cpu_probe(const char *buf, size_t count)
403 {
404         struct device_node *dn;
405         unsigned long drc_index;
406         char *cpu_name;
407         int rc;
408
409         cpu_hotplug_driver_lock();
410         rc = strict_strtoul(buf, 0, &drc_index);
411         if (rc) {
412                 rc = -EINVAL;
413                 goto out;
414         }
415
416         dn = dlpar_configure_connector(drc_index);
417         if (!dn) {
418                 rc = -EINVAL;
419                 goto out;
420         }
421
422         /* configure-connector reports cpus as living in the base
423          * directory of the device tree.  CPUs actually live in the
424          * cpus directory so we need to fixup the full_name.
425          */
426         cpu_name = kzalloc(strlen(dn->full_name) + strlen("/cpus") + 1,
427                            GFP_KERNEL);
428         if (!cpu_name) {
429                 dlpar_free_cc_nodes(dn);
430                 rc = -ENOMEM;
431                 goto out;
432         }
433
434         sprintf(cpu_name, "/cpus%s", dn->full_name);
435         kfree(dn->full_name);
436         dn->full_name = cpu_name;
437
438         rc = dlpar_acquire_drc(drc_index);
439         if (rc) {
440                 dlpar_free_cc_nodes(dn);
441                 rc = -EINVAL;
442                 goto out;
443         }
444
445         rc = dlpar_attach_node(dn);
446         if (rc) {
447                 dlpar_release_drc(drc_index);
448                 dlpar_free_cc_nodes(dn);
449         }
450
451         rc = dlpar_online_cpu(dn);
452 out:
453         cpu_hotplug_driver_unlock();
454
455         return rc ? rc : count;
456 }
457
458 static int dlpar_offline_cpu(struct device_node *dn)
459 {
460         int rc = 0;
461         unsigned int cpu;
462         int len, nthreads, i;
463         const u32 *intserv;
464
465         intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
466         if (!intserv)
467                 return -EINVAL;
468
469         nthreads = len / sizeof(u32);
470
471         cpu_maps_update_begin();
472         for (i = 0; i < nthreads; i++) {
473                 for_each_present_cpu(cpu) {
474                         if (get_hard_smp_processor_id(cpu) != intserv[i])
475                                 continue;
476
477                         if (get_cpu_current_state(cpu) == CPU_STATE_OFFLINE)
478                                 break;
479
480                         if (get_cpu_current_state(cpu) == CPU_STATE_ONLINE) {
481                                 cpu_maps_update_done();
482                                 rc = cpu_down(cpu);
483                                 if (rc)
484                                         goto out;
485                                 cpu_maps_update_begin();
486                                 break;
487
488                         }
489
490                         /*
491                          * The cpu is in CPU_STATE_INACTIVE.
492                          * Upgrade it's state to CPU_STATE_OFFLINE.
493                          */
494                         set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
495                         BUG_ON(plpar_hcall_norets(H_PROD, intserv[i])
496                                                                 != H_SUCCESS);
497                         __cpu_die(cpu);
498                         break;
499                 }
500                 if (cpu == num_possible_cpus())
501                         printk(KERN_WARNING "Could not find cpu to offline "
502                                "with physical id 0x%x\n", intserv[i]);
503         }
504         cpu_maps_update_done();
505
506 out:
507         return rc;
508
509 }
510
511 static ssize_t dlpar_cpu_release(const char *buf, size_t count)
512 {
513         struct device_node *dn;
514         const u32 *drc_index;
515         int rc;
516
517         dn = of_find_node_by_path(buf);
518         if (!dn)
519                 return -EINVAL;
520
521         drc_index = of_get_property(dn, "ibm,my-drc-index", NULL);
522         if (!drc_index) {
523                 of_node_put(dn);
524                 return -EINVAL;
525         }
526
527         cpu_hotplug_driver_lock();
528         rc = dlpar_offline_cpu(dn);
529         if (rc) {
530                 of_node_put(dn);
531                 rc = -EINVAL;
532                 goto out;
533         }
534
535         rc = dlpar_release_drc(*drc_index);
536         if (rc) {
537                 of_node_put(dn);
538                 goto out;
539         }
540
541         rc = dlpar_detach_node(dn);
542         if (rc) {
543                 dlpar_acquire_drc(*drc_index);
544                 goto out;
545         }
546
547         of_node_put(dn);
548 out:
549         cpu_hotplug_driver_unlock();
550         return rc ? rc : count;
551 }
552
553 static int __init pseries_dlpar_init(void)
554 {
555         ppc_md.cpu_probe = dlpar_cpu_probe;
556         ppc_md.cpu_release = dlpar_cpu_release;
557
558         return 0;
559 }
560 machine_device_initcall(pseries, pseries_dlpar_init);
561
562 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */