2 * Copyright IBM Corp. 2007,2012
4 * Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>,
5 * Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
8 #define KMSG_COMPONENT "sclp_cmd"
9 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11 #include <linux/completion.h>
12 #include <linux/init.h>
13 #include <linux/errno.h>
14 #include <linux/err.h>
15 #include <linux/export.h>
16 #include <linux/slab.h>
17 #include <linux/string.h>
19 #include <linux/mmzone.h>
20 #include <linux/memory.h>
21 #include <linux/module.h>
22 #include <linux/platform_device.h>
23 #include <asm/ctl_reg.h>
24 #include <asm/chpid.h>
25 #include <asm/setup.h>
32 static void sclp_sync_callback(struct sclp_req *req, void *data)
34 struct completion *completion = data;
39 int sclp_sync_request(sclp_cmdw_t cmd, void *sccb)
41 return sclp_sync_request_timeout(cmd, sccb, 0);
44 int sclp_sync_request_timeout(sclp_cmdw_t cmd, void *sccb, int timeout)
46 struct completion completion;
47 struct sclp_req *request;
50 request = kzalloc(sizeof(*request), GFP_KERNEL);
54 request->queue_timeout = timeout;
55 request->command = cmd;
57 request->status = SCLP_REQ_FILLED;
58 request->callback = sclp_sync_callback;
59 request->callback_data = &completion;
60 init_completion(&completion);
62 /* Perform sclp request. */
63 rc = sclp_add_request(request);
66 wait_for_completion(&completion);
69 if (request->status != SCLP_REQ_DONE) {
70 pr_warn("sync request failed (cmd=0x%08x, status=0x%02x)\n",
71 cmd, request->status);
80 * CPU configuration related functions.
83 #define SCLP_CMDW_READ_CPU_INFO 0x00010001
84 #define SCLP_CMDW_CONFIGURE_CPU 0x00110001
85 #define SCLP_CMDW_DECONFIGURE_CPU 0x00100001
87 struct read_cpu_info_sccb {
88 struct sccb_header header;
90 u16 offset_configured;
93 u8 reserved[4096 - 16];
94 } __attribute__((packed, aligned(PAGE_SIZE)));
96 static void sclp_fill_core_info(struct sclp_core_info *info,
97 struct read_cpu_info_sccb *sccb)
99 char *page = (char *) sccb;
101 memset(info, 0, sizeof(*info));
102 info->configured = sccb->nr_configured;
103 info->standby = sccb->nr_standby;
104 info->combined = sccb->nr_configured + sccb->nr_standby;
105 memcpy(&info->core, page + sccb->offset_configured,
106 info->combined * sizeof(struct sclp_core_entry));
109 int sclp_get_core_info(struct sclp_core_info *info)
112 struct read_cpu_info_sccb *sccb;
114 if (!SCLP_HAS_CPU_INFO)
116 sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
119 sccb->header.length = sizeof(*sccb);
120 rc = sclp_sync_request_timeout(SCLP_CMDW_READ_CPU_INFO, sccb,
121 SCLP_QUEUE_INTERVAL);
124 if (sccb->header.response_code != 0x0010) {
125 pr_warn("readcpuinfo failed (response=0x%04x)\n",
126 sccb->header.response_code);
130 sclp_fill_core_info(info, sccb);
132 free_page((unsigned long) sccb);
136 struct cpu_configure_sccb {
137 struct sccb_header header;
138 } __attribute__((packed, aligned(8)));
140 static int do_core_configure(sclp_cmdw_t cmd)
142 struct cpu_configure_sccb *sccb;
145 if (!SCLP_HAS_CPU_RECONFIG)
148 * This is not going to cross a page boundary since we force
149 * kmalloc to have a minimum alignment of 8 bytes on s390.
151 sccb = kzalloc(sizeof(*sccb), GFP_KERNEL | GFP_DMA);
154 sccb->header.length = sizeof(*sccb);
155 rc = sclp_sync_request_timeout(cmd, sccb, SCLP_QUEUE_INTERVAL);
158 switch (sccb->header.response_code) {
163 pr_warn("configure cpu failed (cmd=0x%08x, response=0x%04x)\n",
164 cmd, sccb->header.response_code);
173 int sclp_core_configure(u8 core)
175 return do_core_configure(SCLP_CMDW_CONFIGURE_CPU | core << 8);
178 int sclp_core_deconfigure(u8 core)
180 return do_core_configure(SCLP_CMDW_DECONFIGURE_CPU | core << 8);
183 #ifdef CONFIG_MEMORY_HOTPLUG
185 static DEFINE_MUTEX(sclp_mem_mutex);
186 static LIST_HEAD(sclp_mem_list);
187 static u8 sclp_max_storage_id;
188 static DECLARE_BITMAP(sclp_storage_ids, 256);
189 static int sclp_mem_state_changed;
191 struct memory_increment {
192 struct list_head list;
197 struct assign_storage_sccb {
198 struct sccb_header header;
202 int arch_get_memory_phys_device(unsigned long start_pfn)
206 return PFN_PHYS(start_pfn) >> ilog2(sclp.rzm);
209 static unsigned long long rn2addr(u16 rn)
211 return (unsigned long long) (rn - 1) * sclp.rzm;
214 static int do_assign_storage(sclp_cmdw_t cmd, u16 rn)
216 struct assign_storage_sccb *sccb;
219 sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
222 sccb->header.length = PAGE_SIZE;
224 rc = sclp_sync_request_timeout(cmd, sccb, SCLP_QUEUE_INTERVAL);
227 switch (sccb->header.response_code) {
232 pr_warn("assign storage failed (cmd=0x%08x, response=0x%04x, rn=0x%04x)\n",
233 cmd, sccb->header.response_code, rn);
238 free_page((unsigned long) sccb);
242 static int sclp_assign_storage(u16 rn)
244 unsigned long long start;
247 rc = do_assign_storage(0x000d0001, rn);
251 storage_key_init_range(start, start + sclp.rzm);
255 static int sclp_unassign_storage(u16 rn)
257 return do_assign_storage(0x000c0001, rn);
260 struct attach_storage_sccb {
261 struct sccb_header header;
268 static int sclp_attach_storage(u8 id)
270 struct attach_storage_sccb *sccb;
274 sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
277 sccb->header.length = PAGE_SIZE;
278 rc = sclp_sync_request_timeout(0x00080001 | id << 8, sccb,
279 SCLP_QUEUE_INTERVAL);
282 switch (sccb->header.response_code) {
284 set_bit(id, sclp_storage_ids);
285 for (i = 0; i < sccb->assigned; i++) {
286 if (sccb->entries[i])
287 sclp_unassign_storage(sccb->entries[i] >> 16);
295 free_page((unsigned long) sccb);
299 static int sclp_mem_change_state(unsigned long start, unsigned long size,
302 struct memory_increment *incr;
303 unsigned long long istart;
306 list_for_each_entry(incr, &sclp_mem_list, list) {
307 istart = rn2addr(incr->rn);
308 if (start + size - 1 < istart)
310 if (start > istart + sclp.rzm - 1)
313 rc |= sclp_assign_storage(incr->rn);
315 sclp_unassign_storage(incr->rn);
317 incr->standby = online ? 0 : 1;
319 return rc ? -EIO : 0;
322 static bool contains_standby_increment(unsigned long start, unsigned long end)
324 struct memory_increment *incr;
325 unsigned long istart;
327 list_for_each_entry(incr, &sclp_mem_list, list) {
328 istart = rn2addr(incr->rn);
329 if (end - 1 < istart)
331 if (start > istart + sclp.rzm - 1)
339 static int sclp_mem_notifier(struct notifier_block *nb,
340 unsigned long action, void *data)
342 unsigned long start, size;
343 struct memory_notify *arg;
348 start = arg->start_pfn << PAGE_SHIFT;
349 size = arg->nr_pages << PAGE_SHIFT;
350 mutex_lock(&sclp_mem_mutex);
351 for_each_clear_bit(id, sclp_storage_ids, sclp_max_storage_id + 1)
352 sclp_attach_storage(id);
354 case MEM_GOING_OFFLINE:
356 * We do not allow to set memory blocks offline that contain
357 * standby memory. This is done to simplify the "memory online"
360 if (contains_standby_increment(start, start + size))
364 case MEM_CANCEL_OFFLINE:
366 case MEM_GOING_ONLINE:
367 rc = sclp_mem_change_state(start, size, 1);
369 case MEM_CANCEL_ONLINE:
370 sclp_mem_change_state(start, size, 0);
373 sclp_mem_change_state(start, size, 0);
380 sclp_mem_state_changed = 1;
381 mutex_unlock(&sclp_mem_mutex);
382 return rc ? NOTIFY_BAD : NOTIFY_OK;
385 static struct notifier_block sclp_mem_nb = {
386 .notifier_call = sclp_mem_notifier,
389 static void __init align_to_block_size(unsigned long long *start,
390 unsigned long long *size,
391 unsigned long long alignment)
393 unsigned long long start_align, size_align;
395 start_align = roundup(*start, alignment);
396 size_align = rounddown(*start + *size, alignment) - start_align;
398 pr_info("Standby memory at 0x%llx (%lluM of %lluM usable)\n",
399 *start, size_align >> 20, *size >> 20);
400 *start = start_align;
404 static void __init add_memory_merged(u16 rn)
406 unsigned long long start, size, addr, block_size;
407 static u16 first_rn, num;
409 if (rn && first_rn && (first_rn + num == rn)) {
415 start = rn2addr(first_rn);
416 size = (unsigned long long) num * sclp.rzm;
417 if (start >= VMEM_MAX_PHYS)
419 if (start + size > VMEM_MAX_PHYS)
420 size = VMEM_MAX_PHYS - start;
421 if (memory_end_set && (start >= memory_end))
423 if (memory_end_set && (start + size > memory_end))
424 size = memory_end - start;
425 block_size = memory_block_size_bytes();
426 align_to_block_size(&start, &size, block_size);
429 for (addr = start; addr < start + size; addr += block_size)
430 add_memory(numa_pfn_to_nid(PFN_DOWN(addr)), addr, block_size);
436 static void __init sclp_add_standby_memory(void)
438 struct memory_increment *incr;
440 list_for_each_entry(incr, &sclp_mem_list, list)
442 add_memory_merged(incr->rn);
443 add_memory_merged(0);
446 static void __init insert_increment(u16 rn, int standby, int assigned)
448 struct memory_increment *incr, *new_incr;
449 struct list_head *prev;
452 new_incr = kzalloc(sizeof(*new_incr), GFP_KERNEL);
456 new_incr->standby = standby;
458 prev = &sclp_mem_list;
459 list_for_each_entry(incr, &sclp_mem_list, list) {
460 if (assigned && incr->rn > rn)
462 if (!assigned && incr->rn - last_rn > 1)
468 new_incr->rn = last_rn + 1;
469 if (new_incr->rn > sclp.rnmax) {
473 list_add(&new_incr->list, prev);
476 static int sclp_mem_freeze(struct device *dev)
478 if (!sclp_mem_state_changed)
480 pr_err("Memory hotplug state changed, suspend refused.\n");
484 struct read_storage_sccb {
485 struct sccb_header header;
493 static const struct dev_pm_ops sclp_mem_pm_ops = {
494 .freeze = sclp_mem_freeze,
497 static struct platform_driver sclp_mem_pdrv = {
500 .pm = &sclp_mem_pm_ops,
504 static int __init sclp_detect_standby_memory(void)
506 struct platform_device *sclp_pdev;
507 struct read_storage_sccb *sccb;
508 int i, id, assigned, rc;
510 if (OLDMEM_BASE) /* No standby memory in kdump mode */
512 if ((sclp.facilities & 0xe00000000000ULL) != 0xe00000000000ULL)
515 sccb = (void *) __get_free_page(GFP_KERNEL | GFP_DMA);
519 for (id = 0; id <= sclp_max_storage_id; id++) {
520 memset(sccb, 0, PAGE_SIZE);
521 sccb->header.length = PAGE_SIZE;
522 rc = sclp_sync_request(0x00040001 | id << 8, sccb);
525 switch (sccb->header.response_code) {
527 set_bit(id, sclp_storage_ids);
528 for (i = 0; i < sccb->assigned; i++) {
529 if (!sccb->entries[i])
532 insert_increment(sccb->entries[i] >> 16, 0, 1);
538 for (i = 0; i < sccb->assigned; i++) {
539 if (!sccb->entries[i])
542 insert_increment(sccb->entries[i] >> 16, 1, 1);
550 sclp_max_storage_id = sccb->max_id;
552 if (rc || list_empty(&sclp_mem_list))
554 for (i = 1; i <= sclp.rnmax - assigned; i++)
555 insert_increment(0, 1, 0);
556 rc = register_memory_notifier(&sclp_mem_nb);
559 rc = platform_driver_register(&sclp_mem_pdrv);
562 sclp_pdev = platform_device_register_simple("sclp_mem", -1, NULL, 0);
563 rc = PTR_ERR_OR_ZERO(sclp_pdev);
566 sclp_add_standby_memory();
569 platform_driver_unregister(&sclp_mem_pdrv);
571 free_page((unsigned long) sccb);
574 __initcall(sclp_detect_standby_memory);
576 #endif /* CONFIG_MEMORY_HOTPLUG */
579 * Channel path configuration related functions.
582 #define SCLP_CMDW_CONFIGURE_CHPATH 0x000f0001
583 #define SCLP_CMDW_DECONFIGURE_CHPATH 0x000e0001
584 #define SCLP_CMDW_READ_CHPATH_INFORMATION 0x00030001
586 struct chp_cfg_sccb {
587 struct sccb_header header;
591 } __attribute__((packed));
593 static int do_chp_configure(sclp_cmdw_t cmd)
595 struct chp_cfg_sccb *sccb;
598 if (!SCLP_HAS_CHP_RECONFIG)
601 sccb = (struct chp_cfg_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
604 sccb->header.length = sizeof(*sccb);
605 rc = sclp_sync_request(cmd, sccb);
608 switch (sccb->header.response_code) {
615 pr_warn("configure channel-path failed (cmd=0x%08x, response=0x%04x)\n",
616 cmd, sccb->header.response_code);
621 free_page((unsigned long) sccb);
626 * sclp_chp_configure - perform configure channel-path sclp command
627 * @chpid: channel-path ID
629 * Perform configure channel-path command sclp command for specified chpid.
630 * Return 0 after command successfully finished, non-zero otherwise.
632 int sclp_chp_configure(struct chp_id chpid)
634 return do_chp_configure(SCLP_CMDW_CONFIGURE_CHPATH | chpid.id << 8);
638 * sclp_chp_deconfigure - perform deconfigure channel-path sclp command
639 * @chpid: channel-path ID
641 * Perform deconfigure channel-path command sclp command for specified chpid
642 * and wait for completion. On success return 0. Return non-zero otherwise.
644 int sclp_chp_deconfigure(struct chp_id chpid)
646 return do_chp_configure(SCLP_CMDW_DECONFIGURE_CHPATH | chpid.id << 8);
649 struct chp_info_sccb {
650 struct sccb_header header;
651 u8 recognized[SCLP_CHP_INFO_MASK_SIZE];
652 u8 standby[SCLP_CHP_INFO_MASK_SIZE];
653 u8 configured[SCLP_CHP_INFO_MASK_SIZE];
657 } __attribute__((packed));
660 * sclp_chp_read_info - perform read channel-path information sclp command
661 * @info: resulting channel-path information data
663 * Perform read channel-path information sclp command and wait for completion.
664 * On success, store channel-path information in @info and return 0. Return
665 * non-zero otherwise.
667 int sclp_chp_read_info(struct sclp_chp_info *info)
669 struct chp_info_sccb *sccb;
672 if (!SCLP_HAS_CHP_INFO)
675 sccb = (struct chp_info_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
678 sccb->header.length = sizeof(*sccb);
679 rc = sclp_sync_request(SCLP_CMDW_READ_CHPATH_INFORMATION, sccb);
682 if (sccb->header.response_code != 0x0010) {
683 pr_warn("read channel-path info failed (response=0x%04x)\n",
684 sccb->header.response_code);
688 memcpy(info->recognized, sccb->recognized, SCLP_CHP_INFO_MASK_SIZE);
689 memcpy(info->standby, sccb->standby, SCLP_CHP_INFO_MASK_SIZE);
690 memcpy(info->configured, sccb->configured, SCLP_CHP_INFO_MASK_SIZE);
692 free_page((unsigned long) sccb);