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 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 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 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 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 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 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 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