[S390] Standby cpu activation/deactivation.

Add a new interface so that cpus can be put into standby state and
configured state.
Only offline cpus can be put into standby state or configured state.
For that the new percpu sysfs attribute "configure" must be used.
To put a cpu in standby state a "0" must be written to the attribute.
In order to switch it into configured state a "1" must be written to
the attribute.
Only cpus in configured state can be brought online.
In addition this patch introduces a static mapping of physical to
logical cpus. As a result only the sysfs directories of present cpus
will be created. To scan for new cpus the new sysfs attribute "rescan"
must be used.
Writing to /sys/devices/system/cpu/rescan will trigger a rescan of
cpus and will create directories for new cpus.

On IPL only configured cpus will be used. And on reboot/shutdown all
cpus will remain in their current state (configured/standby).

Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

1 files changed, 319 insertions, 0 deletions

diff --git a/drivers/s390/char/sclp_cmd.c b/drivers/s390/char/sclp_cmd.c
new file mode 100644
index 000000000000..ba004fd43c05
--- /dev/null
+++ b/drivers/s390/char/sclp_cmd.c
@@ -0,0 +1,319 @@
+/*
+ *  drivers/s390/char/sclp_cmd.c
+ *
+ *    Copyright IBM Corp. 2007
+ *    Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>
+ */
+
+#include <linux/completion.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <asm/sclp.h>
+#include "sclp.h"
+
+#define TAG     "sclp_cmd: "
+
+#define SCLP_CMDW_READ_SCP_INFO         0x00020001
+#define SCLP_CMDW_READ_SCP_INFO_FORCED  0x00120001
+
+struct read_info_sccb {
+        struct  sccb_header header;     /* 0-7 */
+        u16     rnmax;                  /* 8-9 */
+        u8      rnsize;                 /* 10 */
+        u8      _reserved0[24 - 11];    /* 11-15 */
+        u8      loadparm[8];            /* 24-31 */
+        u8      _reserved1[48 - 32];    /* 32-47 */
+        u64     facilities;             /* 48-55 */
+        u8      _reserved2[84 - 56];    /* 56-83 */
+        u8      fac84;                  /* 84 */
+        u8      _reserved3[91 - 85];    /* 85-90 */
+        u8      flags;                  /* 91 */
+        u8      _reserved4[100 - 92];   /* 92-99 */
+        u32     rnsize2;                /* 100-103 */
+        u64     rnmax2;                 /* 104-111 */
+        u8      _reserved5[4096 - 112]; /* 112-4095 */
+} __attribute__((packed, aligned(PAGE_SIZE)));
+
+static struct read_info_sccb __initdata early_read_info_sccb;
+static int __initdata early_read_info_sccb_valid;
+
+u64 sclp_facilities;
+static u8 sclp_fac84;
+
+static int __init sclp_cmd_sync_early(sclp_cmdw_t cmd, void *sccb)
+{
+        int rc;
+
+        __ctl_set_bit(0, 9);
+        rc = sclp_service_call(cmd, sccb);
+        if (rc)
+                goto out;
+        __load_psw_mask(PSW_BASE_BITS | PSW_MASK_EXT |
+                        PSW_MASK_WAIT | PSW_DEFAULT_KEY);
+        local_irq_disable();
+out:
+        /* Contents of the sccb might have changed. */
+        barrier();
+        __ctl_clear_bit(0, 9);
+        return rc;
+}
+
+void __init sclp_read_info_early(void)
+{
+        int rc;
+        int i;
+        struct read_info_sccb *sccb;
+        sclp_cmdw_t commands[] = {SCLP_CMDW_READ_SCP_INFO_FORCED,
+                                  SCLP_CMDW_READ_SCP_INFO};
+
+        sccb = &early_read_info_sccb;
+        for (i = 0; i < ARRAY_SIZE(commands); i++) {
+                do {
+                        memset(sccb, 0, sizeof(*sccb));
+                        sccb->header.length = sizeof(*sccb);
+                        sccb->header.control_mask[2] = 0x80;
+                        rc = sclp_cmd_sync_early(commands[i], sccb);
+                } while (rc == -EBUSY);
+
+                if (rc)
+                        break;
+                if (sccb->header.response_code == 0x10) {
+                        early_read_info_sccb_valid = 1;
+                        break;
+                }
+                if (sccb->header.response_code != 0x1f0)
+                        break;
+        }
+}
+
+void __init sclp_facilities_detect(void)
+{
+        if (!early_read_info_sccb_valid)
+                return;
+        sclp_facilities = early_read_info_sccb.facilities;
+        sclp_fac84 = early_read_info_sccb.fac84;
+}
+
+unsigned long long __init sclp_memory_detect(void)
+{
+        unsigned long long memsize;
+        struct read_info_sccb *sccb;
+
+        if (!early_read_info_sccb_valid)
+                return 0;
+        sccb = &early_read_info_sccb;
+        if (sccb->rnsize)
+                memsize = sccb->rnsize << 20;
+        else
+                memsize = sccb->rnsize2 << 20;
+        if (sccb->rnmax)
+                memsize *= sccb->rnmax;
+        else
+                memsize *= sccb->rnmax2;
+        return memsize;
+}
+
+/*
+ * This function will be called after sclp_memory_detect(), which gets called
+ * early from early.c code. Therefore the sccb should have valid contents.
+ */
+void __init sclp_get_ipl_info(struct sclp_ipl_info *info)
+{
+        struct read_info_sccb *sccb;
+
+        if (!early_read_info_sccb_valid)
+                return;
+        sccb = &early_read_info_sccb;
+        info->is_valid = 1;
+        if (sccb->flags & 0x2)
+                info->has_dump = 1;
+        memcpy(&info->loadparm, &sccb->loadparm, LOADPARM_LEN);
+}
+
+static void sclp_sync_callback(struct sclp_req *req, void *data)
+{
+        struct completion *completion = data;
+
+        complete(completion);
+}
+
+static int do_sync_request(sclp_cmdw_t cmd, void *sccb)
+{
+        struct completion completion;
+        struct sclp_req *request;
+        int rc;
+
+        request = kzalloc(sizeof(*request), GFP_KERNEL);
+        if (!request)
+                return -ENOMEM;
+        request->command = cmd;
+        request->sccb = sccb;
+        request->status = SCLP_REQ_FILLED;
+        request->callback = sclp_sync_callback;
+        request->callback_data = &completion;
+        init_completion(&completion);
+
+        /* Perform sclp request. */
+        rc = sclp_add_request(request);
+        if (rc)
+                goto out;
+        wait_for_completion(&completion);
+
+        /* Check response. */
+        if (request->status != SCLP_REQ_DONE) {
+                printk(KERN_WARNING TAG "sync request failed "
+                       "(cmd=0x%08x, status=0x%02x)\n", cmd, request->status);
+                rc = -EIO;
+        }
+out:
+        kfree(request);
+        return rc;
+}
+
+/*
+ * CPU configuration related functions.
+ */
+
+#define SCLP_CMDW_READ_CPU_INFO         0x00010001
+#define SCLP_CMDW_CONFIGURE_CPU         0x00110001
+#define SCLP_CMDW_DECONFIGURE_CPU       0x00100001
+
+struct read_cpu_info_sccb {
+        struct  sccb_header header;
+        u16     nr_configured;
+        u16     offset_configured;
+        u16     nr_standby;
+        u16     offset_standby;
+        u8      reserved[4096 - 16];
+} __attribute__((packed, aligned(PAGE_SIZE)));
+
+static struct read_cpu_info_sccb __initdata early_read_cpu_info_sccb;
+static struct sclp_cpu_info __initdata sclp_cpu_info;
+
+static void sclp_fill_cpu_info(struct sclp_cpu_info *info,
+                               struct read_cpu_info_sccb *sccb)
+{
+        char *page = (char *) sccb;
+
+        memset(info, 0, sizeof(*info));
+        info->configured = sccb->nr_configured;
+        info->standby = sccb->nr_standby;
+        info->combined = sccb->nr_configured + sccb->nr_standby;
+        info->has_cpu_type = sclp_fac84 & 0x1;
+        memcpy(&info->cpu, page + sccb->offset_configured,
+               info->combined * sizeof(struct sclp_cpu_entry));
+}
+
+void __init sclp_read_cpu_info_early(void)
+{
+        int rc;
+        struct read_cpu_info_sccb *sccb;
+
+        if (!SCLP_HAS_CPU_INFO)
+                return;
+
+        sccb = &early_read_cpu_info_sccb;
+        do {
+                memset(sccb, 0, sizeof(*sccb));
+                sccb->header.length = sizeof(*sccb);
+                rc = sclp_cmd_sync_early(SCLP_CMDW_READ_CPU_INFO, sccb);
+        } while (rc == -EBUSY);
+
+        if (rc)
+                return;
+        if (sccb->header.response_code != 0x10)
+                return;
+        sclp_fill_cpu_info(&sclp_cpu_info, sccb);
+}
+
+static int __init sclp_get_cpu_info_early(struct sclp_cpu_info *info)
+{
+        if (!SCLP_HAS_CPU_INFO)
+                return -EOPNOTSUPP;
+        *info = sclp_cpu_info;
+        return 0;
+}
+
+static int sclp_get_cpu_info_late(struct sclp_cpu_info *info)
+{
+        int rc;
+        struct read_cpu_info_sccb *sccb;
+
+        if (!SCLP_HAS_CPU_INFO)
+                return -EOPNOTSUPP;
+        sccb = (struct read_cpu_info_sccb *)  __get_free_page(GFP_KERNEL
+                                                              | GFP_DMA);
+        if (!sccb)
+                return -ENOMEM;
+        memset(sccb, 0, sizeof(*sccb));
+        sccb->header.length = sizeof(*sccb);
+        rc = do_sync_request(SCLP_CMDW_READ_CPU_INFO, sccb);
+        if (rc)
+                goto out;
+        if (sccb->header.response_code != 0x0010) {
+                printk(KERN_WARNING TAG "readcpuinfo failed "
+                       "(response=0x%04x)\n", sccb->header.response_code);
+                rc = -EIO;
+                goto out;
+        }
+        sclp_fill_cpu_info(info, sccb);
+out:
+        free_page((unsigned long) sccb);
+        return rc;
+}
+
+int __init_refok sclp_get_cpu_info(struct sclp_cpu_info *info)
+{
+        if (slab_is_available())
+                return sclp_get_cpu_info_late(info);
+        return sclp_get_cpu_info_early(info);
+}
+
+struct cpu_configure_sccb {
+        struct sccb_header header;
+} __attribute__((packed, aligned(8)));
+
+static int do_cpu_configure(sclp_cmdw_t cmd)
+{
+        struct cpu_configure_sccb *sccb;
+        int rc;
+
+        if (!SCLP_HAS_CPU_RECONFIG)
+                return -EOPNOTSUPP;
+        /*
+         * This is not going to cross a page boundary since we force
+         * kmalloc to have a minimum alignment of 8 bytes on s390.
+         */
+        sccb = kzalloc(sizeof(*sccb), GFP_KERNEL | GFP_DMA);
+        if (!sccb)
+                return -ENOMEM;
+        sccb->header.length = sizeof(*sccb);
+        rc = do_sync_request(cmd, sccb);
+        if (rc)
+                goto out;
+        switch (sccb->header.response_code) {
+        case 0x0020:
+        case 0x0120:
+                break;
+        default:
+                printk(KERN_WARNING TAG "configure cpu failed (cmd=0x%08x, "
+                       "response=0x%04x)\n", cmd, sccb->header.response_code);
+                rc = -EIO;
+                break;
+        }
+out:
+        kfree(sccb);
+        return rc;
+}
+
+int sclp_cpu_configure(u8 cpu)
+{
+        return do_cpu_configure(SCLP_CMDW_CONFIGURE_CPU | cpu << 8);
+}
+
+int sclp_cpu_deconfigure(u8 cpu)
+{
+        return do_cpu_configure(SCLP_CMDW_DECONFIGURE_CPU | cpu << 8);
+}