xref: /openbmc/linux/drivers/s390/char/sclp_config.c (revision f36e7c98)
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 
20 struct conf_mgm_data {
21 	u8 reserved;
22 	u8 ev_qualifier;
23 } __attribute__((packed));
24 
25 #define OFB_DATA_MAX 64
26 
27 struct 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 
33 struct 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 
42 static struct work_struct sclp_cpu_capability_work;
43 static struct work_struct sclp_cpu_change_work;
44 
sclp_cpu_capability_notify(struct work_struct * work)45 static 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 
sclp_cpu_change_notify(struct work_struct * work)60 static 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 
sclp_conf_receiver_fn(struct evbuf_header * evbuf)67 static 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 
82 static 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
sclp_ofb_send_req(char * ev_data,size_t len)92 static 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 	}
125 out:
126 	free_page((unsigned long)sccb);
127 	return rc;
128 }
129 
sysfs_ofb_data_write(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)130 static 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 
140 static 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 
sclp_ofb_setup(void)149 static 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 
sclp_conf_init(void)167 static 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