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