arch/powerpc/platforms/pseries/hotplug-cpu.c

   1 /*
   2  * pseries CPU Hotplug infrastructure.
   3  *
   4  * Split out from arch/powerpc/platforms/pseries/setup.c
   5  *  arch/powerpc/kernel/rtas.c, and arch/powerpc/platforms/pseries/smp.c
   6  *
   7  * Peter Bergner, IBM   March 2001.
   8  * Copyright (C) 2001 IBM.
   9  * Dave Engebretsen, Peter Bergner, and
  10  * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
  11  * Plus various changes from other IBM teams...
  12  *
  13  * Copyright (C) 2006 Michael Ellerman, IBM Corporation
  14  *
  15  *      This program is free software; you can redistribute it and/or
  16  *      modify it under the terms of the GNU General Public License
  17  *      as published by the Free Software Foundation; either version
  18  *      2 of the License, or (at your option) any later version.
  19  */
  20
  21 #define pr_fmt(fmt)     "pseries-hotplug-cpu: " fmt
  22
  23 #include <linux/kernel.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/delay.h>
  26 #include <linux/sched.h>        /* for idle_task_exit */
  27 #include <linux/cpu.h>
  28 #include <linux/of.h>
  29 #include <linux/slab.h>
  30 #include <asm/prom.h>
  31 #include <asm/rtas.h>
  32 #include <asm/firmware.h>
  33 #include <asm/machdep.h>
  34 #include <asm/vdso_datapage.h>
  35 #include <asm/xics.h>
  36 #include <asm/plpar_wrappers.h>
  37
  38 #include "pseries.h"
  39 #include "offline_states.h"
  40
  41 /* This version can't take the spinlock, because it never returns */
  42 static int rtas_stop_self_token = RTAS_UNKNOWN_SERVICE;
  43
  44 static DEFINE_PER_CPU(enum cpu_state_vals, preferred_offline_state) =
  45                                                         CPU_STATE_OFFLINE;
  46 static DEFINE_PER_CPU(enum cpu_state_vals, current_state) = CPU_STATE_OFFLINE;
  47
  48 static enum cpu_state_vals default_offline_state = CPU_STATE_OFFLINE;
  49
  50 static bool cede_offline_enabled __read_mostly = true;
  51
  52 /*
  53  * Enable/disable cede_offline when available.
  54  */
  55 static int __init setup_cede_offline(char *str)
  56 {
  57         return (kstrtobool(str, &cede_offline_enabled) == 0);
  58 }
  59
  60 __setup("cede_offline=", setup_cede_offline);
  61
  62 enum cpu_state_vals get_cpu_current_state(int cpu)
  63 {
  64         return per_cpu(current_state, cpu);
  65 }
  66
  67 void set_cpu_current_state(int cpu, enum cpu_state_vals state)
  68 {
  69         per_cpu(current_state, cpu) = state;
  70 }
  71
  72 enum cpu_state_vals get_preferred_offline_state(int cpu)
  73 {
  74         return per_cpu(preferred_offline_state, cpu);
  75 }
  76
  77 void set_preferred_offline_state(int cpu, enum cpu_state_vals state)
  78 {
  79         per_cpu(preferred_offline_state, cpu) = state;
  80 }
  81
  82 void set_default_offline_state(int cpu)
  83 {
  84         per_cpu(preferred_offline_state, cpu) = default_offline_state;
  85 }
  86
  87 static void rtas_stop_self(void)
  88 {
  89         static struct rtas_args args;
  90
  91         local_irq_disable();
  92
  93         BUG_ON(rtas_stop_self_token == RTAS_UNKNOWN_SERVICE);
  94
  95         rtas_call_unlocked(&args, rtas_stop_self_token, 0, 1, NULL);
  96
  97         panic("Alas, I survived.\n");
  98 }
  99
 100 static void pseries_mach_cpu_die(void)
 101 {
 102         unsigned int cpu = smp_processor_id();
 103         unsigned int hwcpu = hard_smp_processor_id();
 104         u8 cede_latency_hint = 0;
 105
 106         local_irq_disable();
 107         idle_task_exit();
 108         xics_teardown_cpu();
 109
 110         if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
 111                 set_cpu_current_state(cpu, CPU_STATE_INACTIVE);
 112                 if (ppc_md.suspend_disable_cpu)
 113                         ppc_md.suspend_disable_cpu();
 114
 115                 cede_latency_hint = 2;
 116
 117                 get_lppaca()->idle = 1;
 118                 if (!lppaca_shared_proc(get_lppaca()))
 119                         get_lppaca()->donate_dedicated_cpu = 1;
 120
 121                 while (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
 122                         while (!prep_irq_for_idle()) {
 123                                 local_irq_enable();
 124                                 local_irq_disable();
 125                         }
 126
 127                         extended_cede_processor(cede_latency_hint);
 128                 }
 129
 130                 local_irq_disable();
 131
 132                 if (!lppaca_shared_proc(get_lppaca()))
 133                         get_lppaca()->donate_dedicated_cpu = 0;
 134                 get_lppaca()->idle = 0;
 135
 136                 if (get_preferred_offline_state(cpu) == CPU_STATE_ONLINE) {
 137                         unregister_slb_shadow(hwcpu);
 138
 139                         hard_irq_disable();
 140                         /*
 141                          * Call to start_secondary_resume() will not return.
 142                          * Kernel stack will be reset and start_secondary()
 143                          * will be called to continue the online operation.
 144                          */
 145                         start_secondary_resume();
 146                 }
 147         }
 148
 149         /* Requested state is CPU_STATE_OFFLINE at this point */
 150         WARN_ON(get_preferred_offline_state(cpu) != CPU_STATE_OFFLINE);
 151
 152         set_cpu_current_state(cpu, CPU_STATE_OFFLINE);
 153         unregister_slb_shadow(hwcpu);
 154         rtas_stop_self();
 155
 156         /* Should never get here... */
 157         BUG();
 158         for(;;);
 159 }
 160
 161 static int pseries_cpu_disable(void)
 162 {
 163         int cpu = smp_processor_id();
 164
 165         set_cpu_online(cpu, false);
 166         vdso_data->processorCount--;
 167
 168         /*fix boot_cpuid here*/
 169         if (cpu == boot_cpuid)
 170                 boot_cpuid = cpumask_any(cpu_online_mask);
 171
 172         /* FIXME: abstract this to not be platform specific later on */
 173         xics_migrate_irqs_away();
 174         return 0;
 175 }
 176
 177 /*
 178  * pseries_cpu_die: Wait for the cpu to die.
 179  * @cpu: logical processor id of the CPU whose death we're awaiting.
 180  *
 181  * This function is called from the context of the thread which is performing
 182  * the cpu-offline. Here we wait for long enough to allow the cpu in question
 183  * to self-destroy so that the cpu-offline thread can send the CPU_DEAD
 184  * notifications.
 185  *
 186  * OTOH, pseries_mach_cpu_die() is called by the @cpu when it wants to
 187  * self-destruct.
 188  */
 189 static void pseries_cpu_die(unsigned int cpu)
 190 {
 191         int tries;
 192         int cpu_status = 1;
 193         unsigned int pcpu = get_hard_smp_processor_id(cpu);
 194
 195         if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
 196                 cpu_status = 1;
 197                 for (tries = 0; tries < 5000; tries++) {
 198                         if (get_cpu_current_state(cpu) == CPU_STATE_INACTIVE) {
 199                                 cpu_status = 0;
 200                                 break;
 201                         }
 202                         msleep(1);
 203                 }
 204         } else if (get_preferred_offline_state(cpu) == CPU_STATE_OFFLINE) {
 205
 206                 for (tries = 0; tries < 25; tries++) {
 207                         cpu_status = smp_query_cpu_stopped(pcpu);
 208                         if (cpu_status == QCSS_STOPPED ||
 209                             cpu_status == QCSS_HARDWARE_ERROR)
 210                                 break;
 211                         cpu_relax();
 212                 }
 213         }
 214
 215         if (cpu_status != 0) {
 216                 printk("Querying DEAD? cpu %i (%i) shows %i\n",
 217                        cpu, pcpu, cpu_status);
 218         }
 219
 220         /* Isolation and deallocation are definitely done by
 221          * drslot_chrp_cpu.  If they were not they would be
 222          * done here.  Change isolate state to Isolate and
 223          * change allocation-state to Unusable.
 224          */
 225         paca[cpu].cpu_start = 0;
 226 }
 227
 228 /*
 229  * Update cpu_present_mask and paca(s) for a new cpu node.  The wrinkle
 230  * here is that a cpu device node may represent up to two logical cpus
 231  * in the SMT case.  We must honor the assumption in other code that
 232  * the logical ids for sibling SMT threads x and y are adjacent, such
 233  * that x^1 == y and y^1 == x.
 234  */
 235 static int pseries_add_processor(struct device_node *np)
 236 {
 237         unsigned int cpu;
 238         cpumask_var_t candidate_mask, tmp;
 239         int err = -ENOSPC, len, nthreads, i;
 240         const __be32 *intserv;
 241
 242         intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
 243         if (!intserv)
 244                 return 0;
 245
 246         zalloc_cpumask_var(&candidate_mask, GFP_KERNEL);
 247         zalloc_cpumask_var(&tmp, GFP_KERNEL);
 248
 249         nthreads = len / sizeof(u32);
 250         for (i = 0; i < nthreads; i++)
 251                 cpumask_set_cpu(i, tmp);
 252
 253         cpu_maps_update_begin();
 254
 255         BUG_ON(!cpumask_subset(cpu_present_mask, cpu_possible_mask));
 256
 257         /* Get a bitmap of unoccupied slots. */
 258         cpumask_xor(candidate_mask, cpu_possible_mask, cpu_present_mask);
 259         if (cpumask_empty(candidate_mask)) {
 260                 /* If we get here, it most likely means that NR_CPUS is
 261                  * less than the partition's max processors setting.
 262                  */
 263                 printk(KERN_ERR "Cannot add cpu %s; this system configuration"
 264                        " supports %d logical cpus.\n", np->full_name,
 265                        num_possible_cpus());
 266                 goto out_unlock;
 267         }
 268
 269         while (!cpumask_empty(tmp))
 270                 if (cpumask_subset(tmp, candidate_mask))
 271                         /* Found a range where we can insert the new cpu(s) */
 272                         break;
 273                 else
 274                         cpumask_shift_left(tmp, tmp, nthreads);
 275
 276         if (cpumask_empty(tmp)) {
 277                 printk(KERN_ERR "Unable to find space in cpu_present_mask for"
 278                        " processor %s with %d thread(s)\n", np->name,
 279                        nthreads);
 280                 goto out_unlock;
 281         }
 282
 283         for_each_cpu(cpu, tmp) {
 284                 BUG_ON(cpu_present(cpu));
 285                 set_cpu_present(cpu, true);
 286                 set_hard_smp_processor_id(cpu, be32_to_cpu(*intserv++));
 287         }
 288         err = 0;
 289 out_unlock:
 290         cpu_maps_update_done();
 291         free_cpumask_var(candidate_mask);
 292         free_cpumask_var(tmp);
 293         return err;
 294 }
 295
 296 /*
 297  * Update the present map for a cpu node which is going away, and set
 298  * the hard id in the paca(s) to -1 to be consistent with boot time
 299  * convention for non-present cpus.
 300  */
 301 static void pseries_remove_processor(struct device_node *np)
 302 {
 303         unsigned int cpu;
 304         int len, nthreads, i;
 305         const __be32 *intserv;
 306         u32 thread;
 307
 308         intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
 309         if (!intserv)
 310                 return;
 311
 312         nthreads = len / sizeof(u32);
 313
 314         cpu_maps_update_begin();
 315         for (i = 0; i < nthreads; i++) {
 316                 thread = be32_to_cpu(intserv[i]);
 317                 for_each_present_cpu(cpu) {
 318                         if (get_hard_smp_processor_id(cpu) != thread)
 319                                 continue;
 320                         BUG_ON(cpu_online(cpu));
 321                         set_cpu_present(cpu, false);
 322                         set_hard_smp_processor_id(cpu, -1);
 323                         break;
 324                 }
 325                 if (cpu >= nr_cpu_ids)
 326                         printk(KERN_WARNING "Could not find cpu to remove "
 327                                "with physical id 0x%x\n", thread);
 328         }
 329         cpu_maps_update_done();
 330 }
 331
 332 static int dlpar_online_cpu(struct device_node *dn)
 333 {
 334         int rc = 0;
 335         unsigned int cpu;
 336         int len, nthreads, i;
 337         const __be32 *intserv;
 338         u32 thread;
 339
 340         intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
 341         if (!intserv)
 342                 return -EINVAL;
 343
 344         nthreads = len / sizeof(u32);
 345
 346         cpu_maps_update_begin();
 347         for (i = 0; i < nthreads; i++) {
 348                 thread = be32_to_cpu(intserv[i]);
 349                 for_each_present_cpu(cpu) {
 350                         if (get_hard_smp_processor_id(cpu) != thread)
 351                                 continue;
 352                         BUG_ON(get_cpu_current_state(cpu)
 353                                         != CPU_STATE_OFFLINE);
 354                         cpu_maps_update_done();
 355                         rc = device_online(get_cpu_device(cpu));
 356                         if (rc)
 357                                 goto out;
 358                         cpu_maps_update_begin();
 359
 360                         break;
 361                 }
 362                 if (cpu == num_possible_cpus())
 363                         printk(KERN_WARNING "Could not find cpu to online "
 364                                "with physical id 0x%x\n", thread);
 365         }
 366         cpu_maps_update_done();
 367
 368 out:
 369         return rc;
 370
 371 }
 372
 373 static bool dlpar_cpu_exists(struct device_node *parent, u32 drc_index)
 374 {
 375         struct device_node *child = NULL;
 376         u32 my_drc_index;
 377         bool found;
 378         int rc;
 379
 380         /* Assume cpu doesn't exist */
 381         found = false;
 382
 383         for_each_child_of_node(parent, child) {
 384                 rc = of_property_read_u32(child, "ibm,my-drc-index",
 385                                           &my_drc_index);
 386                 if (rc)
 387                         continue;
 388
 389                 if (my_drc_index == drc_index) {
 390                         of_node_put(child);
 391                         found = true;
 392                         break;
 393                 }
 394         }
 395
 396         return found;
 397 }
 398
 399 static bool valid_cpu_drc_index(struct device_node *parent, u32 drc_index)
 400 {
 401         bool found = false;
 402         int rc, index;
 403
 404         index = 0;
 405         while (!found) {
 406                 u32 drc;
 407
 408                 rc = of_property_read_u32_index(parent, "ibm,drc-indexes",
 409                                                 index++, &drc);
 410                 if (rc)
 411                         break;
 412
 413                 if (drc == drc_index)
 414                         found = true;
 415         }
 416
 417         return found;
 418 }
 419
 420 static ssize_t dlpar_cpu_add(u32 drc_index)
 421 {
 422         struct device_node *dn, *parent;
 423         int rc, saved_rc;
 424
 425         pr_debug("Attempting to add CPU, drc index: %x\n", drc_index);
 426
 427         parent = of_find_node_by_path("/cpus");
 428         if (!parent) {
 429                 pr_warn("Failed to find CPU root node \"/cpus\"\n");
 430                 return -ENODEV;
 431         }
 432
 433         if (dlpar_cpu_exists(parent, drc_index)) {
 434                 of_node_put(parent);
 435                 pr_warn("CPU with drc index %x already exists\n", drc_index);
 436                 return -EINVAL;
 437         }
 438
 439         if (!valid_cpu_drc_index(parent, drc_index)) {
 440                 of_node_put(parent);
 441                 pr_warn("Cannot find CPU (drc index %x) to add.\n", drc_index);
 442                 return -EINVAL;
 443         }
 444
 445         rc = dlpar_acquire_drc(drc_index);
 446         if (rc) {
 447                 pr_warn("Failed to acquire DRC, rc: %d, drc index: %x\n",
 448                         rc, drc_index);
 449                 of_node_put(parent);
 450                 return -EINVAL;
 451         }
 452
 453         dn = dlpar_configure_connector(cpu_to_be32(drc_index), parent);
 454         of_node_put(parent);
 455         if (!dn) {
 456                 pr_warn("Failed call to configure-connector, drc index: %x\n",
 457                         drc_index);
 458                 dlpar_release_drc(drc_index);
 459                 return -EINVAL;
 460         }
 461
 462         rc = dlpar_attach_node(dn);
 463         if (rc) {
 464                 saved_rc = rc;
 465                 pr_warn("Failed to attach node %s, rc: %d, drc index: %x\n",
 466                         dn->name, rc, drc_index);
 467
 468                 rc = dlpar_release_drc(drc_index);
 469                 if (!rc)
 470                         dlpar_free_cc_nodes(dn);
 471
 472                 return saved_rc;
 473         }
 474
 475         rc = dlpar_online_cpu(dn);
 476         if (rc) {
 477                 saved_rc = rc;
 478                 pr_warn("Failed to online cpu %s, rc: %d, drc index: %x\n",
 479                         dn->name, rc, drc_index);
 480
 481                 rc = dlpar_detach_node(dn);
 482                 if (!rc)
 483                         dlpar_release_drc(drc_index);
 484
 485                 return saved_rc;
 486         }
 487
 488         pr_debug("Successfully added CPU %s, drc index: %x\n", dn->name,
 489                  drc_index);
 490         return rc;
 491 }
 492
 493 static int dlpar_offline_cpu(struct device_node *dn)
 494 {
 495         int rc = 0;
 496         unsigned int cpu;
 497         int len, nthreads, i;
 498         const __be32 *intserv;
 499         u32 thread;
 500
 501         intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
 502         if (!intserv)
 503                 return -EINVAL;
 504
 505         nthreads = len / sizeof(u32);
 506
 507         cpu_maps_update_begin();
 508         for (i = 0; i < nthreads; i++) {
 509                 thread = be32_to_cpu(intserv[i]);
 510                 for_each_present_cpu(cpu) {
 511                         if (get_hard_smp_processor_id(cpu) != thread)
 512                                 continue;
 513
 514                         if (get_cpu_current_state(cpu) == CPU_STATE_OFFLINE)
 515                                 break;
 516
 517                         if (get_cpu_current_state(cpu) == CPU_STATE_ONLINE) {
 518                                 set_preferred_offline_state(cpu,
 519                                                             CPU_STATE_OFFLINE);
 520                                 cpu_maps_update_done();
 521                                 rc = device_offline(get_cpu_device(cpu));
 522                                 if (rc)
 523                                         goto out;
 524                                 cpu_maps_update_begin();
 525                                 break;
 526
 527                         }
 528
 529                         /*
 530                          * The cpu is in CPU_STATE_INACTIVE.
 531                          * Upgrade it's state to CPU_STATE_OFFLINE.
 532                          */
 533                         set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
 534                         BUG_ON(plpar_hcall_norets(H_PROD, thread)
 535                                                                 != H_SUCCESS);
 536                         __cpu_die(cpu);
 537                         break;
 538                 }
 539                 if (cpu == num_possible_cpus())
 540                         printk(KERN_WARNING "Could not find cpu to offline with physical id 0x%x\n", thread);
 541         }
 542         cpu_maps_update_done();
 543
 544 out:
 545         return rc;
 546
 547 }
 548
 549 static ssize_t dlpar_cpu_remove(struct device_node *dn, u32 drc_index)
 550 {
 551         int rc;
 552
 553         pr_debug("Attemping to remove CPU %s, drc index: %x\n",
 554                  dn->name, drc_index);
 555
 556         rc = dlpar_offline_cpu(dn);
 557         if (rc) {
 558                 pr_warn("Failed to offline CPU %s, rc: %d\n", dn->name, rc);
 559                 return -EINVAL;
 560         }
 561
 562         rc = dlpar_release_drc(drc_index);
 563         if (rc) {
 564                 pr_warn("Failed to release drc (%x) for CPU %s, rc: %d\n",
 565                         drc_index, dn->name, rc);
 566                 dlpar_online_cpu(dn);
 567                 return rc;
 568         }
 569
 570         rc = dlpar_detach_node(dn);
 571         if (rc) {
 572                 int saved_rc = rc;
 573
 574                 pr_warn("Failed to detach CPU %s, rc: %d", dn->name, rc);
 575
 576                 rc = dlpar_acquire_drc(drc_index);
 577                 if (!rc)
 578                         dlpar_online_cpu(dn);
 579
 580                 return saved_rc;
 581         }
 582
 583         pr_debug("Successfully removed CPU, drc index: %x\n", drc_index);
 584         return 0;
 585 }
 586
 587 static struct device_node *cpu_drc_index_to_dn(u32 drc_index)
 588 {
 589         struct device_node *dn;
 590         u32 my_index;
 591         int rc;
 592
 593         for_each_node_by_type(dn, "cpu") {
 594                 rc = of_property_read_u32(dn, "ibm,my-drc-index", &my_index);
 595                 if (rc)
 596                         continue;
 597
 598                 if (my_index == drc_index)
 599                         break;
 600         }
 601
 602         return dn;
 603 }
 604
 605 static int dlpar_cpu_remove_by_index(u32 drc_index)
 606 {
 607         struct device_node *dn;
 608         int rc;
 609
 610         dn = cpu_drc_index_to_dn(drc_index);
 611         if (!dn) {
 612                 pr_warn("Cannot find CPU (drc index %x) to remove\n",
 613                         drc_index);
 614                 return -ENODEV;
 615         }
 616
 617         rc = dlpar_cpu_remove(dn, drc_index);
 618         of_node_put(dn);
 619         return rc;
 620 }
 621
 622 static int find_dlpar_cpus_to_remove(u32 *cpu_drcs, int cpus_to_remove)
 623 {
 624         struct device_node *dn;
 625         int cpus_found = 0;
 626         int rc;
 627
 628         /* We want to find cpus_to_remove + 1 CPUs to ensure we do not
 629          * remove the last CPU.
 630          */
 631         for_each_node_by_type(dn, "cpu") {
 632                 cpus_found++;
 633
 634                 if (cpus_found > cpus_to_remove) {
 635                         of_node_put(dn);
 636                         break;
 637                 }
 638
 639                 /* Note that cpus_found is always 1 ahead of the index
 640                  * into the cpu_drcs array, so we use cpus_found - 1
 641                  */
 642                 rc = of_property_read_u32(dn, "ibm,my-drc-index",
 643                                           &cpu_drcs[cpus_found - 1]);
 644                 if (rc) {
 645                         pr_warn("Error occurred getting drc-index for %s\n",
 646                                 dn->name);
 647                         of_node_put(dn);
 648                         return -1;
 649                 }
 650         }
 651
 652         if (cpus_found < cpus_to_remove) {
 653                 pr_warn("Failed to find enough CPUs (%d of %d) to remove\n",
 654                         cpus_found, cpus_to_remove);
 655         } else if (cpus_found == cpus_to_remove) {
 656                 pr_warn("Cannot remove all CPUs\n");
 657         }
 658
 659         return cpus_found;
 660 }
 661
 662 static int dlpar_cpu_remove_by_count(u32 cpus_to_remove)
 663 {
 664         u32 *cpu_drcs;
 665         int cpus_found;
 666         int cpus_removed = 0;
 667         int i, rc;
 668
 669         pr_debug("Attempting to hot-remove %d CPUs\n", cpus_to_remove);
 670
 671         cpu_drcs = kcalloc(cpus_to_remove, sizeof(*cpu_drcs), GFP_KERNEL);
 672         if (!cpu_drcs)
 673                 return -EINVAL;
 674
 675         cpus_found = find_dlpar_cpus_to_remove(cpu_drcs, cpus_to_remove);
 676         if (cpus_found <= cpus_to_remove) {
 677                 kfree(cpu_drcs);
 678                 return -EINVAL;
 679         }
 680
 681         for (i = 0; i < cpus_to_remove; i++) {
 682                 rc = dlpar_cpu_remove_by_index(cpu_drcs[i]);
 683                 if (rc)
 684                         break;
 685
 686                 cpus_removed++;
 687         }
 688
 689         if (cpus_removed != cpus_to_remove) {
 690                 pr_warn("CPU hot-remove failed, adding back removed CPUs\n");
 691
 692                 for (i = 0; i < cpus_removed; i++)
 693                         dlpar_cpu_add(cpu_drcs[i]);
 694
 695                 rc = -EINVAL;
 696         } else {
 697                 rc = 0;
 698         }
 699
 700         kfree(cpu_drcs);
 701         return rc;
 702 }
 703
 704 static int find_dlpar_cpus_to_add(u32 *cpu_drcs, u32 cpus_to_add)
 705 {
 706         struct device_node *parent;
 707         int cpus_found = 0;
 708         int index, rc;
 709
 710         parent = of_find_node_by_path("/cpus");
 711         if (!parent) {
 712                 pr_warn("Could not find CPU root node in device tree\n");
 713                 kfree(cpu_drcs);
 714                 return -1;
 715         }
 716
 717         /* Search the ibm,drc-indexes array for possible CPU drcs to
 718          * add. Note that the format of the ibm,drc-indexes array is
 719          * the number of entries in the array followed by the array
 720          * of drc values so we start looking at index = 1.
 721          */
 722         index = 1;
 723         while (cpus_found < cpus_to_add) {
 724                 u32 drc;
 725
 726                 rc = of_property_read_u32_index(parent, "ibm,drc-indexes",
 727                                                 index++, &drc);
 728                 if (rc)
 729                         break;
 730
 731                 if (dlpar_cpu_exists(parent, drc))
 732                         continue;
 733
 734                 cpu_drcs[cpus_found++] = drc;
 735         }
 736
 737         of_node_put(parent);
 738         return cpus_found;
 739 }
 740
 741 static int dlpar_cpu_add_by_count(u32 cpus_to_add)
 742 {
 743         u32 *cpu_drcs;
 744         int cpus_added = 0;
 745         int cpus_found;
 746         int i, rc;
 747
 748         pr_debug("Attempting to hot-add %d CPUs\n", cpus_to_add);
 749
 750         cpu_drcs = kcalloc(cpus_to_add, sizeof(*cpu_drcs), GFP_KERNEL);
 751         if (!cpu_drcs)
 752                 return -EINVAL;
 753
 754         cpus_found = find_dlpar_cpus_to_add(cpu_drcs, cpus_to_add);
 755         if (cpus_found < cpus_to_add) {
 756                 pr_warn("Failed to find enough CPUs (%d of %d) to add\n",
 757                         cpus_found, cpus_to_add);
 758                 kfree(cpu_drcs);
 759                 return -EINVAL;
 760         }
 761
 762         for (i = 0; i < cpus_to_add; i++) {
 763                 rc = dlpar_cpu_add(cpu_drcs[i]);
 764                 if (rc)
 765                         break;
 766
 767                 cpus_added++;
 768         }
 769
 770         if (cpus_added < cpus_to_add) {
 771                 pr_warn("CPU hot-add failed, removing any added CPUs\n");
 772
 773                 for (i = 0; i < cpus_added; i++)
 774                         dlpar_cpu_remove_by_index(cpu_drcs[i]);
 775
 776                 rc = -EINVAL;
 777         } else {
 778                 rc = 0;
 779         }
 780
 781         kfree(cpu_drcs);
 782         return rc;
 783 }
 784
 785 int dlpar_cpu_readd(int cpu)
 786 {
 787         struct device_node *dn;
 788         struct device *dev;
 789         u32 drc_index;
 790         int rc;
 791
 792         dev = get_cpu_device(cpu);
 793         dn = dev->of_node;
 794
 795         rc = of_property_read_u32(dn, "ibm,my-drc-index", &drc_index);
 796
 797         rc = dlpar_cpu_remove_by_index(drc_index);
 798         if (!rc)
 799                 rc = dlpar_cpu_add(drc_index);
 800
 801         return rc;
 802 }
 803
 804 int dlpar_cpu(struct pseries_hp_errorlog *hp_elog)
 805 {
 806         u32 count, drc_index;
 807         int rc;
 808
 809         count = hp_elog->_drc_u.drc_count;
 810         drc_index = hp_elog->_drc_u.drc_index;
 811
 812         lock_device_hotplug();
 813
 814         switch (hp_elog->action) {
 815         case PSERIES_HP_ELOG_ACTION_REMOVE:
 816                 if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_COUNT)
 817                         rc = dlpar_cpu_remove_by_count(count);
 818                 else if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_INDEX)
 819                         rc = dlpar_cpu_remove_by_index(drc_index);
 820                 else
 821                         rc = -EINVAL;
 822                 break;
 823         case PSERIES_HP_ELOG_ACTION_ADD:
 824                 if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_COUNT)
 825                         rc = dlpar_cpu_add_by_count(count);
 826                 else if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_INDEX)
 827                         rc = dlpar_cpu_add(drc_index);
 828                 else
 829                         rc = -EINVAL;
 830                 break;
 831         default:
 832                 pr_err("Invalid action (%d) specified\n", hp_elog->action);
 833                 rc = -EINVAL;
 834                 break;
 835         }
 836
 837         unlock_device_hotplug();
 838         return rc;
 839 }
 840
 841 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
 842
 843 static ssize_t dlpar_cpu_probe(const char *buf, size_t count)
 844 {
 845         u32 drc_index;
 846         int rc;
 847
 848         rc = kstrtou32(buf, 0, &drc_index);
 849         if (rc)
 850                 return -EINVAL;
 851
 852         rc = dlpar_cpu_add(drc_index);
 853
 854         return rc ? rc : count;
 855 }
 856
 857 static ssize_t dlpar_cpu_release(const char *buf, size_t count)
 858 {
 859         struct device_node *dn;
 860         u32 drc_index;
 861         int rc;
 862
 863         dn = of_find_node_by_path(buf);
 864         if (!dn)
 865                 return -EINVAL;
 866
 867         rc = of_property_read_u32(dn, "ibm,my-drc-index", &drc_index);
 868         if (rc) {
 869                 of_node_put(dn);
 870                 return -EINVAL;
 871         }
 872
 873         rc = dlpar_cpu_remove(dn, drc_index);
 874         of_node_put(dn);
 875
 876         return rc ? rc : count;
 877 }
 878
 879 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
 880
 881 static int pseries_smp_notifier(struct notifier_block *nb,
 882                                 unsigned long action, void *data)
 883 {
 884         struct of_reconfig_data *rd = data;
 885         int err = 0;
 886
 887         switch (action) {
 888         case OF_RECONFIG_ATTACH_NODE:
 889                 err = pseries_add_processor(rd->dn);
 890                 break;
 891         case OF_RECONFIG_DETACH_NODE:
 892                 pseries_remove_processor(rd->dn);
 893                 break;
 894         }
 895         return notifier_from_errno(err);
 896 }
 897
 898 static struct notifier_block pseries_smp_nb = {
 899         .notifier_call = pseries_smp_notifier,
 900 };
 901
 902 #define MAX_CEDE_LATENCY_LEVELS         4
 903 #define CEDE_LATENCY_PARAM_LENGTH       10
 904 #define CEDE_LATENCY_PARAM_MAX_LENGTH   \
 905         (MAX_CEDE_LATENCY_LEVELS * CEDE_LATENCY_PARAM_LENGTH * sizeof(char))
 906 #define CEDE_LATENCY_TOKEN              45
 907
 908 static char cede_parameters[CEDE_LATENCY_PARAM_MAX_LENGTH];
 909
 910 static int parse_cede_parameters(void)
 911 {
 912         memset(cede_parameters, 0, CEDE_LATENCY_PARAM_MAX_LENGTH);
 913         return rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
 914                          NULL,
 915                          CEDE_LATENCY_TOKEN,
 916                          __pa(cede_parameters),
 917                          CEDE_LATENCY_PARAM_MAX_LENGTH);
 918 }
 919
 920 static int __init pseries_cpu_hotplug_init(void)
 921 {
 922         int cpu;
 923         int qcss_tok;
 924
 925 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
 926         ppc_md.cpu_probe = dlpar_cpu_probe;
 927         ppc_md.cpu_release = dlpar_cpu_release;
 928 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
 929
 930         rtas_stop_self_token = rtas_token("stop-self");
 931         qcss_tok = rtas_token("query-cpu-stopped-state");
 932
 933         if (rtas_stop_self_token == RTAS_UNKNOWN_SERVICE ||
 934                         qcss_tok == RTAS_UNKNOWN_SERVICE) {
 935                 printk(KERN_INFO "CPU Hotplug not supported by firmware "
 936                                 "- disabling.\n");
 937                 return 0;
 938         }
 939
 940         ppc_md.cpu_die = pseries_mach_cpu_die;
 941         smp_ops->cpu_disable = pseries_cpu_disable;
 942         smp_ops->cpu_die = pseries_cpu_die;
 943
 944         /* Processors can be added/removed only on LPAR */
 945         if (firmware_has_feature(FW_FEATURE_LPAR)) {
 946                 of_reconfig_notifier_register(&pseries_smp_nb);
 947                 cpu_maps_update_begin();
 948                 if (cede_offline_enabled && parse_cede_parameters() == 0) {
 949                         default_offline_state = CPU_STATE_INACTIVE;
 950                         for_each_online_cpu(cpu)
 951                                 set_default_offline_state(cpu);
 952                 }
 953                 cpu_maps_update_done();
 954         }
 955
 956         return 0;
 957 }
 958 machine_arch_initcall(pseries, pseries_cpu_hotplug_init);