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/notifier.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/cpu.h>
  17 #include <linux/slab.h>
  18 #include <linux/of.h>
  19 #include "offline_states.h"
  20 #include "pseries.h"
  21
  22 #include <asm/prom.h>
  23 #include <asm/machdep.h>
  24 #include <asm/uaccess.h>
  25 #include <asm/rtas.h>
  26
  27 struct cc_workarea {
  28         __be32  drc_index;
  29         __be32  zero;
  30         __be32  name_offset;
  31         __be32  prop_length;
  32         __be32  prop_offset;
  33 };
  34
  35 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 + be32_to_cpu(ccwa->name_offset);
  53         prop->name = kstrdup(name, GFP_KERNEL);
  54
  55         prop->length = be32_to_cpu(ccwa->prop_length);
  56         value = (char *)ccwa + be32_to_cpu(ccwa->prop_offset);
  57         prop->value = kmemdup(value, prop->length, GFP_KERNEL);
  58         if (!prop->value) {
  59                 dlpar_free_cc_property(prop);
  60                 return NULL;
  61         }
  62
  63         return prop;
  64 }
  65
  66 static struct device_node *dlpar_parse_cc_node(struct cc_workarea *ccwa,
  67                                                const char *path)
  68 {
  69         struct device_node *dn;
  70         char *name;
  71
  72         /* If parent node path is "/" advance path to NULL terminator to
  73          * prevent double leading slashs in full_name.
  74          */
  75         if (!path[1])
  76                 path++;
  77
  78         dn = kzalloc(sizeof(*dn), GFP_KERNEL);
  79         if (!dn)
  80                 return NULL;
  81
  82         name = (char *)ccwa + be32_to_cpu(ccwa->name_offset);
  83         dn->full_name = kasprintf(GFP_KERNEL, "%s/%s", path, name);
  84         if (!dn->full_name) {
  85                 kfree(dn);
  86                 return NULL;
  87         }
  88
  89         of_node_set_flag(dn, OF_DYNAMIC);
  90         of_node_init(dn);
  91
  92         return dn;
  93 }
  94
  95 static void dlpar_free_one_cc_node(struct device_node *dn)
  96 {
  97         struct property *prop;
  98
  99         while (dn->properties) {
 100                 prop = dn->properties;
 101                 dn->properties = prop->next;
 102                 dlpar_free_cc_property(prop);
 103         }
 104
 105         kfree(dn->full_name);
 106         kfree(dn);
 107 }
 108
 109 void dlpar_free_cc_nodes(struct device_node *dn)
 110 {
 111         if (dn->child)
 112                 dlpar_free_cc_nodes(dn->child);
 113
 114         if (dn->sibling)
 115                 dlpar_free_cc_nodes(dn->sibling);
 116
 117         dlpar_free_one_cc_node(dn);
 118 }
 119
 120 #define COMPLETE        0
 121 #define NEXT_SIBLING    1
 122 #define NEXT_CHILD      2
 123 #define NEXT_PROPERTY   3
 124 #define PREV_PARENT     4
 125 #define MORE_MEMORY     5
 126 #define CALL_AGAIN      -2
 127 #define ERR_CFG_USE     -9003
 128
 129 struct device_node *dlpar_configure_connector(__be32 drc_index,
 130                                               struct device_node *parent)
 131 {
 132         struct device_node *dn;
 133         struct device_node *first_dn = NULL;
 134         struct device_node *last_dn = NULL;
 135         struct property *property;
 136         struct property *last_property = NULL;
 137         struct cc_workarea *ccwa;
 138         char *data_buf;
 139         const char *parent_path = parent->full_name;
 140         int cc_token;
 141         int rc = -1;
 142
 143         cc_token = rtas_token("ibm,configure-connector");
 144         if (cc_token == RTAS_UNKNOWN_SERVICE)
 145                 return NULL;
 146
 147         data_buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL);
 148         if (!data_buf)
 149                 return NULL;
 150
 151         ccwa = (struct cc_workarea *)&data_buf[0];
 152         ccwa->drc_index = drc_index;
 153         ccwa->zero = 0;
 154
 155         do {
 156                 /* Since we release the rtas_data_buf lock between configure
 157                  * connector calls we want to re-populate the rtas_data_buffer
 158                  * with the contents of the previous call.
 159                  */
 160                 spin_lock(&rtas_data_buf_lock);
 161
 162                 memcpy(rtas_data_buf, data_buf, RTAS_DATA_BUF_SIZE);
 163                 rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL);
 164                 memcpy(data_buf, rtas_data_buf, RTAS_DATA_BUF_SIZE);
 165
 166                 spin_unlock(&rtas_data_buf_lock);
 167
 168                 switch (rc) {
 169                 case COMPLETE:
 170                         break;
 171
 172                 case NEXT_SIBLING:
 173                         dn = dlpar_parse_cc_node(ccwa, parent_path);
 174                         if (!dn)
 175                                 goto cc_error;
 176
 177                         dn->parent = last_dn->parent;
 178                         last_dn->sibling = dn;
 179                         last_dn = dn;
 180                         break;
 181
 182                 case NEXT_CHILD:
 183                         if (first_dn)
 184                                 parent_path = last_dn->full_name;
 185
 186                         dn = dlpar_parse_cc_node(ccwa, parent_path);
 187                         if (!dn)
 188                                 goto cc_error;
 189
 190                         if (!first_dn) {
 191                                 dn->parent = parent;
 192                                 first_dn = dn;
 193                         } else {
 194                                 dn->parent = last_dn;
 195                                 if (last_dn)
 196                                         last_dn->child = dn;
 197                         }
 198
 199                         last_dn = dn;
 200                         break;
 201
 202                 case NEXT_PROPERTY:
 203                         property = dlpar_parse_cc_property(ccwa);
 204                         if (!property)
 205                                 goto cc_error;
 206
 207                         if (!last_dn->properties)
 208                                 last_dn->properties = property;
 209                         else
 210                                 last_property->next = property;
 211
 212                         last_property = property;
 213                         break;
 214
 215                 case PREV_PARENT:
 216                         last_dn = last_dn->parent;
 217                         parent_path = last_dn->parent->full_name;
 218                         break;
 219
 220                 case CALL_AGAIN:
 221                         break;
 222
 223                 case MORE_MEMORY:
 224                 case ERR_CFG_USE:
 225                 default:
 226                         printk(KERN_ERR "Unexpected Error (%d) "
 227                                "returned from configure-connector\n", rc);
 228                         goto cc_error;
 229                 }
 230         } while (rc);
 231
 232 cc_error:
 233         kfree(data_buf);
 234
 235         if (rc) {
 236                 if (first_dn)
 237                         dlpar_free_cc_nodes(first_dn);
 238
 239                 return NULL;
 240         }
 241
 242         return first_dn;
 243 }
 244
 245 static struct device_node *derive_parent(const char *path)
 246 {
 247         struct device_node *parent;
 248         char *last_slash;
 249
 250         last_slash = strrchr(path, '/');
 251         if (last_slash == path) {
 252                 parent = of_find_node_by_path("/");
 253         } else {
 254                 char *parent_path;
 255                 int parent_path_len = last_slash - path + 1;
 256                 parent_path = kmalloc(parent_path_len, GFP_KERNEL);
 257                 if (!parent_path)
 258                         return NULL;
 259
 260                 strlcpy(parent_path, path, parent_path_len);
 261                 parent = of_find_node_by_path(parent_path);
 262                 kfree(parent_path);
 263         }
 264
 265         return parent;
 266 }
 267
 268 int dlpar_attach_node(struct device_node *dn)
 269 {
 270         int rc;
 271
 272         dn->parent = derive_parent(dn->full_name);
 273         if (!dn->parent)
 274                 return -ENOMEM;
 275
 276         rc = of_attach_node(dn);
 277         if (rc) {
 278                 printk(KERN_ERR "Failed to add device node %s\n",
 279                        dn->full_name);
 280                 return rc;
 281         }
 282
 283         of_node_put(dn->parent);
 284         return 0;
 285 }
 286
 287 int dlpar_detach_node(struct device_node *dn)
 288 {
 289         struct device_node *child;
 290         int rc;
 291
 292         child = of_get_next_child(dn, NULL);
 293         while (child) {
 294                 dlpar_detach_node(child);
 295                 child = of_get_next_child(dn, child);
 296         }
 297
 298         rc = of_detach_node(dn);
 299         if (rc)
 300                 return rc;
 301
 302         of_node_put(dn); /* Must decrement the refcount */
 303         return 0;
 304 }
 305
 306 #define DR_ENTITY_SENSE         9003
 307 #define DR_ENTITY_PRESENT       1
 308 #define DR_ENTITY_UNUSABLE      2
 309 #define ALLOCATION_STATE        9003
 310 #define ALLOC_UNUSABLE          0
 311 #define ALLOC_USABLE            1
 312 #define ISOLATION_STATE         9001
 313 #define ISOLATE                 0
 314 #define UNISOLATE               1
 315
 316 int dlpar_acquire_drc(u32 drc_index)
 317 {
 318         int dr_status, rc;
 319
 320         rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
 321                        DR_ENTITY_SENSE, drc_index);
 322         if (rc || dr_status != DR_ENTITY_UNUSABLE)
 323                 return -1;
 324
 325         rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE);
 326         if (rc)
 327                 return rc;
 328
 329         rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
 330         if (rc) {
 331                 rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
 332                 return rc;
 333         }
 334
 335         return 0;
 336 }
 337
 338 int dlpar_release_drc(u32 drc_index)
 339 {
 340         int dr_status, rc;
 341
 342         rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
 343                        DR_ENTITY_SENSE, drc_index);
 344         if (rc || dr_status != DR_ENTITY_PRESENT)
 345                 return -1;
 346
 347         rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE);
 348         if (rc)
 349                 return rc;
 350
 351         rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
 352         if (rc) {
 353                 rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
 354                 return rc;
 355         }
 356
 357         return 0;
 358 }
 359
 360 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
 361
 362 static int dlpar_online_cpu(struct device_node *dn)
 363 {
 364         int rc = 0;
 365         unsigned int cpu;
 366         int len, nthreads, i;
 367         const __be32 *intserv;
 368         u32 thread;
 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                 thread = be32_to_cpu(intserv[i]);
 379                 for_each_present_cpu(cpu) {
 380                         if (get_hard_smp_processor_id(cpu) != thread)
 381                                 continue;
 382                         BUG_ON(get_cpu_current_state(cpu)
 383                                         != CPU_STATE_OFFLINE);
 384                         cpu_maps_update_done();
 385                         rc = device_online(get_cpu_device(cpu));
 386                         if (rc)
 387                                 goto out;
 388                         cpu_maps_update_begin();
 389
 390                         break;
 391                 }
 392                 if (cpu == num_possible_cpus())
 393                         printk(KERN_WARNING "Could not find cpu to online "
 394                                "with physical id 0x%x\n", thread);
 395         }
 396         cpu_maps_update_done();
 397
 398 out:
 399         return rc;
 400
 401 }
 402
 403 static ssize_t dlpar_cpu_probe(const char *buf, size_t count)
 404 {
 405         struct device_node *dn, *parent;
 406         u32 drc_index;
 407         int rc;
 408
 409         rc = kstrtou32(buf, 0, &drc_index);
 410         if (rc)
 411                 return -EINVAL;
 412
 413         parent = of_find_node_by_path("/cpus");
 414         if (!parent)
 415                 return -ENODEV;
 416
 417         dn = dlpar_configure_connector(cpu_to_be32(drc_index), parent);
 418         if (!dn)
 419                 return -EINVAL;
 420
 421         of_node_put(parent);
 422
 423         rc = dlpar_acquire_drc(drc_index);
 424         if (rc) {
 425                 dlpar_free_cc_nodes(dn);
 426                 return -EINVAL;
 427         }
 428
 429         rc = dlpar_attach_node(dn);
 430         if (rc) {
 431                 dlpar_release_drc(drc_index);
 432                 dlpar_free_cc_nodes(dn);
 433                 return rc;
 434         }
 435
 436         rc = dlpar_online_cpu(dn);
 437         if (rc)
 438                 return rc;
 439
 440         return count;
 441 }
 442
 443 static int dlpar_offline_cpu(struct device_node *dn)
 444 {
 445         int rc = 0;
 446         unsigned int cpu;
 447         int len, nthreads, i;
 448         const __be32 *intserv;
 449         u32 thread;
 450
 451         intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
 452         if (!intserv)
 453                 return -EINVAL;
 454
 455         nthreads = len / sizeof(u32);
 456
 457         cpu_maps_update_begin();
 458         for (i = 0; i < nthreads; i++) {
 459                 thread = be32_to_cpu(intserv[i]);
 460                 for_each_present_cpu(cpu) {
 461                         if (get_hard_smp_processor_id(cpu) != thread)
 462                                 continue;
 463
 464                         if (get_cpu_current_state(cpu) == CPU_STATE_OFFLINE)
 465                                 break;
 466
 467                         if (get_cpu_current_state(cpu) == CPU_STATE_ONLINE) {
 468                                 set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
 469                                 cpu_maps_update_done();
 470                                 rc = device_offline(get_cpu_device(cpu));
 471                                 if (rc)
 472                                         goto out;
 473                                 cpu_maps_update_begin();
 474                                 break;
 475
 476                         }
 477
 478                         /*
 479                          * The cpu is in CPU_STATE_INACTIVE.
 480                          * Upgrade it's state to CPU_STATE_OFFLINE.
 481                          */
 482                         set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
 483                         BUG_ON(plpar_hcall_norets(H_PROD, thread)
 484                                                                 != H_SUCCESS);
 485                         __cpu_die(cpu);
 486                         break;
 487                 }
 488                 if (cpu == num_possible_cpus())
 489                         printk(KERN_WARNING "Could not find cpu to offline "
 490                                "with physical id 0x%x\n", thread);
 491         }
 492         cpu_maps_update_done();
 493
 494 out:
 495         return rc;
 496
 497 }
 498
 499 static ssize_t dlpar_cpu_release(const char *buf, size_t count)
 500 {
 501         struct device_node *dn;
 502         u32 drc_index;
 503         int rc;
 504
 505         dn = of_find_node_by_path(buf);
 506         if (!dn)
 507                 return -EINVAL;
 508
 509         rc = of_property_read_u32(dn, "ibm,my-drc-index", &drc_index);
 510         if (rc) {
 511                 of_node_put(dn);
 512                 return -EINVAL;
 513         }
 514
 515         rc = dlpar_offline_cpu(dn);
 516         if (rc) {
 517                 of_node_put(dn);
 518                 return -EINVAL;
 519         }
 520
 521         rc = dlpar_release_drc(drc_index);
 522         if (rc) {
 523                 of_node_put(dn);
 524                 return rc;
 525         }
 526
 527         rc = dlpar_detach_node(dn);
 528         if (rc) {
 529                 dlpar_acquire_drc(drc_index);
 530                 return rc;
 531         }
 532
 533         of_node_put(dn);
 534
 535         return count;
 536 }
 537
 538 static int __init pseries_dlpar_init(void)
 539 {
 540         ppc_md.cpu_probe = dlpar_cpu_probe;
 541         ppc_md.cpu_release = dlpar_cpu_release;
 542
 543         return 0;
 544 }
 545 machine_device_initcall(pseries, pseries_dlpar_init);
 546
 547 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */