1// SPDX-License-Identifier: GPL-2.0
2/*
3 *    Copyright IBM Corp. 2007
4 */
5
6#define KMSG_COMPONENT "sclp_config"
7#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
8
9#include <linux/init.h>
10#include <linux/errno.h>
11#include <linux/cpu.h>
12#include <linux/device.h>
13#include <linux/workqueue.h>
14#include <linux/slab.h>
15#include <linux/sysfs.h>
16#include <asm/smp.h>
17
18#include "sclp.h"
19
20struct conf_mgm_data {
21	u8 reserved;
22	u8 ev_qualifier;
23} __attribute__((packed));
24
25#define OFB_DATA_MAX 64
26
27struct sclp_ofb_evbuf {
28	struct evbuf_header header;
29	struct conf_mgm_data cm_data;
30	char ev_data[OFB_DATA_MAX];
31} __packed;
32
33struct sclp_ofb_sccb {
34	struct sccb_header header;
35	struct sclp_ofb_evbuf ofb_evbuf;
36} __packed;
37
38#define EV_QUAL_CPU_CHANGE	1
39#define EV_QUAL_CAP_CHANGE	3
40#define EV_QUAL_OPEN4BUSINESS	5
41
42static struct work_struct sclp_cpu_capability_work;
43static struct work_struct sclp_cpu_change_work;
44
45static void sclp_cpu_capability_notify(struct work_struct *work)
46{
47	int cpu;
48	struct device *dev;
49
50	s390_update_cpu_mhz();
51	pr_info("CPU capability may have changed\n");
52	cpus_read_lock();
53	for_each_online_cpu(cpu) {
54		dev = get_cpu_device(cpu);
55		kobject_uevent(&dev->kobj, KOBJ_CHANGE);
56	}
57	cpus_read_unlock();
58}
59
60static void __ref sclp_cpu_change_notify(struct work_struct *work)
61{
62	lock_device_hotplug();
63	smp_rescan_cpus();
64	unlock_device_hotplug();
65}
66
67static void sclp_conf_receiver_fn(struct evbuf_header *evbuf)
68{
69	struct conf_mgm_data *cdata;
70
71	cdata = (struct conf_mgm_data *)(evbuf + 1);
72	switch (cdata->ev_qualifier) {
73	case EV_QUAL_CPU_CHANGE:
74		schedule_work(&sclp_cpu_change_work);
75		break;
76	case EV_QUAL_CAP_CHANGE:
77		schedule_work(&sclp_cpu_capability_work);
78		break;
79	}
80}
81
82static struct sclp_register sclp_conf_register =
83{
84#ifdef CONFIG_SCLP_OFB
85	.send_mask    = EVTYP_CONFMGMDATA_MASK,
86#endif
87	.receive_mask = EVTYP_CONFMGMDATA_MASK,
88	.receiver_fn  = sclp_conf_receiver_fn,
89};
90
91#ifdef CONFIG_SCLP_OFB
92static int sclp_ofb_send_req(char *ev_data, size_t len)
93{
94	static DEFINE_MUTEX(send_mutex);
95	struct sclp_ofb_sccb *sccb;
96	int rc, response;
97
98	if (len > OFB_DATA_MAX)
99		return -EINVAL;
100	sccb = (struct sclp_ofb_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
101	if (!sccb)
102		return -ENOMEM;
103	/* Setup SCCB for Control-Program Identification */
104	sccb->header.length = sizeof(struct sclp_ofb_sccb);
105	sccb->ofb_evbuf.header.length = sizeof(struct sclp_ofb_evbuf);
106	sccb->ofb_evbuf.header.type = EVTYP_CONFMGMDATA;
107	sccb->ofb_evbuf.cm_data.ev_qualifier = EV_QUAL_OPEN4BUSINESS;
108	memcpy(sccb->ofb_evbuf.ev_data, ev_data, len);
109
110	if (!(sclp_conf_register.sclp_receive_mask & EVTYP_CONFMGMDATA_MASK))
111		pr_warn("SCLP receiver did not register to receive "
112			"Configuration Management Data Events.\n");
113
114	mutex_lock(&send_mutex);
115	rc = sclp_sync_request(SCLP_CMDW_WRITE_EVENT_DATA, sccb);
116	mutex_unlock(&send_mutex);
117	if (rc)
118		goto out;
119	response = sccb->header.response_code;
120	if (response != 0x0020) {
121		pr_err("Open for Business request failed with response code "
122		       "0x%04x\n", response);
123		rc = -EIO;
124	}
125out:
126	free_page((unsigned long)sccb);
127	return rc;
128}
129
130static ssize_t sysfs_ofb_data_write(struct file *filp, struct kobject *kobj,
131				    struct bin_attribute *bin_attr,
132				    char *buf, loff_t off, size_t count)
133{
134	int rc;
135
136	rc = sclp_ofb_send_req(buf, count);
137	return rc ?: count;
138}
139
140static const struct bin_attribute ofb_bin_attr = {
141	.attr = {
142		.name = "event_data",
143		.mode = S_IWUSR,
144	},
145	.write = sysfs_ofb_data_write,
146};
147#endif
148
149static int __init sclp_ofb_setup(void)
150{
151#ifdef CONFIG_SCLP_OFB
152	struct kset *ofb_kset;
153	int rc;
154
155	ofb_kset = kset_create_and_add("ofb", NULL, firmware_kobj);
156	if (!ofb_kset)
157		return -ENOMEM;
158	rc = sysfs_create_bin_file(&ofb_kset->kobj, &ofb_bin_attr);
159	if (rc) {
160		kset_unregister(ofb_kset);
161		return rc;
162	}
163#endif
164	return 0;
165}
166
167static int __init sclp_conf_init(void)
168{
169	int rc;
170
171	INIT_WORK(&sclp_cpu_capability_work, sclp_cpu_capability_notify);
172	INIT_WORK(&sclp_cpu_change_work, sclp_cpu_change_notify);
173	rc = sclp_register(&sclp_conf_register);
174	if (rc)
175		return rc;
176	return sclp_ofb_setup();
177}
178
179__initcall(sclp_conf_init);
180