1
2
3
4
5
6
7
8
9#define KMSG_COMPONENT "sclp_cmd"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
12#include <linux/completion.h>
13#include <linux/init.h>
14#include <linux/errno.h>
15#include <linux/slab.h>
16#include <linux/string.h>
17#include <linux/mm.h>
18#include <linux/mmzone.h>
19#include <linux/memory.h>
20#include <asm/chpid.h>
21#include <asm/sclp.h>
22#include <asm/setup.h>
23
24#include "sclp.h"
25
26#define SCLP_CMDW_READ_SCP_INFO 0x00020001
27#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
28
29struct read_info_sccb {
30 struct sccb_header header;
31 u16 rnmax;
32 u8 rnsize;
33 u8 _reserved0[24 - 11];
34 u8 loadparm[8];
35 u8 _reserved1[48 - 32];
36 u64 facilities;
37 u8 _reserved2[84 - 56];
38 u8 fac84;
39 u8 _reserved3[91 - 85];
40 u8 flags;
41 u8 _reserved4[100 - 92];
42 u32 rnsize2;
43 u64 rnmax2;
44 u8 _reserved5[4096 - 112];
45} __attribute__((packed, aligned(PAGE_SIZE)));
46
47static struct read_info_sccb __initdata early_read_info_sccb;
48static int __initdata early_read_info_sccb_valid;
49
50u64 sclp_facilities;
51static u8 sclp_fac84;
52static unsigned long long rzm;
53static unsigned long long rnmax;
54
55static int __init sclp_cmd_sync_early(sclp_cmdw_t cmd, void *sccb)
56{
57 int rc;
58
59 __ctl_set_bit(0, 9);
60 rc = sclp_service_call(cmd, sccb);
61 if (rc)
62 goto out;
63 __load_psw_mask(PSW_BASE_BITS | PSW_MASK_EXT |
64 PSW_MASK_WAIT | PSW_DEFAULT_KEY);
65 local_irq_disable();
66out:
67
68 barrier();
69 __ctl_clear_bit(0, 9);
70 return rc;
71}
72
73static void __init sclp_read_info_early(void)
74{
75 int rc;
76 int i;
77 struct read_info_sccb *sccb;
78 sclp_cmdw_t commands[] = {SCLP_CMDW_READ_SCP_INFO_FORCED,
79 SCLP_CMDW_READ_SCP_INFO};
80
81 sccb = &early_read_info_sccb;
82 for (i = 0; i < ARRAY_SIZE(commands); i++) {
83 do {
84 memset(sccb, 0, sizeof(*sccb));
85 sccb->header.length = sizeof(*sccb);
86 sccb->header.control_mask[2] = 0x80;
87 rc = sclp_cmd_sync_early(commands[i], sccb);
88 } while (rc == -EBUSY);
89
90 if (rc)
91 break;
92 if (sccb->header.response_code == 0x10) {
93 early_read_info_sccb_valid = 1;
94 break;
95 }
96 if (sccb->header.response_code != 0x1f0)
97 break;
98 }
99}
100
101void __init sclp_facilities_detect(void)
102{
103 struct read_info_sccb *sccb;
104
105 sclp_read_info_early();
106 if (!early_read_info_sccb_valid)
107 return;
108
109 sccb = &early_read_info_sccb;
110 sclp_facilities = sccb->facilities;
111 sclp_fac84 = sccb->fac84;
112 rnmax = sccb->rnmax ? sccb->rnmax : sccb->rnmax2;
113 rzm = sccb->rnsize ? sccb->rnsize : sccb->rnsize2;
114 rzm <<= 20;
115}
116
117unsigned long long sclp_get_rnmax(void)
118{
119 return rnmax;
120}
121
122unsigned long long sclp_get_rzm(void)
123{
124 return rzm;
125}
126
127
128
129
130
131void __init sclp_get_ipl_info(struct sclp_ipl_info *info)
132{
133 struct read_info_sccb *sccb;
134
135 if (!early_read_info_sccb_valid)
136 return;
137 sccb = &early_read_info_sccb;
138 info->is_valid = 1;
139 if (sccb->flags & 0x2)
140 info->has_dump = 1;
141 memcpy(&info->loadparm, &sccb->loadparm, LOADPARM_LEN);
142}
143
144static void sclp_sync_callback(struct sclp_req *req, void *data)
145{
146 struct completion *completion = data;
147
148 complete(completion);
149}
150
151static int do_sync_request(sclp_cmdw_t cmd, void *sccb)
152{
153 struct completion completion;
154 struct sclp_req *request;
155 int rc;
156
157 request = kzalloc(sizeof(*request), GFP_KERNEL);
158 if (!request)
159 return -ENOMEM;
160 request->command = cmd;
161 request->sccb = sccb;
162 request->status = SCLP_REQ_FILLED;
163 request->callback = sclp_sync_callback;
164 request->callback_data = &completion;
165 init_completion(&completion);
166
167
168 rc = sclp_add_request(request);
169 if (rc)
170 goto out;
171 wait_for_completion(&completion);
172
173
174 if (request->status != SCLP_REQ_DONE) {
175 pr_warning("sync request failed (cmd=0x%08x, "
176 "status=0x%02x)\n", cmd, request->status);
177 rc = -EIO;
178 }
179out:
180 kfree(request);
181 return rc;
182}
183
184
185
186
187
188#define SCLP_CMDW_READ_CPU_INFO 0x00010001
189#define SCLP_CMDW_CONFIGURE_CPU 0x00110001
190#define SCLP_CMDW_DECONFIGURE_CPU 0x00100001
191
192struct read_cpu_info_sccb {
193 struct sccb_header header;
194 u16 nr_configured;
195 u16 offset_configured;
196 u16 nr_standby;
197 u16 offset_standby;
198 u8 reserved[4096 - 16];
199} __attribute__((packed, aligned(PAGE_SIZE)));
200
201static void sclp_fill_cpu_info(struct sclp_cpu_info *info,
202 struct read_cpu_info_sccb *sccb)
203{
204 char *page = (char *) sccb;
205
206 memset(info, 0, sizeof(*info));
207 info->configured = sccb->nr_configured;
208 info->standby = sccb->nr_standby;
209 info->combined = sccb->nr_configured + sccb->nr_standby;
210 info->has_cpu_type = sclp_fac84 & 0x1;
211 memcpy(&info->cpu, page + sccb->offset_configured,
212 info->combined * sizeof(struct sclp_cpu_entry));
213}
214
215int sclp_get_cpu_info(struct sclp_cpu_info *info)
216{
217 int rc;
218 struct read_cpu_info_sccb *sccb;
219
220 if (!SCLP_HAS_CPU_INFO)
221 return -EOPNOTSUPP;
222 sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
223 if (!sccb)
224 return -ENOMEM;
225 sccb->header.length = sizeof(*sccb);
226 rc = do_sync_request(SCLP_CMDW_READ_CPU_INFO, sccb);
227 if (rc)
228 goto out;
229 if (sccb->header.response_code != 0x0010) {
230 pr_warning("readcpuinfo failed (response=0x%04x)\n",
231 sccb->header.response_code);
232 rc = -EIO;
233 goto out;
234 }
235 sclp_fill_cpu_info(info, sccb);
236out:
237 free_page((unsigned long) sccb);
238 return rc;
239}
240
241struct cpu_configure_sccb {
242 struct sccb_header header;
243} __attribute__((packed, aligned(8)));
244
245static int do_cpu_configure(sclp_cmdw_t cmd)
246{
247 struct cpu_configure_sccb *sccb;
248 int rc;
249
250 if (!SCLP_HAS_CPU_RECONFIG)
251 return -EOPNOTSUPP;
252
253
254
255
256 sccb = kzalloc(sizeof(*sccb), GFP_KERNEL | GFP_DMA);
257 if (!sccb)
258 return -ENOMEM;
259 sccb->header.length = sizeof(*sccb);
260 rc = do_sync_request(cmd, sccb);
261 if (rc)
262 goto out;
263 switch (sccb->header.response_code) {
264 case 0x0020:
265 case 0x0120:
266 break;
267 default:
268 pr_warning("configure cpu failed (cmd=0x%08x, "
269 "response=0x%04x)\n", cmd,
270 sccb->header.response_code);
271 rc = -EIO;
272 break;
273 }
274out:
275 kfree(sccb);
276 return rc;
277}
278
279int sclp_cpu_configure(u8 cpu)
280{
281 return do_cpu_configure(SCLP_CMDW_CONFIGURE_CPU | cpu << 8);
282}
283
284int sclp_cpu_deconfigure(u8 cpu)
285{
286 return do_cpu_configure(SCLP_CMDW_DECONFIGURE_CPU | cpu << 8);
287}
288
289#ifdef CONFIG_MEMORY_HOTPLUG
290
291static DEFINE_MUTEX(sclp_mem_mutex);
292static LIST_HEAD(sclp_mem_list);
293static u8 sclp_max_storage_id;
294static unsigned long sclp_storage_ids[256 / BITS_PER_LONG];
295
296struct memory_increment {
297 struct list_head list;
298 u16 rn;
299 int standby;
300 int usecount;
301};
302
303struct assign_storage_sccb {
304 struct sccb_header header;
305 u16 rn;
306} __packed;
307
308static unsigned long long rn2addr(u16 rn)
309{
310 return (unsigned long long) (rn - 1) * rzm;
311}
312
313static int do_assign_storage(sclp_cmdw_t cmd, u16 rn)
314{
315 struct assign_storage_sccb *sccb;
316 int rc;
317
318 sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
319 if (!sccb)
320 return -ENOMEM;
321 sccb->header.length = PAGE_SIZE;
322 sccb->rn = rn;
323 rc = do_sync_request(cmd, sccb);
324 if (rc)
325 goto out;
326 switch (sccb->header.response_code) {
327 case 0x0020:
328 case 0x0120:
329 break;
330 default:
331 pr_warning("assign storage failed (cmd=0x%08x, "
332 "response=0x%04x, rn=0x%04x)\n", cmd,
333 sccb->header.response_code, rn);
334 rc = -EIO;
335 break;
336 }
337out:
338 free_page((unsigned long) sccb);
339 return rc;
340}
341
342static int sclp_assign_storage(u16 rn)
343{
344 return do_assign_storage(0x000d0001, rn);
345}
346
347static int sclp_unassign_storage(u16 rn)
348{
349 return do_assign_storage(0x000c0001, rn);
350}
351
352struct attach_storage_sccb {
353 struct sccb_header header;
354 u16 :16;
355 u16 assigned;
356 u32 :32;
357 u32 entries[0];
358} __packed;
359
360static int sclp_attach_storage(u8 id)
361{
362 struct attach_storage_sccb *sccb;
363 int rc;
364 int i;
365
366 sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
367 if (!sccb)
368 return -ENOMEM;
369 sccb->header.length = PAGE_SIZE;
370 rc = do_sync_request(0x00080001 | id << 8, sccb);
371 if (rc)
372 goto out;
373 switch (sccb->header.response_code) {
374 case 0x0020:
375 set_bit(id, sclp_storage_ids);
376 for (i = 0; i < sccb->assigned; i++)
377 sclp_unassign_storage(sccb->entries[i] >> 16);
378 break;
379 default:
380 rc = -EIO;
381 break;
382 }
383out:
384 free_page((unsigned long) sccb);
385 return rc;
386}
387
388static int sclp_mem_change_state(unsigned long start, unsigned long size,
389 int online)
390{
391 struct memory_increment *incr;
392 unsigned long long istart;
393 int rc = 0;
394
395 list_for_each_entry(incr, &sclp_mem_list, list) {
396 istart = rn2addr(incr->rn);
397 if (start + size - 1 < istart)
398 break;
399 if (start > istart + rzm - 1)
400 continue;
401 if (online) {
402 if (incr->usecount++)
403 continue;
404
405
406
407
408
409
410 rc |= sclp_assign_storage(incr->rn);
411 } else {
412 if (--incr->usecount)
413 continue;
414 sclp_unassign_storage(incr->rn);
415 }
416 }
417 return rc ? -EIO : 0;
418}
419
420static int sclp_mem_notifier(struct notifier_block *nb,
421 unsigned long action, void *data)
422{
423 unsigned long start, size;
424 struct memory_notify *arg;
425 unsigned char id;
426 int rc = 0;
427
428 arg = data;
429 start = arg->start_pfn << PAGE_SHIFT;
430 size = arg->nr_pages << PAGE_SHIFT;
431 mutex_lock(&sclp_mem_mutex);
432 for (id = 0; id <= sclp_max_storage_id; id++)
433 if (!test_bit(id, sclp_storage_ids))
434 sclp_attach_storage(id);
435 switch (action) {
436 case MEM_ONLINE:
437 case MEM_GOING_OFFLINE:
438 case MEM_CANCEL_OFFLINE:
439 break;
440 case MEM_GOING_ONLINE:
441 rc = sclp_mem_change_state(start, size, 1);
442 break;
443 case MEM_CANCEL_ONLINE:
444 sclp_mem_change_state(start, size, 0);
445 break;
446 case MEM_OFFLINE:
447 sclp_mem_change_state(start, size, 0);
448 break;
449 default:
450 rc = -EINVAL;
451 break;
452 }
453 mutex_unlock(&sclp_mem_mutex);
454 return rc ? NOTIFY_BAD : NOTIFY_OK;
455}
456
457static struct notifier_block sclp_mem_nb = {
458 .notifier_call = sclp_mem_notifier,
459};
460
461static void __init add_memory_merged(u16 rn)
462{
463 static u16 first_rn, num;
464 unsigned long long start, size;
465
466 if (rn && first_rn && (first_rn + num == rn)) {
467 num++;
468 return;
469 }
470 if (!first_rn)
471 goto skip_add;
472 start = rn2addr(first_rn);
473 size = (unsigned long long ) num * rzm;
474 if (start >= VMEM_MAX_PHYS)
475 goto skip_add;
476 if (start + size > VMEM_MAX_PHYS)
477 size = VMEM_MAX_PHYS - start;
478 if (memory_end_set && (start >= memory_end))
479 goto skip_add;
480 if (memory_end_set && (start + size > memory_end))
481 size = memory_end - start;
482 add_memory(0, start, size);
483skip_add:
484 first_rn = rn;
485 num = 1;
486}
487
488static void __init sclp_add_standby_memory(void)
489{
490 struct memory_increment *incr;
491
492 list_for_each_entry(incr, &sclp_mem_list, list)
493 if (incr->standby)
494 add_memory_merged(incr->rn);
495 add_memory_merged(0);
496}
497
498static void __init insert_increment(u16 rn, int standby, int assigned)
499{
500 struct memory_increment *incr, *new_incr;
501 struct list_head *prev;
502 u16 last_rn;
503
504 new_incr = kzalloc(sizeof(*new_incr), GFP_KERNEL);
505 if (!new_incr)
506 return;
507 new_incr->rn = rn;
508 new_incr->standby = standby;
509 last_rn = 0;
510 prev = &sclp_mem_list;
511 list_for_each_entry(incr, &sclp_mem_list, list) {
512 if (assigned && incr->rn > rn)
513 break;
514 if (!assigned && incr->rn - last_rn > 1)
515 break;
516 last_rn = incr->rn;
517 prev = &incr->list;
518 }
519 if (!assigned)
520 new_incr->rn = last_rn + 1;
521 if (new_incr->rn > rnmax) {
522 kfree(new_incr);
523 return;
524 }
525 list_add(&new_incr->list, prev);
526}
527
528struct read_storage_sccb {
529 struct sccb_header header;
530 u16 max_id;
531 u16 assigned;
532 u16 standby;
533 u16 :16;
534 u32 entries[0];
535} __packed;
536
537static int __init sclp_detect_standby_memory(void)
538{
539 struct read_storage_sccb *sccb;
540 int i, id, assigned, rc;
541
542 if (!early_read_info_sccb_valid)
543 return 0;
544 if ((sclp_facilities & 0xe00000000000ULL) != 0xe00000000000ULL)
545 return 0;
546 rc = -ENOMEM;
547 sccb = (void *) __get_free_page(GFP_KERNEL | GFP_DMA);
548 if (!sccb)
549 goto out;
550 assigned = 0;
551 for (id = 0; id <= sclp_max_storage_id; id++) {
552 memset(sccb, 0, PAGE_SIZE);
553 sccb->header.length = PAGE_SIZE;
554 rc = do_sync_request(0x00040001 | id << 8, sccb);
555 if (rc)
556 goto out;
557 switch (sccb->header.response_code) {
558 case 0x0010:
559 set_bit(id, sclp_storage_ids);
560 for (i = 0; i < sccb->assigned; i++) {
561 if (!sccb->entries[i])
562 continue;
563 assigned++;
564 insert_increment(sccb->entries[i] >> 16, 0, 1);
565 }
566 break;
567 case 0x0310:
568 break;
569 case 0x0410:
570 for (i = 0; i < sccb->assigned; i++) {
571 if (!sccb->entries[i])
572 continue;
573 assigned++;
574 insert_increment(sccb->entries[i] >> 16, 1, 1);
575 }
576 break;
577 default:
578 rc = -EIO;
579 break;
580 }
581 if (!rc)
582 sclp_max_storage_id = sccb->max_id;
583 }
584 if (rc || list_empty(&sclp_mem_list))
585 goto out;
586 for (i = 1; i <= rnmax - assigned; i++)
587 insert_increment(0, 1, 0);
588 rc = register_memory_notifier(&sclp_mem_nb);
589 if (rc)
590 goto out;
591 sclp_add_standby_memory();
592out:
593 free_page((unsigned long) sccb);
594 return rc;
595}
596__initcall(sclp_detect_standby_memory);
597
598#endif
599
600
601
602
603
604#define SCLP_CMDW_CONFIGURE_CHPATH 0x000f0001
605#define SCLP_CMDW_DECONFIGURE_CHPATH 0x000e0001
606#define SCLP_CMDW_READ_CHPATH_INFORMATION 0x00030001
607
608struct chp_cfg_sccb {
609 struct sccb_header header;
610 u8 ccm;
611 u8 reserved[6];
612 u8 cssid;
613} __attribute__((packed));
614
615static int do_chp_configure(sclp_cmdw_t cmd)
616{
617 struct chp_cfg_sccb *sccb;
618 int rc;
619
620 if (!SCLP_HAS_CHP_RECONFIG)
621 return -EOPNOTSUPP;
622
623 sccb = (struct chp_cfg_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
624 if (!sccb)
625 return -ENOMEM;
626 sccb->header.length = sizeof(*sccb);
627 rc = do_sync_request(cmd, sccb);
628 if (rc)
629 goto out;
630 switch (sccb->header.response_code) {
631 case 0x0020:
632 case 0x0120:
633 case 0x0440:
634 case 0x0450:
635 break;
636 default:
637 pr_warning("configure channel-path failed "
638 "(cmd=0x%08x, response=0x%04x)\n", cmd,
639 sccb->header.response_code);
640 rc = -EIO;
641 break;
642 }
643out:
644 free_page((unsigned long) sccb);
645 return rc;
646}
647
648
649
650
651
652
653
654
655int sclp_chp_configure(struct chp_id chpid)
656{
657 return do_chp_configure(SCLP_CMDW_CONFIGURE_CHPATH | chpid.id << 8);
658}
659
660
661
662
663
664
665
666
667int sclp_chp_deconfigure(struct chp_id chpid)
668{
669 return do_chp_configure(SCLP_CMDW_DECONFIGURE_CHPATH | chpid.id << 8);
670}
671
672struct chp_info_sccb {
673 struct sccb_header header;
674 u8 recognized[SCLP_CHP_INFO_MASK_SIZE];
675 u8 standby[SCLP_CHP_INFO_MASK_SIZE];
676 u8 configured[SCLP_CHP_INFO_MASK_SIZE];
677 u8 ccm;
678 u8 reserved[6];
679 u8 cssid;
680} __attribute__((packed));
681
682
683
684
685
686
687
688
689
690int sclp_chp_read_info(struct sclp_chp_info *info)
691{
692 struct chp_info_sccb *sccb;
693 int rc;
694
695 if (!SCLP_HAS_CHP_INFO)
696 return -EOPNOTSUPP;
697
698 sccb = (struct chp_info_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
699 if (!sccb)
700 return -ENOMEM;
701 sccb->header.length = sizeof(*sccb);
702 rc = do_sync_request(SCLP_CMDW_READ_CHPATH_INFORMATION, sccb);
703 if (rc)
704 goto out;
705 if (sccb->header.response_code != 0x0010) {
706 pr_warning("read channel-path info failed "
707 "(response=0x%04x)\n", sccb->header.response_code);
708 rc = -EIO;
709 goto out;
710 }
711 memcpy(info->recognized, sccb->recognized, SCLP_CHP_INFO_MASK_SIZE);
712 memcpy(info->standby, sccb->standby, SCLP_CHP_INFO_MASK_SIZE);
713 memcpy(info->configured, sccb->configured, SCLP_CHP_INFO_MASK_SIZE);
714out:
715 free_page((unsigned long) sccb);
716 return rc;
717}
718
