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