[linux-2.6-block.git] / drivers / s390 / char / sclp_cmd.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright IBM Corp. 2007,2012
 *
 * Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
 */

#define KMSG_COMPONENT "sclp_cmd"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/completion.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/err.h>
#include <linux/export.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/mmzone.h>
#include <linux/memory.h>
#include <linux/memory_hotplug.h>
#include <linux/module.h>
#include <asm/ctlreg.h>
#include <asm/chpid.h>
#include <asm/setup.h>
#include <asm/page.h>
#include <asm/sclp.h>
#include <asm/numa.h>
#include <asm/facility.h>
#include <asm/page-states.h>

#include "sclp.h"

static void sclp_sync_callback(struct sclp_req *req, void *data)
{
	struct completion *completion = data;

	complete(completion);
}

int sclp_sync_request(sclp_cmdw_t cmd, void *sccb)
{
	return sclp_sync_request_timeout(cmd, sccb, 0);
}

int sclp_sync_request_timeout(sclp_cmdw_t cmd, void *sccb, int timeout)
{
	struct completion completion;
	struct sclp_req *request;
	int rc;

	request = kzalloc(sizeof(*request), GFP_KERNEL);
	if (!request)
		return -ENOMEM;
	if (timeout)
		request->queue_timeout = timeout;
	request->command = cmd;
	request->sccb = sccb;
	request->status = SCLP_REQ_FILLED;
	request->callback = sclp_sync_callback;
	request->callback_data = &completion;
	init_completion(&completion);

	/* Perform sclp request. */
	rc = sclp_add_request(request);
	if (rc)
		goto out;
	wait_for_completion(&completion);

	/* Check response. */
	if (request->status != SCLP_REQ_DONE) {
		pr_warn("sync request failed (cmd=0x%08x, status=0x%02x)\n",
			cmd, request->status);
		rc = -EIO;
	}
out:
	kfree(request);
	return rc;
}

/*
 * CPU configuration related functions.
 */

#define SCLP_CMDW_CONFIGURE_CPU		0x00110001
#define SCLP_CMDW_DECONFIGURE_CPU	0x00100001

int _sclp_get_core_info(struct sclp_core_info *info)
{
	int rc;
	int length = test_facility(140) ? EXT_SCCB_READ_CPU : PAGE_SIZE;
	struct read_cpu_info_sccb *sccb;

	if (!SCLP_HAS_CPU_INFO)
		return -EOPNOTSUPP;

	sccb = (void *)__get_free_pages(GFP_KERNEL | GFP_DMA | __GFP_ZERO, get_order(length));
	if (!sccb)
		return -ENOMEM;
	sccb->header.length = length;
	sccb->header.control_mask[2] = 0x80;
	rc = sclp_sync_request_timeout(SCLP_CMDW_READ_CPU_INFO, sccb,
				       SCLP_QUEUE_INTERVAL);
	if (rc)
		goto out;
	if (sccb->header.response_code != 0x0010) {
		pr_warn("readcpuinfo failed (response=0x%04x)\n",
			sccb->header.response_code);
		rc = -EIO;
		goto out;
	}
	sclp_fill_core_info(info, sccb);
out:
	free_pages((unsigned long) sccb, get_order(length));
	return rc;
}

struct cpu_configure_sccb {
	struct sccb_header header;
} __attribute__((packed, aligned(8)));

static int do_core_configure(sclp_cmdw_t cmd)
{
	struct cpu_configure_sccb *sccb;
	int rc;

	if (!SCLP_HAS_CPU_RECONFIG)
		return -EOPNOTSUPP;
	/*
	 * This is not going to cross a page boundary since we force
	 * kmalloc to have a minimum alignment of 8 bytes on s390.
	 */
	sccb = kzalloc(sizeof(*sccb), GFP_KERNEL | GFP_DMA);
	if (!sccb)
		return -ENOMEM;
	sccb->header.length = sizeof(*sccb);
	rc = sclp_sync_request_timeout(cmd, sccb, SCLP_QUEUE_INTERVAL);
	if (rc)
		goto out;
	switch (sccb->header.response_code) {
	case 0x0020:
	case 0x0120:
		break;
	default:
		pr_warn("configure cpu failed (cmd=0x%08x, response=0x%04x)\n",
			cmd, sccb->header.response_code);
		rc = -EIO;
		break;
	}
out:
	kfree(sccb);
	return rc;
}

int sclp_core_configure(u8 core)
{
	return do_core_configure(SCLP_CMDW_CONFIGURE_CPU | core << 8);
}

int sclp_core_deconfigure(u8 core)
{
	return do_core_configure(SCLP_CMDW_DECONFIGURE_CPU | core << 8);
}

#ifdef CONFIG_MEMORY_HOTPLUG

static DEFINE_MUTEX(sclp_mem_mutex);
static LIST_HEAD(sclp_mem_list);
static u8 sclp_max_storage_id;
static DECLARE_BITMAP(sclp_storage_ids, 256);

struct memory_increment {
	struct list_head list;
	u16 rn;
	int standby;
};

struct assign_storage_sccb {
	struct sccb_header header;
	u16 rn;
} __packed;

int arch_get_memory_phys_device(unsigned long start_pfn)
{
	if (!sclp.rzm)
		return 0;
	return PFN_PHYS(start_pfn) >> ilog2(sclp.rzm);
}

static unsigned long long rn2addr(u16 rn)
{
	return (unsigned long long) (rn - 1) * sclp.rzm;
}

static int do_assign_storage(sclp_cmdw_t cmd, u16 rn)
{
	struct assign_storage_sccb *sccb;
	int rc;

	sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
	if (!sccb)
		return -ENOMEM;
	sccb->header.length = PAGE_SIZE;
	sccb->rn = rn;
	rc = sclp_sync_request_timeout(cmd, sccb, SCLP_QUEUE_INTERVAL);
	if (rc)
		goto out;
	switch (sccb->header.response_code) {
	case 0x0020:
	case 0x0120:
		break;
	default:
		pr_warn("assign storage failed (cmd=0x%08x, response=0x%04x, rn=0x%04x)\n",
			cmd, sccb->header.response_code, rn);
		rc = -EIO;
		break;
	}
out:
	free_page((unsigned long) sccb);
	return rc;
}

static int sclp_assign_storage(u16 rn)
{
	unsigned long long start;
	int rc;

	rc = do_assign_storage(0x000d0001, rn);
	if (rc)
		return rc;
	start = rn2addr(rn);
	storage_key_init_range(start, start + sclp.rzm);
	return 0;
}

static int sclp_unassign_storage(u16 rn)
{
	return do_assign_storage(0x000c0001, rn);
}

struct attach_storage_sccb {
	struct sccb_header header;
	u16 :16;
	u16 assigned;
	u32 :32;
	u32 entries[];
} __packed;

static int sclp_attach_storage(u8 id)
{
	struct attach_storage_sccb *sccb;
	int rc;
	int i;

	sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
	if (!sccb)
		return -ENOMEM;
	sccb->header.length = PAGE_SIZE;
	sccb->header.function_code = 0x40;
	rc = sclp_sync_request_timeout(0x00080001 | id << 8, sccb,
				       SCLP_QUEUE_INTERVAL);
	if (rc)
		goto out;
	switch (sccb->header.response_code) {
	case 0x0020:
		set_bit(id, sclp_storage_ids);
		for (i = 0; i < sccb->assigned; i++) {
			if (sccb->entries[i])
				sclp_unassign_storage(sccb->entries[i] >> 16);
		}
		break;
	default:
		rc = -EIO;
		break;
	}
out:
	free_page((unsigned long) sccb);
	return rc;
}

static int sclp_mem_change_state(unsigned long start, unsigned long size,
				 int online)
{
	struct memory_increment *incr;
	unsigned long long istart;
	int rc = 0;

	list_for_each_entry(incr, &sclp_mem_list, list) {
		istart = rn2addr(incr->rn);
		if (start + size - 1 < istart)
			break;
		if (start > istart + sclp.rzm - 1)
			continue;
		if (online)
			rc |= sclp_assign_storage(incr->rn);
		else
			sclp_unassign_storage(incr->rn);
		if (rc == 0)
			incr->standby = online ? 0 : 1;
	}
	return rc ? -EIO : 0;
}

static bool contains_standby_increment(unsigned long start, unsigned long end)
{
	struct memory_increment *incr;
	unsigned long istart;

	list_for_each_entry(incr, &sclp_mem_list, list) {
		istart = rn2addr(incr->rn);
		if (end - 1 < istart)
			continue;
		if (start > istart + sclp.rzm - 1)
			continue;
		if (incr->standby)
			return true;
	}
	return false;
}

static int sclp_mem_notifier(struct notifier_block *nb,
			     unsigned long action, void *data)
{
	unsigned long start, size;
	struct memory_notify *arg;
	unsigned char id;
	int rc = 0;

	arg = data;
	start = arg->start_pfn << PAGE_SHIFT;
	size = arg->nr_pages << PAGE_SHIFT;
	mutex_lock(&sclp_mem_mutex);
	for_each_clear_bit(id, sclp_storage_ids, sclp_max_storage_id + 1)
		sclp_attach_storage(id);
	switch (action) {
	case MEM_GOING_OFFLINE:
		/*
		 * We do not allow to set memory blocks offline that contain
		 * standby memory. This is done to simplify the "memory online"
		 * case.
		 */
		if (contains_standby_increment(start, start + size))
			rc = -EPERM;
		break;
	case MEM_PREPARE_ONLINE:
		/*
		 * Access the altmap_start_pfn and altmap_nr_pages fields
		 * within the struct memory_notify specifically when dealing
		 * with only MEM_PREPARE_ONLINE/MEM_FINISH_OFFLINE notifiers.
		 *
		 * When altmap is in use, take the specified memory range
		 * online, which includes the altmap.
		 */
		if (arg->altmap_nr_pages) {
			start = PFN_PHYS(arg->altmap_start_pfn);
			size += PFN_PHYS(arg->altmap_nr_pages);
		}
		rc = sclp_mem_change_state(start, size, 1);
		if (rc || !arg->altmap_nr_pages)
			break;
		/*
		 * Set CMMA state to nodat here, since the struct page memory
		 * at the beginning of the memory block will not go through the
		 * buddy allocator later.
		 */
		__arch_set_page_nodat((void *)__va(start), arg->altmap_nr_pages);
		break;
	case MEM_FINISH_OFFLINE:
		/*
		 * When altmap is in use, take the specified memory range
		 * offline, which includes the altmap.
		 */
		if (arg->altmap_nr_pages) {
			start = PFN_PHYS(arg->altmap_start_pfn);
			size += PFN_PHYS(arg->altmap_nr_pages);
		}
		sclp_mem_change_state(start, size, 0);
		break;
	default:
		break;
	}
	mutex_unlock(&sclp_mem_mutex);
	return rc ? NOTIFY_BAD : NOTIFY_OK;
}

static struct notifier_block sclp_mem_nb = {
	.notifier_call = sclp_mem_notifier,
};

static void __init align_to_block_size(unsigned long long *start,
				       unsigned long long *size,
				       unsigned long long alignment)
{
	unsigned long long start_align, size_align;

	start_align = roundup(*start, alignment);
	size_align = rounddown(*start + *size, alignment) - start_align;

	pr_info("Standby memory at 0x%llx (%lluM of %lluM usable)\n",
		*start, size_align >> 20, *size >> 20);
	*start = start_align;
	*size = size_align;
}

static void __init add_memory_merged(u16 rn)
{
	unsigned long long start, size, addr, block_size;
	static u16 first_rn, num;

	if (rn && first_rn && (first_rn + num == rn)) {
		num++;
		return;
	}
	if (!first_rn)
		goto skip_add;
	start = rn2addr(first_rn);
	size = (unsigned long long) num * sclp.rzm;
	if (start >= ident_map_size)
		goto skip_add;
	if (start + size > ident_map_size)
		size = ident_map_size - start;
	block_size = memory_block_size_bytes();
	align_to_block_size(&start, &size, block_size);
	if (!size)
		goto skip_add;
	for (addr = start; addr < start + size; addr += block_size)
		add_memory(0, addr, block_size,
			   MACHINE_HAS_EDAT1 ?
			   MHP_MEMMAP_ON_MEMORY | MHP_OFFLINE_INACCESSIBLE : MHP_NONE);
skip_add:
	first_rn = rn;
	num = 1;
}

static void __init sclp_add_standby_memory(void)
{
	struct memory_increment *incr;

	list_for_each_entry(incr, &sclp_mem_list, list)
		if (incr->standby)
			add_memory_merged(incr->rn);
	add_memory_merged(0);
}

static void __init insert_increment(u16 rn, int standby, int assigned)
{
	struct memory_increment *incr, *new_incr;
	struct list_head *prev;
	u16 last_rn;

	new_incr = kzalloc(sizeof(*new_incr), GFP_KERNEL);
	if (!new_incr)
		return;
	new_incr->rn = rn;
	new_incr->standby = standby;
	last_rn = 0;
	prev = &sclp_mem_list;
	list_for_each_entry(incr, &sclp_mem_list, list) {
		if (assigned && incr->rn > rn)
			break;
		if (!assigned && incr->rn - last_rn > 1)
			break;
		last_rn = incr->rn;
		prev = &incr->list;
	}
	if (!assigned)
		new_incr->rn = last_rn + 1;
	if (new_incr->rn > sclp.rnmax) {
		kfree(new_incr);
		return;
	}
	list_add(&new_incr->list, prev);
}

static int __init sclp_detect_standby_memory(void)
{
	struct read_storage_sccb *sccb;
	int i, id, assigned, rc;

	if (oldmem_data.start) /* No standby memory in kdump mode */
		return 0;
	if ((sclp.facilities & 0xe00000000000ULL) != 0xe00000000000ULL)
		return 0;
	rc = -ENOMEM;
	sccb = (void *) __get_free_page(GFP_KERNEL | GFP_DMA);
	if (!sccb)
		goto out;
	assigned = 0;
	for (id = 0; id <= sclp_max_storage_id; id++) {
		memset(sccb, 0, PAGE_SIZE);
		sccb->header.length = PAGE_SIZE;
		rc = sclp_sync_request(SCLP_CMDW_READ_STORAGE_INFO | id << 8, sccb);
		if (rc)
			goto out;
		switch (sccb->header.response_code) {
		case 0x0010:
			set_bit(id, sclp_storage_ids);
			for (i = 0; i < sccb->assigned; i++) {
				if (!sccb->entries[i])
					continue;
				assigned++;
				insert_increment(sccb->entries[i] >> 16, 0, 1);
			}
			break;
		case 0x0310:
			break;
		case 0x0410:
			for (i = 0; i < sccb->assigned; i++) {
				if (!sccb->entries[i])
					continue;
				assigned++;
				insert_increment(sccb->entries[i] >> 16, 1, 1);
			}
			break;
		default:
			rc = -EIO;
			break;
		}
		if (!rc)
			sclp_max_storage_id = sccb->max_id;
	}
	if (rc || list_empty(&sclp_mem_list))
		goto out;
	for (i = 1; i <= sclp.rnmax - assigned; i++)
		insert_increment(0, 1, 0);
	rc = register_memory_notifier(&sclp_mem_nb);
	if (rc)
		goto out;
	sclp_add_standby_memory();
out:
	free_page((unsigned long) sccb);
	return rc;
}
__initcall(sclp_detect_standby_memory);

#endif /* CONFIG_MEMORY_HOTPLUG */

/*
 * Channel path configuration related functions.
 */

#define SCLP_CMDW_CONFIGURE_CHPATH		0x000f0001
#define SCLP_CMDW_DECONFIGURE_CHPATH		0x000e0001
#define SCLP_CMDW_READ_CHPATH_INFORMATION	0x00030001

struct chp_cfg_sccb {
	struct sccb_header header;
	u8 ccm;
	u8 reserved[6];
	u8 cssid;
} __attribute__((packed));

static int do_chp_configure(sclp_cmdw_t cmd)
{
	struct chp_cfg_sccb *sccb;
	int rc;

	if (!SCLP_HAS_CHP_RECONFIG)
		return -EOPNOTSUPP;
	/* Prepare sccb. */
	sccb = (struct chp_cfg_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
	if (!sccb)
		return -ENOMEM;
	sccb->header.length = sizeof(*sccb);
	rc = sclp_sync_request(cmd, sccb);
	if (rc)
		goto out;
	switch (sccb->header.response_code) {
	case 0x0020:
	case 0x0120:
	case 0x0440:
	case 0x0450:
		break;
	default:
		pr_warn("configure channel-path failed (cmd=0x%08x, response=0x%04x)\n",
			cmd, sccb->header.response_code);
		rc = -EIO;
		break;
	}
out:
	free_page((unsigned long) sccb);
	return rc;
}

/**
 * sclp_chp_configure - perform configure channel-path sclp command
 * @chpid: channel-path ID
 *
 * Perform configure channel-path command sclp command for specified chpid.
 * Return 0 after command successfully finished, non-zero otherwise.
 */
int sclp_chp_configure(struct chp_id chpid)
{
	return do_chp_configure(SCLP_CMDW_CONFIGURE_CHPATH | chpid.id << 8);
}

/**
 * sclp_chp_deconfigure - perform deconfigure channel-path sclp command
 * @chpid: channel-path ID
 *
 * Perform deconfigure channel-path command sclp command for specified chpid
 * and wait for completion. On success return 0. Return non-zero otherwise.
 */
int sclp_chp_deconfigure(struct chp_id chpid)
{
	return do_chp_configure(SCLP_CMDW_DECONFIGURE_CHPATH | chpid.id << 8);
}

struct chp_info_sccb {
	struct sccb_header header;
	u8 recognized[SCLP_CHP_INFO_MASK_SIZE];
	u8 standby[SCLP_CHP_INFO_MASK_SIZE];
	u8 configured[SCLP_CHP_INFO_MASK_SIZE];
	u8 ccm;
	u8 reserved[6];
	u8 cssid;
} __attribute__((packed));

/**
 * sclp_chp_read_info - perform read channel-path information sclp command
 * @info: resulting channel-path information data
 *
 * Perform read channel-path information sclp command and wait for completion.
 * On success, store channel-path information in @info and return 0. Return
 * non-zero otherwise.
 */
int sclp_chp_read_info(struct sclp_chp_info *info)
{
	struct chp_info_sccb *sccb;
	int rc;

	if (!SCLP_HAS_CHP_INFO)
		return -EOPNOTSUPP;
	/* Prepare sccb. */
	sccb = (struct chp_info_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
	if (!sccb)
		return -ENOMEM;
	sccb->header.length = sizeof(*sccb);
	rc = sclp_sync_request(SCLP_CMDW_READ_CHPATH_INFORMATION, sccb);
	if (rc)
		goto out;
	if (sccb->header.response_code != 0x0010) {
		pr_warn("read channel-path info failed (response=0x%04x)\n",
			sccb->header.response_code);
		rc = -EIO;
		goto out;
	}
	memcpy(info->recognized, sccb->recognized, SCLP_CHP_INFO_MASK_SIZE);
	memcpy(info->standby, sccb->standby, SCLP_CHP_INFO_MASK_SIZE);
	memcpy(info->configured, sccb->configured, SCLP_CHP_INFO_MASK_SIZE);
out:
	free_page((unsigned long) sccb);
	return rc;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
08d07968	2	/*
7441b062	3	* Copyright IBM Corp. 2007,2012
08d07968	4	*
f36e7c98	5	* Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
08d07968 HC	6	*/
08d07968 HC	7
b3ff088b MS	8	#define KMSG_COMPONENT "sclp_cmd"
	9	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	10
08d07968 HC	11	#include <linux/completion.h>
	12	#include <linux/init.h>
	13	#include <linux/errno.h>
03997904	14	#include <linux/err.h>
7441b062	15	#include <linux/export.h>
08d07968 HC	16	#include <linux/slab.h>
08d07968 HC	17	#include <linux/string.h>
e0bc2495 HC	18	#include <linux/mm.h>
	19	#include <linux/mmzone.h>
	20	#include <linux/memory.h>
890a4212	21	#include <linux/memory_hotplug.h>
1526bf9c	22	#include <linux/module.h>
ebe1cd53	23	#include <asm/ctlreg.h>
4b28a8fe	24	#include <asm/chpid.h>
23d75d9c	25	#include <asm/setup.h>
6b70a920 HC	26	#include <asm/page.h>
6b70a920 HC	27	#include <asm/sclp.h>
c29a7baf	28	#include <asm/numa.h>
b971cbd0	29	#include <asm/facility.h>
890a4212	30	#include <asm/page-states.h>
08d07968	31
b3ff088b	32	#include "sclp.h"
08d07968	33
08d07968 HC	34	static void sclp_sync_callback(struct sclp_req req, void data)
	35	{
	36	struct completion *completion = data;
	37
	38	complete(completion);
	39	}
	40
d475f942	41	int sclp_sync_request(sclp_cmdw_t cmd, void *sccb)
9f0128f9 GS	42	{
	43	return sclp_sync_request_timeout(cmd, sccb, 0);
	44	}
	45
	46	int sclp_sync_request_timeout(sclp_cmdw_t cmd, void *sccb, int timeout)
08d07968 HC	47	{
	48	struct completion completion;
	49	struct sclp_req *request;
	50	int rc;
	51
	52	request = kzalloc(sizeof(*request), GFP_KERNEL);
	53	if (!request)
	54	return -ENOMEM;
9f0128f9 GS	55	if (timeout)
9f0128f9 GS	56	request->queue_timeout = timeout;
08d07968 HC	57	request->command = cmd;
	58	request->sccb = sccb;
	59	request->status = SCLP_REQ_FILLED;
	60	request->callback = sclp_sync_callback;
	61	request->callback_data = &completion;
	62	init_completion(&completion);
	63
	64	/* Perform sclp request. */
	65	rc = sclp_add_request(request);
	66	if (rc)
	67	goto out;
	68	wait_for_completion(&completion);
	69
	70	/* Check response. */
	71	if (request->status != SCLP_REQ_DONE) {
baebc70a JP	72	pr_warn("sync request failed (cmd=0x%08x, status=0x%02x)\n",
baebc70a JP	73	cmd, request->status);
08d07968 HC	74	rc = -EIO;
	75	}
	76	out:
	77	kfree(request);
	78	return rc;
	79	}
	80
	81	/*
	82	* CPU configuration related functions.
	83	*/
	84
08d07968 HC	85	#define SCLP_CMDW_CONFIGURE_CPU 0x00110001
	86	#define SCLP_CMDW_DECONFIGURE_CPU 0x00100001
	87
af51160e	88	int _sclp_get_core_info(struct sclp_core_info *info)
08d07968 HC	89	{
08d07968 HC	90	int rc;
b971cbd0	91	int length = test_facility(140) ? EXT_SCCB_READ_CPU : PAGE_SIZE;
08d07968 HC	92	struct read_cpu_info_sccb *sccb;
	93
	94	if (!SCLP_HAS_CPU_INFO)
	95	return -EOPNOTSUPP;
b971cbd0 SK	96
b971cbd0 SK	97	sccb = (void *)__get_free_pages(GFP_KERNEL \| GFP_DMA \| __GFP_ZERO, get_order(length));
08d07968 HC	98	if (!sccb)
08d07968 HC	99	return -ENOMEM;
b971cbd0 SK	100	sccb->header.length = length;
b971cbd0 SK	101	sccb->header.control_mask[2] = 0x80;
9f0128f9 GS	102	rc = sclp_sync_request_timeout(SCLP_CMDW_READ_CPU_INFO, sccb,
9f0128f9 GS	103	SCLP_QUEUE_INTERVAL);
08d07968 HC	104	if (rc)
	105	goto out;
	106	if (sccb->header.response_code != 0x0010) {
baebc70a JP	107	pr_warn("readcpuinfo failed (response=0x%04x)\n",
baebc70a JP	108	sccb->header.response_code);
08d07968 HC	109	rc = -EIO;
	110	goto out;
	111	}
d08d9430	112	sclp_fill_core_info(info, sccb);
08d07968	113	out:
b971cbd0	114	free_pages((unsigned long) sccb, get_order(length));
08d07968 HC	115	return rc;
	116	}
	117
08d07968 HC	118	struct cpu_configure_sccb {
	119	struct sccb_header header;
	120	} __attribute__((packed, aligned(8)));
	121
d08d9430	122	static int do_core_configure(sclp_cmdw_t cmd)
08d07968 HC	123	{
	124	struct cpu_configure_sccb *sccb;
	125	int rc;
	126
	127	if (!SCLP_HAS_CPU_RECONFIG)
	128	return -EOPNOTSUPP;
	129	/*
	130	* This is not going to cross a page boundary since we force
	131	* kmalloc to have a minimum alignment of 8 bytes on s390.
	132	*/
	133	sccb = kzalloc(sizeof(*sccb), GFP_KERNEL \| GFP_DMA);
	134	if (!sccb)
	135	return -ENOMEM;
	136	sccb->header.length = sizeof(*sccb);
9f0128f9	137	rc = sclp_sync_request_timeout(cmd, sccb, SCLP_QUEUE_INTERVAL);
08d07968 HC	138	if (rc)
	139	goto out;
	140	switch (sccb->header.response_code) {
	141	case 0x0020:
	142	case 0x0120:
	143	break;
	144	default:
baebc70a JP	145	pr_warn("configure cpu failed (cmd=0x%08x, response=0x%04x)\n",
baebc70a JP	146	cmd, sccb->header.response_code);
08d07968 HC	147	rc = -EIO;
	148	break;
	149	}
	150	out:
	151	kfree(sccb);
	152	return rc;
	153	}
	154
d08d9430	155	int sclp_core_configure(u8 core)
08d07968	156	{
d08d9430	157	return do_core_configure(SCLP_CMDW_CONFIGURE_CPU \| core << 8);
08d07968 HC	158	}
08d07968 HC	159
d08d9430	160	int sclp_core_deconfigure(u8 core)
08d07968	161	{
d08d9430	162	return do_core_configure(SCLP_CMDW_DECONFIGURE_CPU \| core << 8);
08d07968	163	}
4b28a8fe	164
e0bc2495 HC	165	#ifdef CONFIG_MEMORY_HOTPLUG
	166
	167	static DEFINE_MUTEX(sclp_mem_mutex);
	168	static LIST_HEAD(sclp_mem_list);
	169	static u8 sclp_max_storage_id;
b8a43b04	170	static DECLARE_BITMAP(sclp_storage_ids, 256);
e0bc2495 HC	171
	172	struct memory_increment {
	173	struct list_head list;
	174	u16 rn;
	175	int standby;
e0bc2495 HC	176	};
	177
	178	struct assign_storage_sccb {
	179	struct sccb_header header;
	180	u16 rn;
	181	} __packed;
	182
9c95258c HC	183	int arch_get_memory_phys_device(unsigned long start_pfn)
9c95258c HC	184	{
37c5f6c8	185	if (!sclp.rzm)
9c95258c	186	return 0;
37c5f6c8	187	return PFN_PHYS(start_pfn) >> ilog2(sclp.rzm);
9c95258c HC	188	}
9c95258c HC	189
e0bc2495 HC	190	static unsigned long long rn2addr(u16 rn)
e0bc2495 HC	191	{
37c5f6c8	192	return (unsigned long long) (rn - 1) * sclp.rzm;
e0bc2495 HC	193	}
	194
	195	static int do_assign_storage(sclp_cmdw_t cmd, u16 rn)
	196	{
	197	struct assign_storage_sccb *sccb;
	198	int rc;
	199
	200	sccb = (void *) get_zeroed_page(GFP_KERNEL \| GFP_DMA);
	201	if (!sccb)
	202	return -ENOMEM;
	203	sccb->header.length = PAGE_SIZE;
	204	sccb->rn = rn;
9f0128f9	205	rc = sclp_sync_request_timeout(cmd, sccb, SCLP_QUEUE_INTERVAL);
e0bc2495 HC	206	if (rc)
	207	goto out;
	208	switch (sccb->header.response_code) {
	209	case 0x0020:
	210	case 0x0120:
	211	break;
	212	default:
baebc70a JP	213	pr_warn("assign storage failed (cmd=0x%08x, response=0x%04x, rn=0x%04x)\n",
baebc70a JP	214	cmd, sccb->header.response_code, rn);
e0bc2495 HC	215	rc = -EIO;
	216	break;
	217	}
	218	out:
	219	free_page((unsigned long) sccb);
	220	return rc;
	221	}
	222
	223	static int sclp_assign_storage(u16 rn)
	224	{
6b70a920	225	unsigned long long start;
0cd2f620 HC	226	int rc;
	227
	228	rc = do_assign_storage(0x000d0001, rn);
	229	if (rc)
6b70a920 HC	230	return rc;
6b70a920 HC	231	start = rn2addr(rn);
37c5f6c8	232	storage_key_init_range(start, start + sclp.rzm);
6b70a920	233	return 0;
e0bc2495 HC	234	}
	235
	236	static int sclp_unassign_storage(u16 rn)
	237	{
	238	return do_assign_storage(0x000c0001, rn);
	239	}
	240
	241	struct attach_storage_sccb {
	242	struct sccb_header header;
	243	u16 :16;
	244	u16 assigned;
	245	u32 :32;
469c701d	246	u32 entries[];
e0bc2495 HC	247	} __packed;
	248
	249	static int sclp_attach_storage(u8 id)
	250	{
	251	struct attach_storage_sccb *sccb;
	252	int rc;
	253	int i;
	254
	255	sccb = (void *) get_zeroed_page(GFP_KERNEL \| GFP_DMA);
	256	if (!sccb)
	257	return -ENOMEM;
	258	sccb->header.length = PAGE_SIZE;
45be0a02	259	sccb->header.function_code = 0x40;
9f0128f9 GS	260	rc = sclp_sync_request_timeout(0x00080001 \| id << 8, sccb,
9f0128f9 GS	261	SCLP_QUEUE_INTERVAL);
e0bc2495 HC	262	if (rc)
	263	goto out;
	264	switch (sccb->header.response_code) {
	265	case 0x0020:
	266	set_bit(id, sclp_storage_ids);
8adb4ca3 HC	267	for (i = 0; i < sccb->assigned; i++) {
	268	if (sccb->entries[i])
	269	sclp_unassign_storage(sccb->entries[i] >> 16);
	270	}
e0bc2495 HC	271	break;
	272	default:
	273	rc = -EIO;
	274	break;
	275	}
	276	out:
	277	free_page((unsigned long) sccb);
	278	return rc;
	279	}
	280
	281	static int sclp_mem_change_state(unsigned long start, unsigned long size,
	282	int online)
	283	{
	284	struct memory_increment *incr;
	285	unsigned long long istart;
	286	int rc = 0;
	287
	288	list_for_each_entry(incr, &sclp_mem_list, list) {
	289	istart = rn2addr(incr->rn);
	290	if (start + size - 1 < istart)
	291	break;
37c5f6c8	292	if (start > istart + sclp.rzm - 1)
e0bc2495	293	continue;
15535560	294	if (online)
e0bc2495	295	rc \|= sclp_assign_storage(incr->rn);
15535560	296	else
e0bc2495	297	sclp_unassign_storage(incr->rn);
8741ce6d MH	298	if (rc == 0)
8741ce6d MH	299	incr->standby = online ? 0 : 1;
e0bc2495 HC	300	}
	301	return rc ? -EIO : 0;
	302	}
	303
8741ce6d MH	304	static bool contains_standby_increment(unsigned long start, unsigned long end)
	305	{
	306	struct memory_increment *incr;
	307	unsigned long istart;
	308
	309	list_for_each_entry(incr, &sclp_mem_list, list) {
	310	istart = rn2addr(incr->rn);
	311	if (end - 1 < istart)
	312	continue;
37c5f6c8	313	if (start > istart + sclp.rzm - 1)
8741ce6d MH	314	continue;
	315	if (incr->standby)
	316	return true;
	317	}
	318	return false;
	319	}
	320
e0bc2495 HC	321	static int sclp_mem_notifier(struct notifier_block *nb,
	322	unsigned long action, void *data)
	323	{
	324	unsigned long start, size;
	325	struct memory_notify *arg;
	326	unsigned char id;
	327	int rc = 0;
	328
	329	arg = data;
	330	start = arg->start_pfn << PAGE_SHIFT;
	331	size = arg->nr_pages << PAGE_SHIFT;
	332	mutex_lock(&sclp_mem_mutex);
fc89db4b AM	333	for_each_clear_bit(id, sclp_storage_ids, sclp_max_storage_id + 1)
fc89db4b AM	334	sclp_attach_storage(id);
e0bc2495	335	switch (action) {
7e9238fb	336	case MEM_GOING_OFFLINE:
8741ce6d MH	337	/*
	338	* We do not allow to set memory blocks offline that contain
	339	* standby memory. This is done to simplify the "memory online"
	340	* case.
	341	*/
	342	if (contains_standby_increment(start, start + size))
	343	rc = -EPERM;
	344	break;
890a4212 SK	345	case MEM_PREPARE_ONLINE:
	346	/*
	347	* Access the altmap_start_pfn and altmap_nr_pages fields
	348	* within the struct memory_notify specifically when dealing
	349	* with only MEM_PREPARE_ONLINE/MEM_FINISH_OFFLINE notifiers.
	350	*
	351	* When altmap is in use, take the specified memory range
	352	* online, which includes the altmap.
	353	*/
	354	if (arg->altmap_nr_pages) {
	355	start = PFN_PHYS(arg->altmap_start_pfn);
	356	size += PFN_PHYS(arg->altmap_nr_pages);
	357	}
e0bc2495	358	rc = sclp_mem_change_state(start, size, 1);
890a4212 SK	359	if (rc \|\| !arg->altmap_nr_pages)
	360	break;
	361	/*
	362	* Set CMMA state to nodat here, since the struct page memory
	363	* at the beginning of the memory block will not go through the
	364	* buddy allocator later.
	365	*/
	366	__arch_set_page_nodat((void *)__va(start), arg->altmap_nr_pages);
e0bc2495	367	break;
890a4212 SK	368	case MEM_FINISH_OFFLINE:
	369	/*
	370	* When altmap is in use, take the specified memory range
	371	* offline, which includes the altmap.
	372	*/
	373	if (arg->altmap_nr_pages) {
	374	start = PFN_PHYS(arg->altmap_start_pfn);
	375	size += PFN_PHYS(arg->altmap_nr_pages);
	376	}
7e9238fb GS	377	sclp_mem_change_state(start, size, 0);
7e9238fb GS	378	break;
e0bc2495	379	default:
e0bc2495 HC	380	break;
	381	}
	382	mutex_unlock(&sclp_mem_mutex);
	383	return rc ? NOTIFY_BAD : NOTIFY_OK;
	384	}
	385
	386	static struct notifier_block sclp_mem_nb = {
	387	.notifier_call = sclp_mem_notifier,
	388	};
	389
8741ce6d	390	static void __init align_to_block_size(unsigned long long *start,
c29a7baf MH	391	unsigned long long *size,
c29a7baf MH	392	unsigned long long alignment)
8741ce6d	393	{
c29a7baf	394	unsigned long long start_align, size_align;
8741ce6d	395
8741ce6d MH	396	start_align = roundup(*start, alignment);
	397	size_align = rounddown(start + size, alignment) - start_align;
	398
	399	pr_info("Standby memory at 0x%llx (%lluM of %lluM usable)\n",
	400	start, size_align >> 20, size >> 20);
	401	*start = start_align;
	402	*size = size_align;
	403	}
	404
e0bc2495 HC	405	static void __init add_memory_merged(u16 rn)
e0bc2495 HC	406	{
c29a7baf	407	unsigned long long start, size, addr, block_size;
e0bc2495	408	static u16 first_rn, num;
e0bc2495 HC	409
	410	if (rn && first_rn && (first_rn + num == rn)) {
	411	num++;
	412	return;
	413	}
	414	if (!first_rn)
	415	goto skip_add;
	416	start = rn2addr(first_rn);
37c5f6c8	417	size = (unsigned long long) num * sclp.rzm;
73045a08	418	if (start >= ident_map_size)
23d75d9c	419	goto skip_add;
73045a08 VG	420	if (start + size > ident_map_size)
73045a08 VG	421	size = ident_map_size - start;
c29a7baf MH	422	block_size = memory_block_size_bytes();
	423	align_to_block_size(&start, &size, block_size);
	424	if (!size)
	425	goto skip_add;
	426	for (addr = start; addr < start + size; addr += block_size)
890a4212 SK	427	add_memory(0, addr, block_size,
	428	MACHINE_HAS_EDAT1 ?
	429	MHP_MEMMAP_ON_MEMORY \| MHP_OFFLINE_INACCESSIBLE : MHP_NONE);
e0bc2495 HC	430	skip_add:
	431	first_rn = rn;
	432	num = 1;
	433	}
	434
	435	static void __init sclp_add_standby_memory(void)
	436	{
	437	struct memory_increment *incr;
	438
	439	list_for_each_entry(incr, &sclp_mem_list, list)
	440	if (incr->standby)
	441	add_memory_merged(incr->rn);
	442	add_memory_merged(0);
	443	}
	444
	445	static void __init insert_increment(u16 rn, int standby, int assigned)
	446	{
	447	struct memory_increment incr, new_incr;
	448	struct list_head *prev;
	449	u16 last_rn;
	450
	451	new_incr = kzalloc(sizeof(*new_incr), GFP_KERNEL);
	452	if (!new_incr)
	453	return;
	454	new_incr->rn = rn;
	455	new_incr->standby = standby;
	456	last_rn = 0;
	457	prev = &sclp_mem_list;
	458	list_for_each_entry(incr, &sclp_mem_list, list) {
	459	if (assigned && incr->rn > rn)
	460	break;
	461	if (!assigned && incr->rn - last_rn > 1)
	462	break;
	463	last_rn = incr->rn;
	464	prev = &incr->list;
	465	}
	466	if (!assigned)
	467	new_incr->rn = last_rn + 1;
37c5f6c8	468	if (new_incr->rn > sclp.rnmax) {
e0bc2495 HC	469	kfree(new_incr);
	470	return;
	471	}
	472	list_add(&new_incr->list, prev);
	473	}
	474
e0bc2495 HC	475	static int __init sclp_detect_standby_memory(void)
	476	{
	477	struct read_storage_sccb *sccb;
	478	int i, id, assigned, rc;
	479
e9e7870f	480	if (oldmem_data.start) /* No standby memory in kdump mode */
52319b45	481	return 0;
78335a30	482	if ((sclp.facilities & 0xe00000000000ULL) != 0xe00000000000ULL)
e0bc2495 HC	483	return 0;
	484	rc = -ENOMEM;
	485	sccb = (void *) __get_free_page(GFP_KERNEL \| GFP_DMA);
	486	if (!sccb)
	487	goto out;
	488	assigned = 0;
	489	for (id = 0; id <= sclp_max_storage_id; id++) {
	490	memset(sccb, 0, PAGE_SIZE);
	491	sccb->header.length = PAGE_SIZE;
fddbaa5c	492	rc = sclp_sync_request(SCLP_CMDW_READ_STORAGE_INFO \| id << 8, sccb);
e0bc2495 HC	493	if (rc)
	494	goto out;
	495	switch (sccb->header.response_code) {
	496	case 0x0010:
	497	set_bit(id, sclp_storage_ids);
	498	for (i = 0; i < sccb->assigned; i++) {
	499	if (!sccb->entries[i])
	500	continue;
	501	assigned++;
	502	insert_increment(sccb->entries[i] >> 16, 0, 1);
	503	}
	504	break;
	505	case 0x0310:
	506	break;
	507	case 0x0410:
	508	for (i = 0; i < sccb->assigned; i++) {
	509	if (!sccb->entries[i])
	510	continue;
	511	assigned++;
	512	insert_increment(sccb->entries[i] >> 16, 1, 1);
	513	}
	514	break;
	515	default:
	516	rc = -EIO;
	517	break;
	518	}
	519	if (!rc)
	520	sclp_max_storage_id = sccb->max_id;
	521	}
	522	if (rc \|\| list_empty(&sclp_mem_list))
	523	goto out;
37c5f6c8	524	for (i = 1; i <= sclp.rnmax - assigned; i++)
e0bc2495 HC	525	insert_increment(0, 1, 0);
	526	rc = register_memory_notifier(&sclp_mem_nb);
	527	if (rc)
	528	goto out;
	529	sclp_add_standby_memory();
	530	out:
	531	free_page((unsigned long) sccb);
	532	return rc;
	533	}
	534	__initcall(sclp_detect_standby_memory);
	535
	536	#endif /* CONFIG_MEMORY_HOTPLUG */
	537
4b28a8fe HC	538	/*
	539	* Channel path configuration related functions.
	540	*/
	541
	542	#define SCLP_CMDW_CONFIGURE_CHPATH 0x000f0001
	543	#define SCLP_CMDW_DECONFIGURE_CHPATH 0x000e0001
	544	#define SCLP_CMDW_READ_CHPATH_INFORMATION 0x00030001
	545
	546	struct chp_cfg_sccb {
	547	struct sccb_header header;
	548	u8 ccm;
	549	u8 reserved[6];
	550	u8 cssid;
	551	} __attribute__((packed));
	552
	553	static int do_chp_configure(sclp_cmdw_t cmd)
	554	{
	555	struct chp_cfg_sccb *sccb;
	556	int rc;
	557
	558	if (!SCLP_HAS_CHP_RECONFIG)
	559	return -EOPNOTSUPP;
	560	/* Prepare sccb. */
	561	sccb = (struct chp_cfg_sccb *) get_zeroed_page(GFP_KERNEL \| GFP_DMA);
	562	if (!sccb)
	563	return -ENOMEM;
	564	sccb->header.length = sizeof(*sccb);
d475f942	565	rc = sclp_sync_request(cmd, sccb);
4b28a8fe HC	566	if (rc)
	567	goto out;
	568	switch (sccb->header.response_code) {
	569	case 0x0020:
	570	case 0x0120:
	571	case 0x0440:
	572	case 0x0450:
	573	break;
	574	default:
baebc70a JP	575	pr_warn("configure channel-path failed (cmd=0x%08x, response=0x%04x)\n",
baebc70a JP	576	cmd, sccb->header.response_code);
4b28a8fe HC	577	rc = -EIO;
	578	break;
	579	}
	580	out:
	581	free_page((unsigned long) sccb);
	582	return rc;
	583	}
	584
	585	/**
	586	* sclp_chp_configure - perform configure channel-path sclp command
	587	* @chpid: channel-path ID
	588	*
	589	* Perform configure channel-path command sclp command for specified chpid.
	590	* Return 0 after command successfully finished, non-zero otherwise.
	591	*/
	592	int sclp_chp_configure(struct chp_id chpid)
	593	{
	594	return do_chp_configure(SCLP_CMDW_CONFIGURE_CHPATH \| chpid.id << 8);
	595	}
	596
	597	/**
	598	* sclp_chp_deconfigure - perform deconfigure channel-path sclp command
	599	* @chpid: channel-path ID
	600	*
	601	* Perform deconfigure channel-path command sclp command for specified chpid
	602	* and wait for completion. On success return 0. Return non-zero otherwise.
	603	*/
	604	int sclp_chp_deconfigure(struct chp_id chpid)
	605	{
	606	return do_chp_configure(SCLP_CMDW_DECONFIGURE_CHPATH \| chpid.id << 8);
	607	}
	608
	609	struct chp_info_sccb {
	610	struct sccb_header header;
	611	u8 recognized[SCLP_CHP_INFO_MASK_SIZE];
	612	u8 standby[SCLP_CHP_INFO_MASK_SIZE];
	613	u8 configured[SCLP_CHP_INFO_MASK_SIZE];
	614	u8 ccm;
	615	u8 reserved[6];
	616	u8 cssid;
	617	} __attribute__((packed));
	618
	619	/**
	620	* sclp_chp_read_info - perform read channel-path information sclp command
	621	* @info: resulting channel-path information data
	622	*
	623	* Perform read channel-path information sclp command and wait for completion.
	624	* On success, store channel-path information in @info and return 0. Return
	625	* non-zero otherwise.
	626	*/
	627	int sclp_chp_read_info(struct sclp_chp_info *info)
	628	{
	629	struct chp_info_sccb *sccb;
	630	int rc;
	631
	632	if (!SCLP_HAS_CHP_INFO)
	633	return -EOPNOTSUPP;
	634	/* Prepare sccb. */
	635	sccb = (struct chp_info_sccb *) get_zeroed_page(GFP_KERNEL \| GFP_DMA);
	636	if (!sccb)
	637	return -ENOMEM;
	638	sccb->header.length = sizeof(*sccb);
d475f942	639	rc = sclp_sync_request(SCLP_CMDW_READ_CHPATH_INFORMATION, sccb);
4b28a8fe HC	640	if (rc)
	641	goto out;
	642	if (sccb->header.response_code != 0x0010) {
baebc70a JP	643	pr_warn("read channel-path info failed (response=0x%04x)\n",
baebc70a JP	644	sccb->header.response_code);
4b28a8fe HC	645	rc = -EIO;
	646	goto out;
	647	}
	648	memcpy(info->recognized, sccb->recognized, SCLP_CHP_INFO_MASK_SIZE);
	649	memcpy(info->standby, sccb->standby, SCLP_CHP_INFO_MASK_SIZE);
	650	memcpy(info->configured, sccb->configured, SCLP_CHP_INFO_MASK_SIZE);
	651	out:
	652	free_page((unsigned long) sccb);
	653	return rc;
	654	}