Merge git://git.kernel.org/pub/scm/linux/kernel/git/holtmann/bluetooth-2.6
[linux-2.6] / arch / s390 / kernel / ipl.c
1 /*
2  *  arch/s390/kernel/ipl.c
3  *    ipl/reipl/dump support for Linux on s390.
4  *
5  *    Copyright (C) IBM Corp. 2005,2006
6  *    Author(s): Michael Holzheu <holzheu@de.ibm.com>
7  *               Heiko Carstens <heiko.carstens@de.ibm.com>
8  *               Volker Sameske <sameske@de.ibm.com>
9  */
10
11 #include <linux/types.h>
12 #include <linux/module.h>
13 #include <linux/device.h>
14 #include <linux/delay.h>
15 #include <linux/reboot.h>
16 #include <linux/ctype.h>
17 #include <asm/ipl.h>
18 #include <asm/smp.h>
19 #include <asm/setup.h>
20 #include <asm/cpcmd.h>
21 #include <asm/cio.h>
22 #include <asm/ebcdic.h>
23 #include <asm/reset.h>
24 #include <asm/sclp.h>
25
26 #define IPL_PARM_BLOCK_VERSION 0
27
28 #define SCCB_VALID (s390_readinfo_sccb.header.response_code == 0x10)
29 #define SCCB_LOADPARM (&s390_readinfo_sccb.loadparm)
30 #define SCCB_FLAG (s390_readinfo_sccb.flags)
31
32 #define IPL_UNKNOWN_STR         "unknown"
33 #define IPL_CCW_STR             "ccw"
34 #define IPL_FCP_STR             "fcp"
35 #define IPL_FCP_DUMP_STR        "fcp_dump"
36 #define IPL_NSS_STR             "nss"
37
38 static char *ipl_type_str(enum ipl_type type)
39 {
40         switch (type) {
41         case IPL_TYPE_CCW:
42                 return IPL_CCW_STR;
43         case IPL_TYPE_FCP:
44                 return IPL_FCP_STR;
45         case IPL_TYPE_FCP_DUMP:
46                 return IPL_FCP_DUMP_STR;
47         case IPL_TYPE_NSS:
48                 return IPL_NSS_STR;
49         case IPL_TYPE_UNKNOWN:
50         default:
51                 return IPL_UNKNOWN_STR;
52         }
53 }
54
55 enum dump_type {
56         DUMP_TYPE_NONE  = 1,
57         DUMP_TYPE_CCW   = 2,
58         DUMP_TYPE_FCP   = 4,
59 };
60
61 #define DUMP_NONE_STR    "none"
62 #define DUMP_CCW_STR     "ccw"
63 #define DUMP_FCP_STR     "fcp"
64
65 static char *dump_type_str(enum dump_type type)
66 {
67         switch (type) {
68         case DUMP_TYPE_NONE:
69                 return DUMP_NONE_STR;
70         case DUMP_TYPE_CCW:
71                 return DUMP_CCW_STR;
72         case DUMP_TYPE_FCP:
73                 return DUMP_FCP_STR;
74         default:
75                 return NULL;
76         }
77 }
78
79 /*
80  * Must be in data section since the bss section
81  * is not cleared when these are accessed.
82  */
83 static u16 ipl_devno __attribute__((__section__(".data"))) = 0;
84 u32 ipl_flags __attribute__((__section__(".data"))) = 0;
85
86 enum ipl_method {
87         REIPL_METHOD_CCW_CIO,
88         REIPL_METHOD_CCW_DIAG,
89         REIPL_METHOD_CCW_VM,
90         REIPL_METHOD_FCP_RO_DIAG,
91         REIPL_METHOD_FCP_RW_DIAG,
92         REIPL_METHOD_FCP_RO_VM,
93         REIPL_METHOD_FCP_DUMP,
94         REIPL_METHOD_NSS,
95         REIPL_METHOD_DEFAULT,
96 };
97
98 enum dump_method {
99         DUMP_METHOD_NONE,
100         DUMP_METHOD_CCW_CIO,
101         DUMP_METHOD_CCW_DIAG,
102         DUMP_METHOD_CCW_VM,
103         DUMP_METHOD_FCP_DIAG,
104 };
105
106 enum shutdown_action {
107         SHUTDOWN_REIPL,
108         SHUTDOWN_DUMP,
109         SHUTDOWN_STOP,
110 };
111
112 #define SHUTDOWN_REIPL_STR "reipl"
113 #define SHUTDOWN_DUMP_STR  "dump"
114 #define SHUTDOWN_STOP_STR  "stop"
115
116 static char *shutdown_action_str(enum shutdown_action action)
117 {
118         switch (action) {
119         case SHUTDOWN_REIPL:
120                 return SHUTDOWN_REIPL_STR;
121         case SHUTDOWN_DUMP:
122                 return SHUTDOWN_DUMP_STR;
123         case SHUTDOWN_STOP:
124                 return SHUTDOWN_STOP_STR;
125         default:
126                 return NULL;
127         }
128 }
129
130 static int diag308_set_works = 0;
131
132 static int reipl_capabilities = IPL_TYPE_UNKNOWN;
133
134 static enum ipl_type reipl_type = IPL_TYPE_UNKNOWN;
135 static enum ipl_method reipl_method = REIPL_METHOD_DEFAULT;
136 static struct ipl_parameter_block *reipl_block_fcp;
137 static struct ipl_parameter_block *reipl_block_ccw;
138
139 static char reipl_nss_name[NSS_NAME_SIZE + 1];
140
141 static int dump_capabilities = DUMP_TYPE_NONE;
142 static enum dump_type dump_type = DUMP_TYPE_NONE;
143 static enum dump_method dump_method = DUMP_METHOD_NONE;
144 static struct ipl_parameter_block *dump_block_fcp;
145 static struct ipl_parameter_block *dump_block_ccw;
146
147 static enum shutdown_action on_panic_action = SHUTDOWN_STOP;
148
149 int diag308(unsigned long subcode, void *addr)
150 {
151         register unsigned long _addr asm("0") = (unsigned long) addr;
152         register unsigned long _rc asm("1") = 0;
153
154         asm volatile(
155                 "       diag    %0,%2,0x308\n"
156                 "0:\n"
157                 EX_TABLE(0b,0b)
158                 : "+d" (_addr), "+d" (_rc)
159                 : "d" (subcode) : "cc", "memory");
160         return _rc;
161 }
162 EXPORT_SYMBOL_GPL(diag308);
163
164 /* SYSFS */
165
166 #define DEFINE_IPL_ATTR_RO(_prefix, _name, _format, _value)             \
167 static ssize_t sys_##_prefix##_##_name##_show(struct kset *kset,        \
168                 char *page)                                             \
169 {                                                                       \
170         return sprintf(page, _format, _value);                          \
171 }                                                                       \
172 static struct subsys_attribute sys_##_prefix##_##_name##_attr =         \
173         __ATTR(_name, S_IRUGO, sys_##_prefix##_##_name##_show, NULL);
174
175 #define DEFINE_IPL_ATTR_RW(_prefix, _name, _fmt_out, _fmt_in, _value)   \
176 static ssize_t sys_##_prefix##_##_name##_show(struct kset *kset,        \
177                 char *page)                                             \
178 {                                                                       \
179         return sprintf(page, _fmt_out,                                  \
180                         (unsigned long long) _value);                   \
181 }                                                                       \
182 static ssize_t sys_##_prefix##_##_name##_store(struct kset *kset,       \
183                 const char *buf, size_t len)                            \
184 {                                                                       \
185         unsigned long long value;                                       \
186         if (sscanf(buf, _fmt_in, &value) != 1)                          \
187                 return -EINVAL;                                         \
188         _value = value;                                                 \
189         return len;                                                     \
190 }                                                                       \
191 static struct subsys_attribute sys_##_prefix##_##_name##_attr =         \
192         __ATTR(_name,(S_IRUGO | S_IWUSR),                               \
193                         sys_##_prefix##_##_name##_show,                 \
194                         sys_##_prefix##_##_name##_store);
195
196 #define DEFINE_IPL_ATTR_STR_RW(_prefix, _name, _fmt_out, _fmt_in, _value)\
197 static ssize_t sys_##_prefix##_##_name##_show(struct kset *kset,        \
198                 char *page)                                             \
199 {                                                                       \
200         return sprintf(page, _fmt_out, _value);                         \
201 }                                                                       \
202 static ssize_t sys_##_prefix##_##_name##_store(struct kset *kset,       \
203                 const char *buf, size_t len)                            \
204 {                                                                       \
205         if (sscanf(buf, _fmt_in, _value) != 1)                          \
206                 return -EINVAL;                                         \
207         return len;                                                     \
208 }                                                                       \
209 static struct subsys_attribute sys_##_prefix##_##_name##_attr =         \
210         __ATTR(_name,(S_IRUGO | S_IWUSR),                               \
211                         sys_##_prefix##_##_name##_show,                 \
212                         sys_##_prefix##_##_name##_store);
213
214 static void make_attrs_ro(struct attribute **attrs)
215 {
216         while (*attrs) {
217                 (*attrs)->mode = S_IRUGO;
218                 attrs++;
219         }
220 }
221
222 /*
223  * ipl section
224  */
225
226 static __init enum ipl_type get_ipl_type(void)
227 {
228         struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
229
230         if (ipl_flags & IPL_NSS_VALID)
231                 return IPL_TYPE_NSS;
232         if (!(ipl_flags & IPL_DEVNO_VALID))
233                 return IPL_TYPE_UNKNOWN;
234         if (!(ipl_flags & IPL_PARMBLOCK_VALID))
235                 return IPL_TYPE_CCW;
236         if (ipl->hdr.version > IPL_MAX_SUPPORTED_VERSION)
237                 return IPL_TYPE_UNKNOWN;
238         if (ipl->hdr.pbt != DIAG308_IPL_TYPE_FCP)
239                 return IPL_TYPE_UNKNOWN;
240         if (ipl->ipl_info.fcp.opt == DIAG308_IPL_OPT_DUMP)
241                 return IPL_TYPE_FCP_DUMP;
242         return IPL_TYPE_FCP;
243 }
244
245 void __init setup_ipl_info(void)
246 {
247         ipl_info.type = get_ipl_type();
248         switch (ipl_info.type) {
249         case IPL_TYPE_CCW:
250                 ipl_info.data.ccw.dev_id.devno = ipl_devno;
251                 ipl_info.data.ccw.dev_id.ssid = 0;
252                 break;
253         case IPL_TYPE_FCP:
254         case IPL_TYPE_FCP_DUMP:
255                 ipl_info.data.fcp.dev_id.devno =
256                         IPL_PARMBLOCK_START->ipl_info.fcp.devno;
257                 ipl_info.data.fcp.dev_id.ssid = 0;
258                 ipl_info.data.fcp.wwpn = IPL_PARMBLOCK_START->ipl_info.fcp.wwpn;
259                 ipl_info.data.fcp.lun = IPL_PARMBLOCK_START->ipl_info.fcp.lun;
260                 break;
261         case IPL_TYPE_NSS:
262                 strncpy(ipl_info.data.nss.name, kernel_nss_name,
263                         sizeof(ipl_info.data.nss.name));
264                 break;
265         case IPL_TYPE_UNKNOWN:
266         default:
267                 /* We have no info to copy */
268                 break;
269         }
270 }
271
272 struct ipl_info ipl_info;
273 EXPORT_SYMBOL_GPL(ipl_info);
274
275 static ssize_t ipl_type_show(struct kset *kset, char *page)
276 {
277         return sprintf(page, "%s\n", ipl_type_str(ipl_info.type));
278 }
279
280 static struct subsys_attribute sys_ipl_type_attr = __ATTR_RO(ipl_type);
281
282 static ssize_t sys_ipl_device_show(struct kset *kset, char *page)
283 {
284         struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
285
286         switch (ipl_info.type) {
287         case IPL_TYPE_CCW:
288                 return sprintf(page, "0.0.%04x\n", ipl_devno);
289         case IPL_TYPE_FCP:
290         case IPL_TYPE_FCP_DUMP:
291                 return sprintf(page, "0.0.%04x\n", ipl->ipl_info.fcp.devno);
292         default:
293                 return 0;
294         }
295 }
296
297 static struct subsys_attribute sys_ipl_device_attr =
298         __ATTR(device, S_IRUGO, sys_ipl_device_show, NULL);
299
300 static ssize_t ipl_parameter_read(struct kobject *kobj, char *buf, loff_t off,
301                                   size_t count)
302 {
303         unsigned int size = IPL_PARMBLOCK_SIZE;
304
305         if (off > size)
306                 return 0;
307         if (off + count > size)
308                 count = size - off;
309         memcpy(buf, (void *)IPL_PARMBLOCK_START + off, count);
310         return count;
311 }
312
313 static struct bin_attribute ipl_parameter_attr = {
314         .attr = {
315                 .name = "binary_parameter",
316                 .mode = S_IRUGO,
317                 .owner = THIS_MODULE,
318         },
319         .size = PAGE_SIZE,
320         .read = &ipl_parameter_read,
321 };
322
323 static ssize_t ipl_scp_data_read(struct kobject *kobj, char *buf, loff_t off,
324         size_t count)
325 {
326         unsigned int size = IPL_PARMBLOCK_START->ipl_info.fcp.scp_data_len;
327         void *scp_data = &IPL_PARMBLOCK_START->ipl_info.fcp.scp_data;
328
329         if (off > size)
330                 return 0;
331         if (off + count > size)
332                 count = size - off;
333         memcpy(buf, scp_data + off, count);
334         return count;
335 }
336
337 static struct bin_attribute ipl_scp_data_attr = {
338         .attr = {
339                 .name = "scp_data",
340                 .mode = S_IRUGO,
341                 .owner = THIS_MODULE,
342         },
343         .size = PAGE_SIZE,
344         .read = &ipl_scp_data_read,
345 };
346
347 /* FCP ipl device attributes */
348
349 DEFINE_IPL_ATTR_RO(ipl_fcp, wwpn, "0x%016llx\n", (unsigned long long)
350                    IPL_PARMBLOCK_START->ipl_info.fcp.wwpn);
351 DEFINE_IPL_ATTR_RO(ipl_fcp, lun, "0x%016llx\n", (unsigned long long)
352                    IPL_PARMBLOCK_START->ipl_info.fcp.lun);
353 DEFINE_IPL_ATTR_RO(ipl_fcp, bootprog, "%lld\n", (unsigned long long)
354                    IPL_PARMBLOCK_START->ipl_info.fcp.bootprog);
355 DEFINE_IPL_ATTR_RO(ipl_fcp, br_lba, "%lld\n", (unsigned long long)
356                    IPL_PARMBLOCK_START->ipl_info.fcp.br_lba);
357
358 static struct attribute *ipl_fcp_attrs[] = {
359         &sys_ipl_type_attr.attr,
360         &sys_ipl_device_attr.attr,
361         &sys_ipl_fcp_wwpn_attr.attr,
362         &sys_ipl_fcp_lun_attr.attr,
363         &sys_ipl_fcp_bootprog_attr.attr,
364         &sys_ipl_fcp_br_lba_attr.attr,
365         NULL,
366 };
367
368 static struct attribute_group ipl_fcp_attr_group = {
369         .attrs = ipl_fcp_attrs,
370 };
371
372 /* CCW ipl device attributes */
373
374 static ssize_t ipl_ccw_loadparm_show(struct kset *kset, char *page)
375 {
376         char loadparm[LOADPARM_LEN + 1] = {};
377
378         if (!SCCB_VALID)
379                 return sprintf(page, "#unknown#\n");
380         memcpy(loadparm, SCCB_LOADPARM, LOADPARM_LEN);
381         EBCASC(loadparm, LOADPARM_LEN);
382         strstrip(loadparm);
383         return sprintf(page, "%s\n", loadparm);
384 }
385
386 static struct subsys_attribute sys_ipl_ccw_loadparm_attr =
387         __ATTR(loadparm, 0444, ipl_ccw_loadparm_show, NULL);
388
389 static struct attribute *ipl_ccw_attrs[] = {
390         &sys_ipl_type_attr.attr,
391         &sys_ipl_device_attr.attr,
392         &sys_ipl_ccw_loadparm_attr.attr,
393         NULL,
394 };
395
396 static struct attribute_group ipl_ccw_attr_group = {
397         .attrs = ipl_ccw_attrs,
398 };
399
400 /* NSS ipl device attributes */
401
402 DEFINE_IPL_ATTR_RO(ipl_nss, name, "%s\n", kernel_nss_name);
403
404 static struct attribute *ipl_nss_attrs[] = {
405         &sys_ipl_type_attr.attr,
406         &sys_ipl_nss_name_attr.attr,
407         NULL,
408 };
409
410 static struct attribute_group ipl_nss_attr_group = {
411         .attrs = ipl_nss_attrs,
412 };
413
414 /* UNKNOWN ipl device attributes */
415
416 static struct attribute *ipl_unknown_attrs[] = {
417         &sys_ipl_type_attr.attr,
418         NULL,
419 };
420
421 static struct attribute_group ipl_unknown_attr_group = {
422         .attrs = ipl_unknown_attrs,
423 };
424
425 static decl_subsys(ipl, NULL, NULL);
426
427 /*
428  * reipl section
429  */
430
431 /* FCP reipl device attributes */
432
433 DEFINE_IPL_ATTR_RW(reipl_fcp, wwpn, "0x%016llx\n", "%016llx\n",
434                    reipl_block_fcp->ipl_info.fcp.wwpn);
435 DEFINE_IPL_ATTR_RW(reipl_fcp, lun, "0x%016llx\n", "%016llx\n",
436                    reipl_block_fcp->ipl_info.fcp.lun);
437 DEFINE_IPL_ATTR_RW(reipl_fcp, bootprog, "%lld\n", "%lld\n",
438                    reipl_block_fcp->ipl_info.fcp.bootprog);
439 DEFINE_IPL_ATTR_RW(reipl_fcp, br_lba, "%lld\n", "%lld\n",
440                    reipl_block_fcp->ipl_info.fcp.br_lba);
441 DEFINE_IPL_ATTR_RW(reipl_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
442                    reipl_block_fcp->ipl_info.fcp.devno);
443
444 static struct attribute *reipl_fcp_attrs[] = {
445         &sys_reipl_fcp_device_attr.attr,
446         &sys_reipl_fcp_wwpn_attr.attr,
447         &sys_reipl_fcp_lun_attr.attr,
448         &sys_reipl_fcp_bootprog_attr.attr,
449         &sys_reipl_fcp_br_lba_attr.attr,
450         NULL,
451 };
452
453 static struct attribute_group reipl_fcp_attr_group = {
454         .name  = IPL_FCP_STR,
455         .attrs = reipl_fcp_attrs,
456 };
457
458 /* CCW reipl device attributes */
459
460 DEFINE_IPL_ATTR_RW(reipl_ccw, device, "0.0.%04llx\n", "0.0.%llx\n",
461         reipl_block_ccw->ipl_info.ccw.devno);
462
463 static void reipl_get_ascii_loadparm(char *loadparm)
464 {
465         memcpy(loadparm, &reipl_block_ccw->ipl_info.ccw.load_param,
466                LOADPARM_LEN);
467         EBCASC(loadparm, LOADPARM_LEN);
468         loadparm[LOADPARM_LEN] = 0;
469         strstrip(loadparm);
470 }
471
472 static ssize_t reipl_ccw_loadparm_show(struct kset *kset, char *page)
473 {
474         char buf[LOADPARM_LEN + 1];
475
476         reipl_get_ascii_loadparm(buf);
477         return sprintf(page, "%s\n", buf);
478 }
479
480 static ssize_t reipl_ccw_loadparm_store(struct kset *kset,
481                                         const char *buf, size_t len)
482 {
483         int i, lp_len;
484
485         /* ignore trailing newline */
486         lp_len = len;
487         if ((len > 0) && (buf[len - 1] == '\n'))
488                 lp_len--;
489         /* loadparm can have max 8 characters and must not start with a blank */
490         if ((lp_len > LOADPARM_LEN) || ((lp_len > 0) && (buf[0] == ' ')))
491                 return -EINVAL;
492         /* loadparm can only contain "a-z,A-Z,0-9,SP,." */
493         for (i = 0; i < lp_len; i++) {
494                 if (isalpha(buf[i]) || isdigit(buf[i]) || (buf[i] == ' ') ||
495                     (buf[i] == '.'))
496                         continue;
497                 return -EINVAL;
498         }
499         /* initialize loadparm with blanks */
500         memset(&reipl_block_ccw->ipl_info.ccw.load_param, ' ', LOADPARM_LEN);
501         /* copy and convert to ebcdic */
502         memcpy(&reipl_block_ccw->ipl_info.ccw.load_param, buf, lp_len);
503         ASCEBC(reipl_block_ccw->ipl_info.ccw.load_param, LOADPARM_LEN);
504         return len;
505 }
506
507 static struct subsys_attribute sys_reipl_ccw_loadparm_attr =
508         __ATTR(loadparm, 0644, reipl_ccw_loadparm_show,
509                reipl_ccw_loadparm_store);
510
511 static struct attribute *reipl_ccw_attrs[] = {
512         &sys_reipl_ccw_device_attr.attr,
513         &sys_reipl_ccw_loadparm_attr.attr,
514         NULL,
515 };
516
517 static struct attribute_group reipl_ccw_attr_group = {
518         .name  = IPL_CCW_STR,
519         .attrs = reipl_ccw_attrs,
520 };
521
522
523 /* NSS reipl device attributes */
524
525 DEFINE_IPL_ATTR_STR_RW(reipl_nss, name, "%s\n", "%s\n", reipl_nss_name);
526
527 static struct attribute *reipl_nss_attrs[] = {
528         &sys_reipl_nss_name_attr.attr,
529         NULL,
530 };
531
532 static struct attribute_group reipl_nss_attr_group = {
533         .name  = IPL_NSS_STR,
534         .attrs = reipl_nss_attrs,
535 };
536
537 /* reipl type */
538
539 static int reipl_set_type(enum ipl_type type)
540 {
541         if (!(reipl_capabilities & type))
542                 return -EINVAL;
543
544         switch(type) {
545         case IPL_TYPE_CCW:
546                 if (MACHINE_IS_VM)
547                         reipl_method = REIPL_METHOD_CCW_VM;
548                 else
549                         reipl_method = REIPL_METHOD_CCW_CIO;
550                 break;
551         case IPL_TYPE_FCP:
552                 if (diag308_set_works)
553                         reipl_method = REIPL_METHOD_FCP_RW_DIAG;
554                 else if (MACHINE_IS_VM)
555                         reipl_method = REIPL_METHOD_FCP_RO_VM;
556                 else
557                         reipl_method = REIPL_METHOD_FCP_RO_DIAG;
558                 break;
559         case IPL_TYPE_FCP_DUMP:
560                 reipl_method = REIPL_METHOD_FCP_DUMP;
561                 break;
562         case IPL_TYPE_NSS:
563                 reipl_method = REIPL_METHOD_NSS;
564                 break;
565         case IPL_TYPE_UNKNOWN:
566                 reipl_method = REIPL_METHOD_DEFAULT;
567                 break;
568         default:
569                 BUG();
570         }
571         reipl_type = type;
572         return 0;
573 }
574
575 static ssize_t reipl_type_show(struct kset *kset, char *page)
576 {
577         return sprintf(page, "%s\n", ipl_type_str(reipl_type));
578 }
579
580 static ssize_t reipl_type_store(struct kset *kset, const char *buf,
581                                 size_t len)
582 {
583         int rc = -EINVAL;
584
585         if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
586                 rc = reipl_set_type(IPL_TYPE_CCW);
587         else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
588                 rc = reipl_set_type(IPL_TYPE_FCP);
589         else if (strncmp(buf, IPL_NSS_STR, strlen(IPL_NSS_STR)) == 0)
590                 rc = reipl_set_type(IPL_TYPE_NSS);
591         return (rc != 0) ? rc : len;
592 }
593
594 static struct subsys_attribute reipl_type_attr =
595                 __ATTR(reipl_type, 0644, reipl_type_show, reipl_type_store);
596
597 static decl_subsys(reipl, NULL, NULL);
598
599 /*
600  * dump section
601  */
602
603 /* FCP dump device attributes */
604
605 DEFINE_IPL_ATTR_RW(dump_fcp, wwpn, "0x%016llx\n", "%016llx\n",
606                    dump_block_fcp->ipl_info.fcp.wwpn);
607 DEFINE_IPL_ATTR_RW(dump_fcp, lun, "0x%016llx\n", "%016llx\n",
608                    dump_block_fcp->ipl_info.fcp.lun);
609 DEFINE_IPL_ATTR_RW(dump_fcp, bootprog, "%lld\n", "%lld\n",
610                    dump_block_fcp->ipl_info.fcp.bootprog);
611 DEFINE_IPL_ATTR_RW(dump_fcp, br_lba, "%lld\n", "%lld\n",
612                    dump_block_fcp->ipl_info.fcp.br_lba);
613 DEFINE_IPL_ATTR_RW(dump_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
614                    dump_block_fcp->ipl_info.fcp.devno);
615
616 static struct attribute *dump_fcp_attrs[] = {
617         &sys_dump_fcp_device_attr.attr,
618         &sys_dump_fcp_wwpn_attr.attr,
619         &sys_dump_fcp_lun_attr.attr,
620         &sys_dump_fcp_bootprog_attr.attr,
621         &sys_dump_fcp_br_lba_attr.attr,
622         NULL,
623 };
624
625 static struct attribute_group dump_fcp_attr_group = {
626         .name  = IPL_FCP_STR,
627         .attrs = dump_fcp_attrs,
628 };
629
630 /* CCW dump device attributes */
631
632 DEFINE_IPL_ATTR_RW(dump_ccw, device, "0.0.%04llx\n", "0.0.%llx\n",
633                    dump_block_ccw->ipl_info.ccw.devno);
634
635 static struct attribute *dump_ccw_attrs[] = {
636         &sys_dump_ccw_device_attr.attr,
637         NULL,
638 };
639
640 static struct attribute_group dump_ccw_attr_group = {
641         .name  = IPL_CCW_STR,
642         .attrs = dump_ccw_attrs,
643 };
644
645 /* dump type */
646
647 static int dump_set_type(enum dump_type type)
648 {
649         if (!(dump_capabilities & type))
650                 return -EINVAL;
651         switch(type) {
652         case DUMP_TYPE_CCW:
653                 if (MACHINE_IS_VM)
654                         dump_method = DUMP_METHOD_CCW_VM;
655                 else
656                         dump_method = DUMP_METHOD_CCW_CIO;
657                 break;
658         case DUMP_TYPE_FCP:
659                 dump_method = DUMP_METHOD_FCP_DIAG;
660                 break;
661         default:
662                 dump_method = DUMP_METHOD_NONE;
663         }
664         dump_type = type;
665         return 0;
666 }
667
668 static ssize_t dump_type_show(struct kset *kset, char *page)
669 {
670         return sprintf(page, "%s\n", dump_type_str(dump_type));
671 }
672
673 static ssize_t dump_type_store(struct kset *kset, const char *buf,
674                                size_t len)
675 {
676         int rc = -EINVAL;
677
678         if (strncmp(buf, DUMP_NONE_STR, strlen(DUMP_NONE_STR)) == 0)
679                 rc = dump_set_type(DUMP_TYPE_NONE);
680         else if (strncmp(buf, DUMP_CCW_STR, strlen(DUMP_CCW_STR)) == 0)
681                 rc = dump_set_type(DUMP_TYPE_CCW);
682         else if (strncmp(buf, DUMP_FCP_STR, strlen(DUMP_FCP_STR)) == 0)
683                 rc = dump_set_type(DUMP_TYPE_FCP);
684         return (rc != 0) ? rc : len;
685 }
686
687 static struct subsys_attribute dump_type_attr =
688                 __ATTR(dump_type, 0644, dump_type_show, dump_type_store);
689
690 static decl_subsys(dump, NULL, NULL);
691
692 /*
693  * Shutdown actions section
694  */
695
696 static decl_subsys(shutdown_actions, NULL, NULL);
697
698 /* on panic */
699
700 static ssize_t on_panic_show(struct kset *kset, char *page)
701 {
702         return sprintf(page, "%s\n", shutdown_action_str(on_panic_action));
703 }
704
705 static ssize_t on_panic_store(struct kset *kset, const char *buf,
706                               size_t len)
707 {
708         if (strncmp(buf, SHUTDOWN_REIPL_STR, strlen(SHUTDOWN_REIPL_STR)) == 0)
709                 on_panic_action = SHUTDOWN_REIPL;
710         else if (strncmp(buf, SHUTDOWN_DUMP_STR,
711                          strlen(SHUTDOWN_DUMP_STR)) == 0)
712                 on_panic_action = SHUTDOWN_DUMP;
713         else if (strncmp(buf, SHUTDOWN_STOP_STR,
714                          strlen(SHUTDOWN_STOP_STR)) == 0)
715                 on_panic_action = SHUTDOWN_STOP;
716         else
717                 return -EINVAL;
718
719         return len;
720 }
721
722 static struct subsys_attribute on_panic_attr =
723                 __ATTR(on_panic, 0644, on_panic_show, on_panic_store);
724
725 void do_reipl(void)
726 {
727         struct ccw_dev_id devid;
728         static char buf[100];
729         char loadparm[LOADPARM_LEN + 1];
730
731         switch (reipl_method) {
732         case REIPL_METHOD_CCW_CIO:
733                 devid.devno = reipl_block_ccw->ipl_info.ccw.devno;
734                 if (ipl_info.type == IPL_TYPE_CCW && devid.devno == ipl_devno)
735                         diag308(DIAG308_IPL, NULL);
736                 devid.ssid  = 0;
737                 reipl_ccw_dev(&devid);
738                 break;
739         case REIPL_METHOD_CCW_VM:
740                 reipl_get_ascii_loadparm(loadparm);
741                 if (strlen(loadparm) == 0)
742                         sprintf(buf, "IPL %X",
743                                 reipl_block_ccw->ipl_info.ccw.devno);
744                 else
745                         sprintf(buf, "IPL %X LOADPARM '%s'",
746                                 reipl_block_ccw->ipl_info.ccw.devno, loadparm);
747                 __cpcmd(buf, NULL, 0, NULL);
748                 break;
749         case REIPL_METHOD_CCW_DIAG:
750                 diag308(DIAG308_SET, reipl_block_ccw);
751                 diag308(DIAG308_IPL, NULL);
752                 break;
753         case REIPL_METHOD_FCP_RW_DIAG:
754                 diag308(DIAG308_SET, reipl_block_fcp);
755                 diag308(DIAG308_IPL, NULL);
756                 break;
757         case REIPL_METHOD_FCP_RO_DIAG:
758                 diag308(DIAG308_IPL, NULL);
759                 break;
760         case REIPL_METHOD_FCP_RO_VM:
761                 __cpcmd("IPL", NULL, 0, NULL);
762                 break;
763         case REIPL_METHOD_NSS:
764                 sprintf(buf, "IPL %s", reipl_nss_name);
765                 __cpcmd(buf, NULL, 0, NULL);
766                 break;
767         case REIPL_METHOD_DEFAULT:
768                 if (MACHINE_IS_VM)
769                         __cpcmd("IPL", NULL, 0, NULL);
770                 diag308(DIAG308_IPL, NULL);
771                 break;
772         case REIPL_METHOD_FCP_DUMP:
773         default:
774                 break;
775         }
776         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
777 }
778
779 static void do_dump(void)
780 {
781         struct ccw_dev_id devid;
782         static char buf[100];
783
784         switch (dump_method) {
785         case DUMP_METHOD_CCW_CIO:
786                 smp_send_stop();
787                 devid.devno = dump_block_ccw->ipl_info.ccw.devno;
788                 devid.ssid  = 0;
789                 reipl_ccw_dev(&devid);
790                 break;
791         case DUMP_METHOD_CCW_VM:
792                 smp_send_stop();
793                 sprintf(buf, "STORE STATUS");
794                 __cpcmd(buf, NULL, 0, NULL);
795                 sprintf(buf, "IPL %X", dump_block_ccw->ipl_info.ccw.devno);
796                 __cpcmd(buf, NULL, 0, NULL);
797                 break;
798         case DUMP_METHOD_CCW_DIAG:
799                 diag308(DIAG308_SET, dump_block_ccw);
800                 diag308(DIAG308_DUMP, NULL);
801                 break;
802         case DUMP_METHOD_FCP_DIAG:
803                 diag308(DIAG308_SET, dump_block_fcp);
804                 diag308(DIAG308_DUMP, NULL);
805                 break;
806         case DUMP_METHOD_NONE:
807         default:
808                 return;
809         }
810         printk(KERN_EMERG "Dump failed!\n");
811 }
812
813 /* init functions */
814
815 static int __init ipl_register_fcp_files(void)
816 {
817         int rc;
818
819         rc = sysfs_create_group(&ipl_subsys.kset.kobj,
820                                 &ipl_fcp_attr_group);
821         if (rc)
822                 goto out;
823         rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
824                                    &ipl_parameter_attr);
825         if (rc)
826                 goto out_ipl_parm;
827         rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
828                                    &ipl_scp_data_attr);
829         if (!rc)
830                 goto out;
831
832         sysfs_remove_bin_file(&ipl_subsys.kset.kobj, &ipl_parameter_attr);
833
834 out_ipl_parm:
835         sysfs_remove_group(&ipl_subsys.kset.kobj, &ipl_fcp_attr_group);
836 out:
837         return rc;
838 }
839
840 static int __init ipl_init(void)
841 {
842         int rc;
843
844         rc = firmware_register(&ipl_subsys);
845         if (rc)
846                 return rc;
847         switch (ipl_info.type) {
848         case IPL_TYPE_CCW:
849                 rc = sysfs_create_group(&ipl_subsys.kset.kobj,
850                                         &ipl_ccw_attr_group);
851                 break;
852         case IPL_TYPE_FCP:
853         case IPL_TYPE_FCP_DUMP:
854                 rc = ipl_register_fcp_files();
855                 break;
856         case IPL_TYPE_NSS:
857                 rc = sysfs_create_group(&ipl_subsys.kset.kobj,
858                                         &ipl_nss_attr_group);
859                 break;
860         default:
861                 rc = sysfs_create_group(&ipl_subsys.kset.kobj,
862                                         &ipl_unknown_attr_group);
863                 break;
864         }
865         if (rc)
866                 firmware_unregister(&ipl_subsys);
867         return rc;
868 }
869
870 static void __init reipl_probe(void)
871 {
872         void *buffer;
873
874         buffer = (void *) get_zeroed_page(GFP_KERNEL);
875         if (!buffer)
876                 return;
877         if (diag308(DIAG308_STORE, buffer) == DIAG308_RC_OK)
878                 diag308_set_works = 1;
879         free_page((unsigned long)buffer);
880 }
881
882 static int __init reipl_nss_init(void)
883 {
884         int rc;
885
886         if (!MACHINE_IS_VM)
887                 return 0;
888         rc = sysfs_create_group(&reipl_subsys.kset.kobj, &reipl_nss_attr_group);
889         if (rc)
890                 return rc;
891         strncpy(reipl_nss_name, kernel_nss_name, NSS_NAME_SIZE + 1);
892         reipl_capabilities |= IPL_TYPE_NSS;
893         return 0;
894 }
895
896 static int __init reipl_ccw_init(void)
897 {
898         int rc;
899
900         reipl_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
901         if (!reipl_block_ccw)
902                 return -ENOMEM;
903         rc = sysfs_create_group(&reipl_subsys.kset.kobj, &reipl_ccw_attr_group);
904         if (rc) {
905                 free_page((unsigned long)reipl_block_ccw);
906                 return rc;
907         }
908         reipl_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN;
909         reipl_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
910         reipl_block_ccw->hdr.blk0_len = IPL_PARM_BLK0_CCW_LEN;
911         reipl_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
912         /* check if read scp info worked and set loadparm */
913         if (SCCB_VALID)
914                 memcpy(reipl_block_ccw->ipl_info.ccw.load_param,
915                        SCCB_LOADPARM, LOADPARM_LEN);
916         else
917                 /* read scp info failed: set empty loadparm (EBCDIC blanks) */
918                 memset(reipl_block_ccw->ipl_info.ccw.load_param, 0x40,
919                        LOADPARM_LEN);
920         /* FIXME: check for diag308_set_works when enabling diag ccw reipl */
921         if (!MACHINE_IS_VM)
922                 sys_reipl_ccw_loadparm_attr.attr.mode = S_IRUGO;
923         if (ipl_info.type == IPL_TYPE_CCW)
924                 reipl_block_ccw->ipl_info.ccw.devno = ipl_devno;
925         reipl_capabilities |= IPL_TYPE_CCW;
926         return 0;
927 }
928
929 static int __init reipl_fcp_init(void)
930 {
931         int rc;
932
933         if ((!diag308_set_works) && (ipl_info.type != IPL_TYPE_FCP))
934                 return 0;
935         if ((!diag308_set_works) && (ipl_info.type == IPL_TYPE_FCP))
936                 make_attrs_ro(reipl_fcp_attrs);
937
938         reipl_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
939         if (!reipl_block_fcp)
940                 return -ENOMEM;
941         rc = sysfs_create_group(&reipl_subsys.kset.kobj, &reipl_fcp_attr_group);
942         if (rc) {
943                 free_page((unsigned long)reipl_block_fcp);
944                 return rc;
945         }
946         if (ipl_info.type == IPL_TYPE_FCP) {
947                 memcpy(reipl_block_fcp, IPL_PARMBLOCK_START, PAGE_SIZE);
948         } else {
949                 reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
950                 reipl_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
951                 reipl_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN;
952                 reipl_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
953                 reipl_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_IPL;
954         }
955         reipl_capabilities |= IPL_TYPE_FCP;
956         return 0;
957 }
958
959 static int __init reipl_init(void)
960 {
961         int rc;
962
963         rc = firmware_register(&reipl_subsys);
964         if (rc)
965                 return rc;
966         rc = subsys_create_file(&reipl_subsys, &reipl_type_attr);
967         if (rc) {
968                 firmware_unregister(&reipl_subsys);
969                 return rc;
970         }
971         rc = reipl_ccw_init();
972         if (rc)
973                 return rc;
974         rc = reipl_fcp_init();
975         if (rc)
976                 return rc;
977         rc = reipl_nss_init();
978         if (rc)
979                 return rc;
980         rc = reipl_set_type(ipl_info.type);
981         if (rc)
982                 return rc;
983         return 0;
984 }
985
986 static int __init dump_ccw_init(void)
987 {
988         int rc;
989
990         dump_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
991         if (!dump_block_ccw)
992                 return -ENOMEM;
993         rc = sysfs_create_group(&dump_subsys.kset.kobj, &dump_ccw_attr_group);
994         if (rc) {
995                 free_page((unsigned long)dump_block_ccw);
996                 return rc;
997         }
998         dump_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN;
999         dump_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
1000         dump_block_ccw->hdr.blk0_len = IPL_PARM_BLK0_CCW_LEN;
1001         dump_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
1002         dump_capabilities |= DUMP_TYPE_CCW;
1003         return 0;
1004 }
1005
1006 static int __init dump_fcp_init(void)
1007 {
1008         int rc;
1009
1010         if(!(SCCB_FLAG & 0x2) || !SCCB_VALID)
1011                 return 0; /* LDIPL DUMP is not installed */
1012         if (!diag308_set_works)
1013                 return 0;
1014         dump_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
1015         if (!dump_block_fcp)
1016                 return -ENOMEM;
1017         rc = sysfs_create_group(&dump_subsys.kset.kobj, &dump_fcp_attr_group);
1018         if (rc) {
1019                 free_page((unsigned long)dump_block_fcp);
1020                 return rc;
1021         }
1022         dump_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
1023         dump_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
1024         dump_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN;
1025         dump_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
1026         dump_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_DUMP;
1027         dump_capabilities |= DUMP_TYPE_FCP;
1028         return 0;
1029 }
1030
1031 #define SHUTDOWN_ON_PANIC_PRIO 0
1032
1033 static int shutdown_on_panic_notify(struct notifier_block *self,
1034                                     unsigned long event, void *data)
1035 {
1036         if (on_panic_action == SHUTDOWN_DUMP)
1037                 do_dump();
1038         else if (on_panic_action == SHUTDOWN_REIPL)
1039                 do_reipl();
1040         return NOTIFY_OK;
1041 }
1042
1043 static struct notifier_block shutdown_on_panic_nb = {
1044         .notifier_call = shutdown_on_panic_notify,
1045         .priority = SHUTDOWN_ON_PANIC_PRIO
1046 };
1047
1048 static int __init dump_init(void)
1049 {
1050         int rc;
1051
1052         rc = firmware_register(&dump_subsys);
1053         if (rc)
1054                 return rc;
1055         rc = subsys_create_file(&dump_subsys, &dump_type_attr);
1056         if (rc) {
1057                 firmware_unregister(&dump_subsys);
1058                 return rc;
1059         }
1060         rc = dump_ccw_init();
1061         if (rc)
1062                 return rc;
1063         rc = dump_fcp_init();
1064         if (rc)
1065                 return rc;
1066         dump_set_type(DUMP_TYPE_NONE);
1067         return 0;
1068 }
1069
1070 static int __init shutdown_actions_init(void)
1071 {
1072         int rc;
1073
1074         rc = firmware_register(&shutdown_actions_subsys);
1075         if (rc)
1076                 return rc;
1077         rc = subsys_create_file(&shutdown_actions_subsys, &on_panic_attr);
1078         if (rc) {
1079                 firmware_unregister(&shutdown_actions_subsys);
1080                 return rc;
1081         }
1082         atomic_notifier_chain_register(&panic_notifier_list,
1083                                        &shutdown_on_panic_nb);
1084         return 0;
1085 }
1086
1087 static int __init s390_ipl_init(void)
1088 {
1089         int rc;
1090
1091         reipl_probe();
1092         rc = ipl_init();
1093         if (rc)
1094                 return rc;
1095         rc = reipl_init();
1096         if (rc)
1097                 return rc;
1098         rc = dump_init();
1099         if (rc)
1100                 return rc;
1101         rc = shutdown_actions_init();
1102         if (rc)
1103                 return rc;
1104         return 0;
1105 }
1106
1107 __initcall(s390_ipl_init);
1108
1109 void __init ipl_save_parameters(void)
1110 {
1111         struct cio_iplinfo iplinfo;
1112         unsigned int *ipl_ptr;
1113         void *src, *dst;
1114
1115         if (cio_get_iplinfo(&iplinfo))
1116                 return;
1117
1118         ipl_devno = iplinfo.devno;
1119         ipl_flags |= IPL_DEVNO_VALID;
1120         if (!iplinfo.is_qdio)
1121                 return;
1122         ipl_flags |= IPL_PARMBLOCK_VALID;
1123         ipl_ptr = (unsigned int *)__LC_IPL_PARMBLOCK_PTR;
1124         src = (void *)(unsigned long)*ipl_ptr;
1125         dst = (void *)IPL_PARMBLOCK_ORIGIN;
1126         memmove(dst, src, PAGE_SIZE);
1127         *ipl_ptr = IPL_PARMBLOCK_ORIGIN;
1128 }
1129
1130 static LIST_HEAD(rcall);
1131 static DEFINE_MUTEX(rcall_mutex);
1132
1133 void register_reset_call(struct reset_call *reset)
1134 {
1135         mutex_lock(&rcall_mutex);
1136         list_add(&reset->list, &rcall);
1137         mutex_unlock(&rcall_mutex);
1138 }
1139 EXPORT_SYMBOL_GPL(register_reset_call);
1140
1141 void unregister_reset_call(struct reset_call *reset)
1142 {
1143         mutex_lock(&rcall_mutex);
1144         list_del(&reset->list);
1145         mutex_unlock(&rcall_mutex);
1146 }
1147 EXPORT_SYMBOL_GPL(unregister_reset_call);
1148
1149 static void do_reset_calls(void)
1150 {
1151         struct reset_call *reset;
1152
1153         list_for_each_entry(reset, &rcall, list)
1154                 reset->fn();
1155 }
1156
1157 u32 dump_prefix_page;
1158
1159 void s390_reset_system(void)
1160 {
1161         struct _lowcore *lc;
1162
1163         lc = (struct _lowcore *)(unsigned long) store_prefix();
1164
1165         /* Stack for interrupt/machine check handler */
1166         lc->panic_stack = S390_lowcore.panic_stack;
1167
1168         /* Save prefix page address for dump case */
1169         dump_prefix_page = (u32)(unsigned long) lc;
1170
1171         /* Disable prefixing */
1172         set_prefix(0);
1173
1174         /* Disable lowcore protection */
1175         __ctl_clear_bit(0,28);
1176
1177         /* Set new machine check handler */
1178         S390_lowcore.mcck_new_psw.mask = psw_kernel_bits & ~PSW_MASK_MCHECK;
1179         S390_lowcore.mcck_new_psw.addr =
1180                 PSW_ADDR_AMODE | (unsigned long) s390_base_mcck_handler;
1181
1182         /* Set new program check handler */
1183         S390_lowcore.program_new_psw.mask = psw_kernel_bits & ~PSW_MASK_MCHECK;
1184         S390_lowcore.program_new_psw.addr =
1185                 PSW_ADDR_AMODE | (unsigned long) s390_base_pgm_handler;
1186
1187         do_reset_calls();
1188 }