1 files changed, 171 insertions, 82 deletions

diff --git a/arch/s390/kernel/ipl.c b/arch/s390/kernel/ipl.c
index f731185bf2bd..06833ac2b115 100644
--- a/arch/s390/kernel/ipl.c
+++ b/arch/s390/kernel/ipl.c
@@ -29,36 +29,21 @@
 #define SCCB_LOADPARM (&s390_readinfo_sccb.loadparm)
 #define SCCB_FLAG (s390_readinfo_sccb.flags)
 
-enum ipl_type {
-        IPL_TYPE_NONE    = 1,
-        IPL_TYPE_UNKNOWN = 2,
-        IPL_TYPE_CCW     = 4,
-        IPL_TYPE_FCP     = 8,
-        IPL_TYPE_NSS     = 16,
-};
-
-#define IPL_NONE_STR     "none"
-#define IPL_UNKNOWN_STR  "unknown"
-#define IPL_CCW_STR      "ccw"
-#define IPL_FCP_STR      "fcp"
-#define IPL_NSS_STR      "nss"
-
-/*
- * Must be in data section since the bss section
- * is not cleared when these are accessed.
- */
-u16 ipl_devno __attribute__((__section__(".data"))) = 0;
-u32 ipl_flags __attribute__((__section__(".data"))) = 0;
+#define IPL_UNKNOWN_STR         "unknown"
+#define IPL_CCW_STR             "ccw"
+#define IPL_FCP_STR             "fcp"
+#define IPL_FCP_DUMP_STR        "fcp_dump"
+#define IPL_NSS_STR             "nss"
 
 static char *ipl_type_str(enum ipl_type type)
 {
         switch (type) {
-        case IPL_TYPE_NONE:
-                return IPL_NONE_STR;
         case IPL_TYPE_CCW:
                 return IPL_CCW_STR;
         case IPL_TYPE_FCP:
                 return IPL_FCP_STR;
+        case IPL_TYPE_FCP_DUMP:
+                return IPL_FCP_DUMP_STR;
         case IPL_TYPE_NSS:
                 return IPL_NSS_STR;
         case IPL_TYPE_UNKNOWN:
@@ -67,15 +52,55 @@ static char *ipl_type_str(enum ipl_type type)
         }
 }
 
+enum dump_type {
+        DUMP_TYPE_NONE  = 1,
+        DUMP_TYPE_CCW   = 2,
+        DUMP_TYPE_FCP   = 4,
+};
+
+#define DUMP_NONE_STR    "none"
+#define DUMP_CCW_STR     "ccw"
+#define DUMP_FCP_STR     "fcp"
+
+static char *dump_type_str(enum dump_type type)
+{
+        switch (type) {
+        case DUMP_TYPE_NONE:
+                return DUMP_NONE_STR;
+        case DUMP_TYPE_CCW:
+                return DUMP_CCW_STR;
+        case DUMP_TYPE_FCP:
+                return DUMP_FCP_STR;
+        default:
+                return NULL;
+        }
+}
+
+/*
+ * Must be in data section since the bss section
+ * is not cleared when these are accessed.
+ */
+static u16 ipl_devno __attribute__((__section__(".data"))) = 0;
+u32 ipl_flags __attribute__((__section__(".data"))) = 0;
+
 enum ipl_method {
-        IPL_METHOD_NONE,
-        IPL_METHOD_CCW_CIO,
-        IPL_METHOD_CCW_DIAG,
-        IPL_METHOD_CCW_VM,
-        IPL_METHOD_FCP_RO_DIAG,
-        IPL_METHOD_FCP_RW_DIAG,
-        IPL_METHOD_FCP_RO_VM,
-        IPL_METHOD_NSS,
+        REIPL_METHOD_CCW_CIO,
+        REIPL_METHOD_CCW_DIAG,
+        REIPL_METHOD_CCW_VM,
+        REIPL_METHOD_FCP_RO_DIAG,
+        REIPL_METHOD_FCP_RW_DIAG,
+        REIPL_METHOD_FCP_RO_VM,
+        REIPL_METHOD_FCP_DUMP,
+        REIPL_METHOD_NSS,
+        REIPL_METHOD_DEFAULT,
+};
+
+enum dump_method {
+        DUMP_METHOD_NONE,
+        DUMP_METHOD_CCW_CIO,
+        DUMP_METHOD_CCW_DIAG,
+        DUMP_METHOD_CCW_VM,
+        DUMP_METHOD_FCP_DIAG,
 };
 
 enum shutdown_action {
@@ -107,15 +132,15 @@ static int diag308_set_works = 0;
 static int reipl_capabilities = IPL_TYPE_UNKNOWN;
 
 static enum ipl_type reipl_type = IPL_TYPE_UNKNOWN;
-static enum ipl_method reipl_method = IPL_METHOD_NONE;
+static enum ipl_method reipl_method = REIPL_METHOD_DEFAULT;
 static struct ipl_parameter_block *reipl_block_fcp;
 static struct ipl_parameter_block *reipl_block_ccw;
 
 static char reipl_nss_name[NSS_NAME_SIZE + 1];
 
-static int dump_capabilities = IPL_TYPE_NONE;
-static enum ipl_type dump_type = IPL_TYPE_NONE;
-static enum ipl_method dump_method = IPL_METHOD_NONE;
+static int dump_capabilities = DUMP_TYPE_NONE;
+static enum dump_type dump_type = DUMP_TYPE_NONE;
+static enum dump_method dump_method = DUMP_METHOD_NONE;
 static struct ipl_parameter_block *dump_block_fcp;
 static struct ipl_parameter_block *dump_block_ccw;
 
@@ -134,6 +159,7 @@ int diag308(unsigned long subcode, void *addr)
                 : "d" (subcode) : "cc", "memory");
         return _rc;
 }
+EXPORT_SYMBOL_GPL(diag308);
 
 /* SYSFS */
 
@@ -197,7 +223,7 @@ static void make_attrs_ro(struct attribute **attrs)
  * ipl section
  */
 
-static enum ipl_type ipl_get_type(void)
+static __init enum ipl_type get_ipl_type(void)
 {
         struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
 
@@ -211,12 +237,44 @@ static enum ipl_type ipl_get_type(void)
                 return IPL_TYPE_UNKNOWN;
         if (ipl->hdr.pbt != DIAG308_IPL_TYPE_FCP)
                 return IPL_TYPE_UNKNOWN;
+        if (ipl->ipl_info.fcp.opt == DIAG308_IPL_OPT_DUMP)
+                return IPL_TYPE_FCP_DUMP;
         return IPL_TYPE_FCP;
 }
 
+void __init setup_ipl_info(void)
+{
+        ipl_info.type = get_ipl_type();
+        switch (ipl_info.type) {
+        case IPL_TYPE_CCW:
+                ipl_info.data.ccw.dev_id.devno = ipl_devno;
+                ipl_info.data.ccw.dev_id.ssid = 0;
+                break;
+        case IPL_TYPE_FCP:
+        case IPL_TYPE_FCP_DUMP:
+                ipl_info.data.fcp.dev_id.devno =
+                        IPL_PARMBLOCK_START->ipl_info.fcp.devno;
+                ipl_info.data.fcp.dev_id.ssid = 0;
+                ipl_info.data.fcp.wwpn = IPL_PARMBLOCK_START->ipl_info.fcp.wwpn;
+                ipl_info.data.fcp.lun = IPL_PARMBLOCK_START->ipl_info.fcp.lun;
+                break;
+        case IPL_TYPE_NSS:
+                strncpy(ipl_info.data.nss.name, kernel_nss_name,
+                        sizeof(ipl_info.data.nss.name));
+                break;
+        case IPL_TYPE_UNKNOWN:
+        default:
+                /* We have no info to copy */
+                break;
+        }
+}
+
+struct ipl_info ipl_info;
+EXPORT_SYMBOL_GPL(ipl_info);
+
 static ssize_t ipl_type_show(struct subsystem *subsys, char *page)
 {
-        return sprintf(page, "%s\n", ipl_type_str(ipl_get_type()));
+        return sprintf(page, "%s\n", ipl_type_str(ipl_info.type));
 }
 
 static struct subsys_attribute sys_ipl_type_attr = __ATTR_RO(ipl_type);
@@ -225,10 +283,11 @@ static ssize_t sys_ipl_device_show(struct subsystem *subsys, char *page)
 {
         struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
 
-        switch (ipl_get_type()) {
+        switch (ipl_info.type) {
         case IPL_TYPE_CCW:
                 return sprintf(page, "0.0.%04x\n", ipl_devno);
         case IPL_TYPE_FCP:
+        case IPL_TYPE_FCP_DUMP:
                 return sprintf(page, "0.0.%04x\n", ipl->ipl_info.fcp.devno);
         default:
                 return 0;
@@ -485,23 +544,29 @@ static int reipl_set_type(enum ipl_type type)
         switch(type) {
         case IPL_TYPE_CCW:
                 if (MACHINE_IS_VM)
-                        reipl_method = IPL_METHOD_CCW_VM;
+                        reipl_method = REIPL_METHOD_CCW_VM;
                 else
-                        reipl_method = IPL_METHOD_CCW_CIO;
+                        reipl_method = REIPL_METHOD_CCW_CIO;
                 break;
         case IPL_TYPE_FCP:
                 if (diag308_set_works)
-                        reipl_method = IPL_METHOD_FCP_RW_DIAG;
+                        reipl_method = REIPL_METHOD_FCP_RW_DIAG;
                 else if (MACHINE_IS_VM)
-                        reipl_method = IPL_METHOD_FCP_RO_VM;
+                        reipl_method = REIPL_METHOD_FCP_RO_VM;
                 else
-                        reipl_method = IPL_METHOD_FCP_RO_DIAG;
+                        reipl_method = REIPL_METHOD_FCP_RO_DIAG;
+                break;
+        case IPL_TYPE_FCP_DUMP:
+                reipl_method = REIPL_METHOD_FCP_DUMP;
                 break;
         case IPL_TYPE_NSS:
-                reipl_method = IPL_METHOD_NSS;
+                reipl_method = REIPL_METHOD_NSS;
+                break;
+        case IPL_TYPE_UNKNOWN:
+                reipl_method = REIPL_METHOD_DEFAULT;
                 break;
         default:
-                reipl_method = IPL_METHOD_NONE;
+                BUG();
         }
         reipl_type = type;
         return 0;
@@ -579,22 +644,22 @@ static struct attribute_group dump_ccw_attr_group = {
 
 /* dump type */
 
-static int dump_set_type(enum ipl_type type)
+static int dump_set_type(enum dump_type type)
 {
         if (!(dump_capabilities & type))
                 return -EINVAL;
         switch(type) {
-        case IPL_TYPE_CCW:
+        case DUMP_TYPE_CCW:
                 if (MACHINE_IS_VM)
-                        dump_method = IPL_METHOD_CCW_VM;
+                        dump_method = DUMP_METHOD_CCW_VM;
                 else
-                        dump_method = IPL_METHOD_CCW_CIO;
+                        dump_method = DUMP_METHOD_CCW_CIO;
                 break;
-        case IPL_TYPE_FCP:
-                dump_method = IPL_METHOD_FCP_RW_DIAG;
+        case DUMP_TYPE_FCP:
+                dump_method = DUMP_METHOD_FCP_DIAG;
                 break;
         default:
-                dump_method = IPL_METHOD_NONE;
+                dump_method = DUMP_METHOD_NONE;
         }
         dump_type = type;
         return 0;
@@ -602,7 +667,7 @@ static int dump_set_type(enum ipl_type type)
 
 static ssize_t dump_type_show(struct subsystem *subsys, char *page)
 {
-        return sprintf(page, "%s\n", ipl_type_str(dump_type));
+        return sprintf(page, "%s\n", dump_type_str(dump_type));
 }
 
 static ssize_t dump_type_store(struct subsystem *subsys, const char *buf,
@@ -610,12 +675,12 @@ static ssize_t dump_type_store(struct subsystem *subsys, const char *buf,
 {
         int rc = -EINVAL;
 
-        if (strncmp(buf, IPL_NONE_STR, strlen(IPL_NONE_STR)) == 0)
-                rc = dump_set_type(IPL_TYPE_NONE);
-        else if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
-                rc = dump_set_type(IPL_TYPE_CCW);
-        else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
-                rc = dump_set_type(IPL_TYPE_FCP);
+        if (strncmp(buf, DUMP_NONE_STR, strlen(DUMP_NONE_STR)) == 0)
+                rc = dump_set_type(DUMP_TYPE_NONE);
+        else if (strncmp(buf, DUMP_CCW_STR, strlen(DUMP_CCW_STR)) == 0)
+                rc = dump_set_type(DUMP_TYPE_CCW);
+        else if (strncmp(buf, DUMP_FCP_STR, strlen(DUMP_FCP_STR)) == 0)
+                rc = dump_set_type(DUMP_TYPE_FCP);
         return (rc != 0) ? rc : len;
 }
 
@@ -664,14 +729,14 @@ void do_reipl(void)
         char loadparm[LOADPARM_LEN + 1];
 
         switch (reipl_method) {
-        case IPL_METHOD_CCW_CIO:
+        case REIPL_METHOD_CCW_CIO:
                 devid.devno = reipl_block_ccw->ipl_info.ccw.devno;
-                if (ipl_get_type() == IPL_TYPE_CCW && devid.devno == ipl_devno)
+                if (ipl_info.type == IPL_TYPE_CCW && devid.devno == ipl_devno)
                         diag308(DIAG308_IPL, NULL);
                 devid.ssid  = 0;
                 reipl_ccw_dev(&devid);
                 break;
-        case IPL_METHOD_CCW_VM:
+        case REIPL_METHOD_CCW_VM:
                 reipl_get_ascii_loadparm(loadparm);
                 if (strlen(loadparm) == 0)
                         sprintf(buf, "IPL %X",
@@ -681,30 +746,32 @@ void do_reipl(void)
                                 reipl_block_ccw->ipl_info.ccw.devno, loadparm);
                 __cpcmd(buf, NULL, 0, NULL);
                 break;
-        case IPL_METHOD_CCW_DIAG:
+        case REIPL_METHOD_CCW_DIAG:
                 diag308(DIAG308_SET, reipl_block_ccw);
                 diag308(DIAG308_IPL, NULL);
                 break;
-        case IPL_METHOD_FCP_RW_DIAG:
+        case REIPL_METHOD_FCP_RW_DIAG:
                 diag308(DIAG308_SET, reipl_block_fcp);
                 diag308(DIAG308_IPL, NULL);
                 break;
-        case IPL_METHOD_FCP_RO_DIAG:
+        case REIPL_METHOD_FCP_RO_DIAG:
                 diag308(DIAG308_IPL, NULL);
                 break;
-        case IPL_METHOD_FCP_RO_VM:
+        case REIPL_METHOD_FCP_RO_VM:
                 __cpcmd("IPL", NULL, 0, NULL);
                 break;
-        case IPL_METHOD_NSS:
+        case REIPL_METHOD_NSS:
                 sprintf(buf, "IPL %s", reipl_nss_name);
                 __cpcmd(buf, NULL, 0, NULL);
                 break;
-        case IPL_METHOD_NONE:
-        default:
+        case REIPL_METHOD_DEFAULT:
                 if (MACHINE_IS_VM)
                         __cpcmd("IPL", NULL, 0, NULL);
                 diag308(DIAG308_IPL, NULL);
                 break;
+        case REIPL_METHOD_FCP_DUMP:
+        default:
+                break;
         }
         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
 }
@@ -715,28 +782,28 @@ static void do_dump(void)
         static char buf[100];
 
         switch (dump_method) {
-        case IPL_METHOD_CCW_CIO:
+        case DUMP_METHOD_CCW_CIO:
                 smp_send_stop();
                 devid.devno = dump_block_ccw->ipl_info.ccw.devno;
                 devid.ssid  = 0;
                 reipl_ccw_dev(&devid);
                 break;
-        case IPL_METHOD_CCW_VM:
+        case DUMP_METHOD_CCW_VM:
                 smp_send_stop();
                 sprintf(buf, "STORE STATUS");
                 __cpcmd(buf, NULL, 0, NULL);
                 sprintf(buf, "IPL %X", dump_block_ccw->ipl_info.ccw.devno);
                 __cpcmd(buf, NULL, 0, NULL);
                 break;
-        case IPL_METHOD_CCW_DIAG:
+        case DUMP_METHOD_CCW_DIAG:
                 diag308(DIAG308_SET, dump_block_ccw);
                 diag308(DIAG308_DUMP, NULL);
                 break;
-        case IPL_METHOD_FCP_RW_DIAG:
+        case DUMP_METHOD_FCP_DIAG:
                 diag308(DIAG308_SET, dump_block_fcp);
                 diag308(DIAG308_DUMP, NULL);
                 break;
-        case IPL_METHOD_NONE:
+        case DUMP_METHOD_NONE:
         default:
                 return;
         }
@@ -777,12 +844,13 @@ static int __init ipl_init(void)
         rc = firmware_register(&ipl_subsys);
         if (rc)
                 return rc;
-        switch (ipl_get_type()) {
+        switch (ipl_info.type) {
         case IPL_TYPE_CCW:
                 rc = sysfs_create_group(&ipl_subsys.kset.kobj,
                                         &ipl_ccw_attr_group);
                 break;
         case IPL_TYPE_FCP:
+        case IPL_TYPE_FCP_DUMP:
                 rc = ipl_register_fcp_files();
                 break;
         case IPL_TYPE_NSS:
@@ -852,7 +920,7 @@ static int __init reipl_ccw_init(void)
         /* FIXME: check for diag308_set_works when enabling diag ccw reipl */
         if (!MACHINE_IS_VM)
                 sys_reipl_ccw_loadparm_attr.attr.mode = S_IRUGO;
-        if (ipl_get_type() == IPL_TYPE_CCW)
+        if (ipl_info.type == IPL_TYPE_CCW)
                 reipl_block_ccw->ipl_info.ccw.devno = ipl_devno;
         reipl_capabilities |= IPL_TYPE_CCW;
         return 0;
@@ -862,9 +930,9 @@ static int __init reipl_fcp_init(void)
 {
         int rc;
 
-        if ((!diag308_set_works) && (ipl_get_type() != IPL_TYPE_FCP))
+        if ((!diag308_set_works) && (ipl_info.type != IPL_TYPE_FCP))
                 return 0;
-        if ((!diag308_set_works) && (ipl_get_type() == IPL_TYPE_FCP))
+        if ((!diag308_set_works) && (ipl_info.type == IPL_TYPE_FCP))
                 make_attrs_ro(reipl_fcp_attrs);
 
         reipl_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
@@ -875,7 +943,7 @@ static int __init reipl_fcp_init(void)
                 free_page((unsigned long)reipl_block_fcp);
                 return rc;
         }
-        if (ipl_get_type() == IPL_TYPE_FCP) {
+        if (ipl_info.type == IPL_TYPE_FCP) {
                 memcpy(reipl_block_fcp, IPL_PARMBLOCK_START, PAGE_SIZE);
         } else {
                 reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
@@ -909,7 +977,7 @@ static int __init reipl_init(void)
         rc = reipl_nss_init();
         if (rc)
                 return rc;
-        rc = reipl_set_type(ipl_get_type());
+        rc = reipl_set_type(ipl_info.type);
         if (rc)
                 return rc;
         return 0;
@@ -931,7 +999,7 @@ static int __init dump_ccw_init(void)
         dump_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
         dump_block_ccw->hdr.blk0_len = IPL_PARM_BLK0_CCW_LEN;
         dump_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
-        dump_capabilities |= IPL_TYPE_CCW;
+        dump_capabilities |= DUMP_TYPE_CCW;
         return 0;
 }
 
@@ -956,7 +1024,7 @@ static int __init dump_fcp_init(void)
         dump_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN;
         dump_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
         dump_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_DUMP;
-        dump_capabilities |= IPL_TYPE_FCP;
+        dump_capabilities |= DUMP_TYPE_FCP;
         return 0;
 }
 
@@ -995,7 +1063,7 @@ static int __init dump_init(void)
         rc = dump_fcp_init();
         if (rc)
                 return rc;
-        dump_set_type(IPL_TYPE_NONE);
+        dump_set_type(DUMP_TYPE_NONE);
         return 0;
 }
 
@@ -1038,6 +1106,27 @@ static int __init s390_ipl_init(void)
 
 __initcall(s390_ipl_init);
 
+void __init ipl_save_parameters(void)
+{
+        struct cio_iplinfo iplinfo;
+        unsigned int *ipl_ptr;
+        void *src, *dst;
+
+        if (cio_get_iplinfo(&iplinfo))
+                return;
+
+        ipl_devno = iplinfo.devno;
+        ipl_flags |= IPL_DEVNO_VALID;
+        if (!iplinfo.is_qdio)
+                return;
+        ipl_flags |= IPL_PARMBLOCK_VALID;
+        ipl_ptr = (unsigned int *)__LC_IPL_PARMBLOCK_PTR;
+        src = (void *)(unsigned long)*ipl_ptr;
+        dst = (void *)IPL_PARMBLOCK_ORIGIN;
+        memmove(dst, src, PAGE_SIZE);
+        *ipl_ptr = IPL_PARMBLOCK_ORIGIN;
+}
+
 static LIST_HEAD(rcall);
 static DEFINE_MUTEX(rcall_mutex);